3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
32 #include "framehook.h"
37 #if !defined(HAVE_GETRUSAGE) && defined(HAVE_GETPROCESSTIMES)
41 #if defined(HAVE_TERMIOS_H)
44 #include <sys/ioctl.h>
47 #include <sys/resource.h>
48 #elif defined(HAVE_CONIO_H)
51 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
60 #if !defined(INFINITY) && defined(HUGE_VAL)
61 #define INFINITY HUGE_VAL
66 static const char program_name[] = "FFmpeg";
67 static const int program_birth_year = 2000;
69 /* select an input stream for an output stream */
70 typedef struct AVStreamMap {
74 int sync_stream_index;
77 /** select an input file for an output file */
78 typedef struct AVMetaDataMap {
83 extern const OptionDef options[];
85 static void show_help(void);
86 static void opt_show_license(void);
87 static int opt_default(const char *opt, const char *arg);
91 static AVFormatContext *input_files[MAX_FILES];
92 static int64_t input_files_ts_offset[MAX_FILES];
93 static int nb_input_files = 0;
95 static AVFormatContext *output_files[MAX_FILES];
96 static int nb_output_files = 0;
98 static AVStreamMap stream_maps[MAX_FILES];
99 static int nb_stream_maps;
101 static AVMetaDataMap meta_data_maps[MAX_FILES];
102 static int nb_meta_data_maps;
104 static AVInputFormat *file_iformat;
105 static AVOutputFormat *file_oformat;
106 static int frame_width = 0;
107 static int frame_height = 0;
108 static float frame_aspect_ratio = 0;
109 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
110 static int frame_padtop = 0;
111 static int frame_padbottom = 0;
112 static int frame_padleft = 0;
113 static int frame_padright = 0;
114 static int padcolor[3] = {16,128,128}; /* default to black */
115 static int frame_topBand = 0;
116 static int frame_bottomBand = 0;
117 static int frame_leftBand = 0;
118 static int frame_rightBand = 0;
119 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
120 static AVRational frame_rate = (AVRational) {25,1};
121 static float video_qscale = 0;
122 static int video_qdiff = 3;
123 static uint16_t *intra_matrix = NULL;
124 static uint16_t *inter_matrix = NULL;
125 #if 0 //experimental, (can be removed)
126 static float video_rc_qsquish=1.0;
127 static float video_rc_qmod_amp=0;
128 static int video_rc_qmod_freq=0;
130 static char *video_rc_override_string=NULL;
131 static char *video_rc_eq="tex^qComp";
132 static int video_disable = 0;
133 static int video_discard = 0;
134 static char *video_codec_name = NULL;
135 static int video_codec_tag = 0;
136 static int same_quality = 0;
137 static int do_deinterlace = 0;
138 static int strict = 0;
139 static int top_field_first = -1;
140 static int me_threshold = 0;
141 static int intra_dc_precision = 8;
142 static int loop_input = 0;
143 static int loop_output = AVFMT_NOOUTPUTLOOP;
144 static int qp_hist = 0;
146 static int intra_only = 0;
147 static int audio_sample_rate = 44100;
148 #define QSCALE_NONE -99999
149 static float audio_qscale = QSCALE_NONE;
150 static int audio_disable = 0;
151 static int audio_channels = 1;
152 static char *audio_codec_name = NULL;
153 static int audio_codec_tag = 0;
154 static char *audio_language = NULL;
156 static int subtitle_disable = 0;
157 static char *subtitle_codec_name = NULL;
158 static char *subtitle_language = NULL;
160 static float mux_preload= 0.5;
161 static float mux_max_delay= 0.7;
163 static int64_t recording_time = 0;
164 static int64_t start_time = 0;
165 static int64_t rec_timestamp = 0;
166 static int64_t input_ts_offset = 0;
167 static int file_overwrite = 0;
168 static char *str_title = NULL;
169 static char *str_author = NULL;
170 static char *str_copyright = NULL;
171 static char *str_comment = NULL;
172 static char *str_album = NULL;
173 static int do_benchmark = 0;
174 static int do_hex_dump = 0;
175 static int do_pkt_dump = 0;
176 static int do_psnr = 0;
177 static int do_pass = 0;
178 static char *pass_logfilename = NULL;
179 static int audio_stream_copy = 0;
180 static int video_stream_copy = 0;
181 static int subtitle_stream_copy = 0;
182 static int video_sync_method= 1;
183 static int audio_sync_method= 0;
184 static float audio_drift_threshold= 0.1;
185 static int copy_ts= 0;
186 static int opt_shortest = 0; //
187 static int video_global_header = 0;
188 static char *vstats_filename;
189 static FILE *vstats_file;
190 static int opt_programid = 0;
192 static int rate_emu = 0;
194 static int video_channel = 0;
195 static char *video_standard;
197 static int audio_volume = 256;
199 static int using_stdin = 0;
200 static int using_vhook = 0;
201 static int verbose = 1;
202 static int thread_count= 1;
203 static int q_pressed = 0;
204 static int64_t video_size = 0;
205 static int64_t audio_size = 0;
206 static int64_t extra_size = 0;
207 static int nb_frames_dup = 0;
208 static int nb_frames_drop = 0;
209 static int input_sync;
210 static uint64_t limit_filesize = 0; //
212 static int pgmyuv_compatibility_hack=0;
213 static float dts_delta_threshold = 10;
215 static int sws_flags = SWS_BICUBIC;
217 static const char **opt_names;
218 static int opt_name_count;
219 static AVCodecContext *avctx_opts[CODEC_TYPE_NB];
220 static AVFormatContext *avformat_opts;
221 static struct SwsContext *sws_opts;
222 static int64_t timer_start;
224 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
225 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
226 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
228 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
230 struct AVInputStream;
232 typedef struct AVOutputStream {
233 int file_index; /* file index */
234 int index; /* stream index in the output file */
235 int source_index; /* AVInputStream index */
236 AVStream *st; /* stream in the output file */
237 int encoding_needed; /* true if encoding needed for this stream */
239 /* input pts and corresponding output pts
241 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
242 struct AVInputStream *sync_ist; /* input stream to sync against */
243 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
246 AVFrame pict_tmp; /* temporary image for resampling */
247 struct SwsContext *img_resample_ctx; /* for image resampling */
251 int topBand; /* cropping area sizes */
255 int padtop; /* padding area sizes */
262 ReSampleContext *resample; /* for audio resampling */
263 AVFifoBuffer fifo; /* for compression: one audio fifo per codec */
267 typedef struct AVInputStream {
271 int discard; /* true if stream data should be discarded */
272 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
273 int64_t sample_index; /* current sample */
275 int64_t start; /* time when read started */
276 unsigned long frame; /* current frame */
277 int64_t next_pts; /* synthetic pts for cases where pkt.pts
279 int64_t pts; /* current pts */
280 int is_start; /* is 1 at the start and after a discontinuity */
283 typedef struct AVInputFile {
284 int eof_reached; /* true if eof reached */
285 int ist_index; /* index of first stream in ist_table */
286 int buffer_size; /* current total buffer size */
287 int nb_streams; /* nb streams we are aware of */
290 #ifdef HAVE_TERMIOS_H
292 /* init terminal so that we can grab keys */
293 static struct termios oldtty;
296 static void term_exit(void)
298 #ifdef HAVE_TERMIOS_H
299 tcsetattr (0, TCSANOW, &oldtty);
303 static volatile sig_atomic_t received_sigterm = 0;
306 sigterm_handler(int sig)
308 received_sigterm = sig;
312 static void term_init(void)
314 #ifdef HAVE_TERMIOS_H
320 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
321 |INLCR|IGNCR|ICRNL|IXON);
322 tty.c_oflag |= OPOST;
323 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
324 tty.c_cflag &= ~(CSIZE|PARENB);
329 tcsetattr (0, TCSANOW, &tty);
330 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
333 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
334 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
336 register a function to be called at normal program termination
339 #ifdef CONFIG_BEOS_NETSERVER
340 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
344 /* read a key without blocking */
345 static int read_key(void)
347 #if defined(HAVE_TERMIOS_H)
350 #ifndef CONFIG_BEOS_NETSERVER
358 n = select(1, &rfds, NULL, NULL, &tv);
367 #elif defined(HAVE_CONIO_H)
374 static int decode_interrupt_cb(void)
376 return q_pressed || (q_pressed = read_key() == 'q');
379 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
384 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
387 /* copy stream format */
388 s->nb_streams = ic->nb_streams;
389 for(i=0;i<ic->nb_streams;i++) {
392 // FIXME: a more elegant solution is needed
393 st = av_mallocz(sizeof(AVStream));
394 memcpy(st, ic->streams[i], sizeof(AVStream));
395 st->codec = avcodec_alloc_context();
396 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
400 av_close_input_file(ic);
405 get_sync_ipts(const AVOutputStream *ost)
407 const AVInputStream *ist = ost->sync_ist;
408 return (double)(ist->pts - start_time)/AV_TIME_BASE;
411 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
415 AVPacket new_pkt= *pkt;
416 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
417 &new_pkt.data, &new_pkt.size,
418 pkt->data, pkt->size,
419 pkt->flags & PKT_FLAG_KEY);
422 new_pkt.destruct= av_destruct_packet;
429 ret= av_interleaved_write_frame(s, pkt);
431 print_error("av_interleaved_write_frame()", ret);
436 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
438 static void do_audio_out(AVFormatContext *s,
441 unsigned char *buf, int size)
444 static uint8_t *audio_buf = NULL;
445 static uint8_t *audio_out = NULL;
446 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
448 int size_out, frame_bytes, ret;
449 AVCodecContext *enc= ost->st->codec;
451 /* SC: dynamic allocation of buffers */
453 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
455 audio_out = av_malloc(audio_out_size);
456 if (!audio_buf || !audio_out)
457 return; /* Should signal an error ! */
459 if(audio_sync_method){
460 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
461 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2);
462 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
463 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
465 //FIXME resample delay
466 if(fabs(delta) > 50){
467 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
469 byte_delta= FFMAX(byte_delta, -size);
473 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
478 static uint8_t *input_tmp= NULL;
479 input_tmp= av_realloc(input_tmp, byte_delta + size);
481 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
484 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
486 memset(input_tmp, 0, byte_delta);
487 memcpy(input_tmp + byte_delta, buf, size);
491 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
493 }else if(audio_sync_method>1){
494 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
495 assert(ost->audio_resample);
497 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
498 // fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2));
499 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
503 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
504 - av_fifo_size(&ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
506 if (ost->audio_resample) {
508 size_out = audio_resample(ost->resample,
509 (short *)buftmp, (short *)buf,
510 size / (ist->st->codec->channels * 2));
511 size_out = size_out * enc->channels * 2;
517 /* now encode as many frames as possible */
518 if (enc->frame_size > 1) {
519 /* output resampled raw samples */
520 av_fifo_write(&ost->fifo, buftmp, size_out);
522 frame_bytes = enc->frame_size * 2 * enc->channels;
524 while (av_fifo_read(&ost->fifo, audio_buf, frame_bytes) == 0) {
526 av_init_packet(&pkt);
528 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
531 pkt.stream_index= ost->index;
534 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
535 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
536 pkt.flags |= PKT_FLAG_KEY;
537 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
539 ost->sync_opts += enc->frame_size;
543 av_init_packet(&pkt);
545 ost->sync_opts += size_out / (2 * enc->channels);
547 /* output a pcm frame */
548 /* XXX: change encoding codec API to avoid this ? */
549 switch(enc->codec->id) {
550 case CODEC_ID_PCM_S32LE:
551 case CODEC_ID_PCM_S32BE:
552 case CODEC_ID_PCM_U32LE:
553 case CODEC_ID_PCM_U32BE:
554 size_out = size_out << 1;
556 case CODEC_ID_PCM_S24LE:
557 case CODEC_ID_PCM_S24BE:
558 case CODEC_ID_PCM_U24LE:
559 case CODEC_ID_PCM_U24BE:
560 case CODEC_ID_PCM_S24DAUD:
561 size_out = size_out / 2 * 3;
563 case CODEC_ID_PCM_S16LE:
564 case CODEC_ID_PCM_S16BE:
565 case CODEC_ID_PCM_U16LE:
566 case CODEC_ID_PCM_U16BE:
569 size_out = size_out >> 1;
572 ret = avcodec_encode_audio(enc, audio_out, size_out,
575 pkt.stream_index= ost->index;
578 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
579 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
580 pkt.flags |= PKT_FLAG_KEY;
581 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
585 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
589 AVPicture picture_tmp;
592 dec = ist->st->codec;
594 /* deinterlace : must be done before any resize */
595 if (do_deinterlace || using_vhook) {
598 /* create temporary picture */
599 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
600 buf = av_malloc(size);
604 picture2 = &picture_tmp;
605 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
608 if(avpicture_deinterlace(picture2, picture,
609 dec->pix_fmt, dec->width, dec->height) < 0) {
610 /* if error, do not deinterlace */
616 av_picture_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
623 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height,
624 1000000 * ist->pts / AV_TIME_BASE);
626 if (picture != picture2)
627 *picture = *picture2;
631 /* we begin to correct av delay at this threshold */
632 #define AV_DELAY_MAX 0.100
634 static void do_subtitle_out(AVFormatContext *s,
640 static uint8_t *subtitle_out = NULL;
641 int subtitle_out_max_size = 65536;
642 int subtitle_out_size, nb, i;
646 if (pts == AV_NOPTS_VALUE) {
647 fprintf(stderr, "Subtitle packets must have a pts\n");
651 enc = ost->st->codec;
654 subtitle_out = av_malloc(subtitle_out_max_size);
657 /* Note: DVB subtitle need one packet to draw them and one other
658 packet to clear them */
659 /* XXX: signal it in the codec context ? */
660 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
665 for(i = 0; i < nb; i++) {
666 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
667 subtitle_out_max_size, sub);
669 av_init_packet(&pkt);
670 pkt.stream_index = ost->index;
671 pkt.data = subtitle_out;
672 pkt.size = subtitle_out_size;
673 pkt.pts = av_rescale_q(pts, ist->st->time_base, ost->st->time_base);
674 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
675 /* XXX: the pts correction is handled here. Maybe handling
676 it in the codec would be better */
678 pkt.pts += 90 * sub->start_display_time;
680 pkt.pts += 90 * sub->end_display_time;
682 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
686 static int bit_buffer_size= 1024*256;
687 static uint8_t *bit_buffer= NULL;
689 static void do_video_out(AVFormatContext *s,
695 int nb_frames, i, ret;
696 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
697 AVFrame picture_crop_temp, picture_pad_temp;
698 AVCodecContext *enc, *dec;
700 avcodec_get_frame_defaults(&picture_crop_temp);
701 avcodec_get_frame_defaults(&picture_pad_temp);
703 enc = ost->st->codec;
704 dec = ist->st->codec;
706 /* by default, we output a single frame */
711 if(video_sync_method){
713 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
714 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
717 else if (vdelta > 1.1)
718 nb_frames = lrintf(vdelta);
719 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
723 fprintf(stderr, "*** drop!\n");
724 }else if (nb_frames > 1) {
725 nb_frames_dup += nb_frames;
727 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
730 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
732 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
736 if (ost->video_crop) {
737 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
738 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
741 formatted_picture = &picture_crop_temp;
743 formatted_picture = in_picture;
746 final_picture = formatted_picture;
747 padding_src = formatted_picture;
748 resampling_dst = &ost->pict_tmp;
749 if (ost->video_pad) {
750 final_picture = &ost->pict_tmp;
751 if (ost->video_resample) {
752 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
753 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
756 resampling_dst = &picture_pad_temp;
760 if (ost->video_resample) {
762 final_picture = &ost->pict_tmp;
763 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
764 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
767 if (ost->video_pad) {
768 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
769 enc->height, enc->width, enc->pix_fmt,
770 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
773 /* duplicates frame if needed */
774 for(i=0;i<nb_frames;i++) {
776 av_init_packet(&pkt);
777 pkt.stream_index= ost->index;
779 if (s->oformat->flags & AVFMT_RAWPICTURE) {
780 /* raw pictures are written as AVPicture structure to
781 avoid any copies. We support temorarily the older
783 AVFrame* old_frame = enc->coded_frame;
784 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
785 pkt.data= (uint8_t *)final_picture;
786 pkt.size= sizeof(AVPicture);
787 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
788 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
789 if(dec->coded_frame && dec->coded_frame->key_frame)
790 pkt.flags |= PKT_FLAG_KEY;
792 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
793 enc->coded_frame = old_frame;
797 big_picture= *final_picture;
798 /* better than nothing: use input picture interlaced
800 big_picture.interlaced_frame = in_picture->interlaced_frame;
801 if(avctx_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
802 if(top_field_first == -1)
803 big_picture.top_field_first = in_picture->top_field_first;
805 big_picture.top_field_first = top_field_first;
808 /* handles sameq here. This is not correct because it may
809 not be a global option */
811 big_picture.quality = ist->st->quality;
813 big_picture.quality = ost->st->quality;
815 big_picture.pict_type = 0;
816 // big_picture.pts = AV_NOPTS_VALUE;
817 big_picture.pts= ost->sync_opts;
818 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
819 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
820 ret = avcodec_encode_video(enc,
821 bit_buffer, bit_buffer_size,
824 fprintf(stderr, "Video encoding failed\n");
827 //enc->frame_number = enc->real_pict_num;
829 pkt.data= bit_buffer;
831 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
832 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
833 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
834 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
835 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
837 if(enc->coded_frame && enc->coded_frame->key_frame)
838 pkt.flags |= PKT_FLAG_KEY;
839 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
841 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
842 // enc->frame_number-1, enc->real_pict_num, ret,
844 /* if two pass, output log */
845 if (ost->logfile && enc->stats_out) {
846 fprintf(ost->logfile, "%s", enc->stats_out);
855 static double psnr(double d){
856 if(d==0) return INFINITY;
857 return -10.0*log(d)/log(10.0);
860 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
865 double ti1, bitrate, avg_bitrate;
867 /* this is executed just the first time do_video_stats is called */
869 vstats_file = fopen(vstats_filename, "w");
876 enc = ost->st->codec;
877 if (enc->codec_type == CODEC_TYPE_VIDEO) {
878 frame_number = ost->frame_number;
879 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
880 if (enc->flags&CODEC_FLAG_PSNR)
881 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
883 fprintf(vstats_file,"f_size= %6d ", frame_size);
884 /* compute pts value */
885 ti1 = ost->sync_opts * av_q2d(enc->time_base);
889 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
890 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
891 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
892 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
893 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
897 static void print_report(AVFormatContext **output_files,
898 AVOutputStream **ost_table, int nb_ostreams,
903 AVFormatContext *oc, *os;
906 int frame_number, vid, i;
907 double bitrate, ti1, pts;
908 static int64_t last_time = -1;
909 static int qp_histogram[52];
911 if (!is_last_report) {
913 /* display the report every 0.5 seconds */
914 cur_time = av_gettime();
915 if (last_time == -1) {
916 last_time = cur_time;
919 if ((cur_time - last_time) < 500000)
921 last_time = cur_time;
925 oc = output_files[0];
927 total_size = url_fsize(&oc->pb);
928 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
929 total_size= url_ftell(&oc->pb);
934 for(i=0;i<nb_ostreams;i++) {
936 os = output_files[ost->file_index];
937 enc = ost->st->codec;
938 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
939 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
940 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
942 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
943 float t = (av_gettime()-timer_start) / 1000000.0;
945 frame_number = ost->frame_number;
946 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
947 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
948 enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
950 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
951 if(qp_hist && enc->coded_frame){
953 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
954 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
957 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
959 if (enc->flags&CODEC_FLAG_PSNR){
961 double error, error_sum=0;
962 double scale, scale_sum=0;
963 char type[3]= {'Y','U','V'};
964 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
967 error= enc->error[j];
968 scale= enc->width*enc->height*255.0*255.0*frame_number;
970 error= enc->coded_frame->error[j];
971 scale= enc->width*enc->height*255.0*255.0;
976 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
978 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
982 /* compute min output value */
983 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
984 if ((pts < ti1) && (pts > 0))
990 if (verbose || is_last_report) {
991 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
993 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
994 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
995 (double)total_size / 1024, ti1, bitrate);
998 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
999 nb_frames_dup, nb_frames_drop);
1002 fprintf(stderr, "%s \r", buf);
1007 if (is_last_report && verbose >= 0){
1008 int64_t raw= audio_size + video_size + extra_size;
1009 fprintf(stderr, "\n");
1010 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1014 100.0*(total_size - raw)/raw
1019 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1020 static int output_packet(AVInputStream *ist, int ist_index,
1021 AVOutputStream **ost_table, int nb_ostreams,
1022 const AVPacket *pkt)
1024 AVFormatContext *os;
1025 AVOutputStream *ost;
1029 int data_size, got_picture;
1031 void *buffer_to_free;
1032 static unsigned int samples_size= 0;
1033 static short *samples= NULL;
1034 AVSubtitle subtitle, *subtitle_to_free;
1038 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1039 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1040 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1042 // assert(ist->pts == ist->next_pts);
1056 /* decode the packet if needed */
1057 data_buf = NULL; /* fail safe */
1059 subtitle_to_free = NULL;
1060 if (ist->decoding_needed) {
1061 switch(ist->st->codec->codec_type) {
1062 case CODEC_TYPE_AUDIO:{
1064 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE));
1065 data_size= samples_size;
1066 /* XXX: could avoid copy if PCM 16 bits with same
1067 endianness as CPU */
1068 ret = avcodec_decode_audio2(ist->st->codec, samples, &data_size,
1074 /* Some bug in mpeg audio decoder gives */
1075 /* data_size < 0, it seems they are overflows */
1076 if (data_size <= 0) {
1077 /* no audio frame */
1080 data_buf = (uint8_t *)samples;
1081 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1082 (ist->st->codec->sample_rate * ist->st->codec->channels);
1084 case CODEC_TYPE_VIDEO:
1085 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1086 /* XXX: allocate picture correctly */
1087 avcodec_get_frame_defaults(&picture);
1089 ret = avcodec_decode_video(ist->st->codec,
1090 &picture, &got_picture, ptr, len);
1091 ist->st->quality= picture.quality;
1095 /* no picture yet */
1096 goto discard_packet;
1098 if (ist->st->codec->time_base.num != 0) {
1099 ist->next_pts += ((int64_t)AV_TIME_BASE *
1100 ist->st->codec->time_base.num) /
1101 ist->st->codec->time_base.den;
1105 case CODEC_TYPE_SUBTITLE:
1106 ret = avcodec_decode_subtitle(ist->st->codec,
1107 &subtitle, &got_subtitle, ptr, len);
1110 if (!got_subtitle) {
1111 goto discard_packet;
1113 subtitle_to_free = &subtitle;
1120 switch(ist->st->codec->codec_type) {
1121 case CODEC_TYPE_AUDIO:
1122 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1123 (ist->st->codec->sample_rate * ist->st->codec->channels);
1125 case CODEC_TYPE_VIDEO:
1126 if (ist->st->codec->time_base.num != 0) {
1127 ist->next_pts += ((int64_t)AV_TIME_BASE *
1128 ist->st->codec->time_base.num) /
1129 ist->st->codec->time_base.den;
1139 buffer_to_free = NULL;
1140 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1141 pre_process_video_frame(ist, (AVPicture *)&picture,
1145 // preprocess audio (volume)
1146 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1147 if (audio_volume != 256) {
1150 for(i=0;i<(data_size / sizeof(short));i++) {
1151 int v = ((*volp) * audio_volume + 128) >> 8;
1152 if (v < -32768) v = -32768;
1153 if (v > 32767) v = 32767;
1159 /* frame rate emulation */
1160 if (ist->st->codec->rate_emu) {
1161 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1162 int64_t now = av_gettime() - ist->start;
1170 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1171 is the one of the next displayed one */
1172 /* XXX: add mpeg4 too ? */
1173 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1174 if (ist->st->codec->pict_type != B_TYPE) {
1176 tmp = ist->last_ip_pts;
1177 ist->last_ip_pts = ist->frac_pts.val;
1178 ist->frac_pts.val = tmp;
1182 /* if output time reached then transcode raw format,
1183 encode packets and output them */
1184 if (start_time == 0 || ist->pts >= start_time)
1185 for(i=0;i<nb_ostreams;i++) {
1189 if (ost->source_index == ist_index) {
1190 os = output_files[ost->file_index];
1193 printf("%d: got pts=%0.3f %0.3f\n", i,
1194 (double)pkt->pts / AV_TIME_BASE,
1195 ((double)ist->pts / AV_TIME_BASE) -
1196 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1198 /* set the input output pts pairs */
1199 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1201 if (ost->encoding_needed) {
1202 switch(ost->st->codec->codec_type) {
1203 case CODEC_TYPE_AUDIO:
1204 do_audio_out(os, ost, ist, data_buf, data_size);
1206 case CODEC_TYPE_VIDEO:
1207 do_video_out(os, ost, ist, &picture, &frame_size);
1208 video_size += frame_size;
1209 if (vstats_filename && frame_size)
1210 do_video_stats(os, ost, frame_size);
1212 case CODEC_TYPE_SUBTITLE:
1213 do_subtitle_out(os, ost, ist, &subtitle,
1220 AVFrame avframe; //FIXME/XXX remove this
1222 av_init_packet(&opkt);
1224 if (!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY))
1227 /* no reencoding needed : output the packet directly */
1228 /* force the input stream PTS */
1230 avcodec_get_frame_defaults(&avframe);
1231 ost->st->codec->coded_frame= &avframe;
1232 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1234 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1235 audio_size += data_size;
1236 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1237 video_size += data_size;
1241 opkt.stream_index= ost->index;
1242 if(pkt->pts != AV_NOPTS_VALUE)
1243 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base);
1245 opkt.pts= AV_NOPTS_VALUE;
1247 if (pkt->dts == AV_NOPTS_VALUE)
1248 opkt.dts = av_rescale_q(ist->next_pts, AV_TIME_BASE_Q, ost->st->time_base);
1250 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1252 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1253 opkt.flags= pkt->flags;
1255 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1256 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1257 opkt.destruct= av_destruct_packet;
1259 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1260 ost->st->codec->frame_number++;
1261 ost->frame_number++;
1262 av_free_packet(&opkt);
1266 av_free(buffer_to_free);
1267 /* XXX: allocate the subtitles in the codec ? */
1268 if (subtitle_to_free) {
1269 if (subtitle_to_free->rects != NULL) {
1270 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1271 av_free(subtitle_to_free->rects[i].bitmap);
1272 av_free(subtitle_to_free->rects[i].rgba_palette);
1274 av_freep(&subtitle_to_free->rects);
1276 subtitle_to_free->num_rects = 0;
1277 subtitle_to_free = NULL;
1284 for(i=0;i<nb_ostreams;i++) {
1286 if (ost->source_index == ist_index) {
1287 AVCodecContext *enc= ost->st->codec;
1288 os = output_files[ost->file_index];
1290 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1292 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1295 if (ost->encoding_needed) {
1299 av_init_packet(&pkt);
1300 pkt.stream_index= ost->index;
1302 switch(ost->st->codec->codec_type) {
1303 case CODEC_TYPE_AUDIO:
1304 fifo_bytes = av_fifo_size(&ost->fifo);
1306 /* encode any samples remaining in fifo */
1307 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1308 int fs_tmp = enc->frame_size;
1309 enc->frame_size = fifo_bytes / (2 * enc->channels);
1310 if(av_fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes) == 0) {
1311 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1313 enc->frame_size = fs_tmp;
1316 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1319 pkt.flags |= PKT_FLAG_KEY;
1321 case CODEC_TYPE_VIDEO:
1322 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1324 if(enc->coded_frame && enc->coded_frame->key_frame)
1325 pkt.flags |= PKT_FLAG_KEY;
1326 if (ost->logfile && enc->stats_out) {
1327 fprintf(ost->logfile, "%s", enc->stats_out);
1336 pkt.data= bit_buffer;
1338 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1339 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1340 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1352 static void print_sdp(AVFormatContext **avc, int n)
1356 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1357 printf("SDP:\n%s\n", sdp);
1360 static int stream_index_from_inputs(AVFormatContext **input_files,
1362 AVInputFile *file_table,
1363 AVInputStream **ist_table,
1364 enum CodecType type,
1368 for(z=0; z<nb_input_files; z++) {
1369 AVFormatContext *ic = input_files[z];
1370 for(p=0; p<ic->nb_programs; p++) {
1371 AVProgram *program = ic->programs[p];
1372 if(program->id != programid)
1374 for(q=0; q<program->nb_stream_indexes; q++) {
1375 int sidx = program->stream_index[q];
1376 int ris = file_table[z].ist_index + sidx;
1377 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1387 * The following code is the main loop of the file converter
1389 static int av_encode(AVFormatContext **output_files,
1390 int nb_output_files,
1391 AVFormatContext **input_files,
1393 AVStreamMap *stream_maps, int nb_stream_maps)
1395 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1396 AVFormatContext *is, *os;
1397 AVCodecContext *codec, *icodec;
1398 AVOutputStream *ost, **ost_table = NULL;
1399 AVInputStream *ist, **ist_table = NULL;
1400 AVInputFile *file_table;
1404 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1408 /* input stream init */
1410 for(i=0;i<nb_input_files;i++) {
1411 is = input_files[i];
1412 file_table[i].ist_index = j;
1413 file_table[i].nb_streams = is->nb_streams;
1414 j += is->nb_streams;
1418 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1422 for(i=0;i<nb_istreams;i++) {
1423 ist = av_mallocz(sizeof(AVInputStream));
1429 for(i=0;i<nb_input_files;i++) {
1430 is = input_files[i];
1431 for(k=0;k<is->nb_streams;k++) {
1432 ist = ist_table[j++];
1433 ist->st = is->streams[k];
1434 ist->file_index = i;
1436 ist->discard = 1; /* the stream is discarded by default
1439 if (ist->st->codec->rate_emu) {
1440 ist->start = av_gettime();
1446 /* output stream init */
1448 for(i=0;i<nb_output_files;i++) {
1449 os = output_files[i];
1450 if (!os->nb_streams) {
1451 fprintf(stderr, "Output file does not contain any stream\n");
1454 nb_ostreams += os->nb_streams;
1456 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1457 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1461 /* Sanity check the mapping args -- do the input files & streams exist? */
1462 for(i=0;i<nb_stream_maps;i++) {
1463 int fi = stream_maps[i].file_index;
1464 int si = stream_maps[i].stream_index;
1466 if (fi < 0 || fi > nb_input_files - 1 ||
1467 si < 0 || si > file_table[fi].nb_streams - 1) {
1468 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1471 fi = stream_maps[i].sync_file_index;
1472 si = stream_maps[i].sync_stream_index;
1473 if (fi < 0 || fi > nb_input_files - 1 ||
1474 si < 0 || si > file_table[fi].nb_streams - 1) {
1475 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1480 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1483 for(i=0;i<nb_ostreams;i++) {
1484 ost = av_mallocz(sizeof(AVOutputStream));
1491 for(k=0;k<nb_output_files;k++) {
1492 os = output_files[k];
1493 for(i=0;i<os->nb_streams;i++) {
1495 ost = ost_table[n++];
1496 ost->file_index = k;
1498 ost->st = os->streams[i];
1499 if (nb_stream_maps > 0) {
1500 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1501 stream_maps[n-1].stream_index;
1503 /* Sanity check that the stream types match */
1504 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1505 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1506 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1507 ost->file_index, ost->index);
1514 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1516 ost->source_index = j;
1520 /* get corresponding input stream index : we select the first one with the right type */
1522 for(j=0;j<nb_istreams;j++) {
1525 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1526 ost->source_index = j;
1534 if(! opt_programid) {
1535 /* try again and reuse existing stream */
1536 for(j=0;j<nb_istreams;j++) {
1538 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1539 ost->source_index = j;
1545 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1546 ost->file_index, ost->index);
1551 ist = ist_table[ost->source_index];
1553 ost->sync_ist = (nb_stream_maps > 0) ?
1554 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1555 stream_maps[n-1].sync_stream_index] : ist;
1559 /* for each output stream, we compute the right encoding parameters */
1560 for(i=0;i<nb_ostreams;i++) {
1562 os = output_files[ost->file_index];
1563 ist = ist_table[ost->source_index];
1565 codec = ost->st->codec;
1566 icodec = ist->st->codec;
1568 if (!ost->st->language[0])
1569 av_strlcpy(ost->st->language, ist->st->language,
1570 sizeof(ost->st->language));
1572 if (ost->st->stream_copy) {
1573 /* if stream_copy is selected, no need to decode or encode */
1574 codec->codec_id = icodec->codec_id;
1575 codec->codec_type = icodec->codec_type;
1577 if(!codec->codec_tag){
1578 if( !os->oformat->codec_tag
1579 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) > 0
1580 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1581 codec->codec_tag = icodec->codec_tag;
1584 codec->bit_rate = icodec->bit_rate;
1585 codec->extradata= icodec->extradata;
1586 codec->extradata_size= icodec->extradata_size;
1587 if(av_q2d(icodec->time_base) > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000)
1588 codec->time_base = icodec->time_base;
1590 codec->time_base = ist->st->time_base;
1591 switch(codec->codec_type) {
1592 case CODEC_TYPE_AUDIO:
1593 codec->sample_rate = icodec->sample_rate;
1594 codec->channels = icodec->channels;
1595 codec->frame_size = icodec->frame_size;
1596 codec->block_align= icodec->block_align;
1597 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1598 codec->block_align= 0;
1600 case CODEC_TYPE_VIDEO:
1602 fprintf(stderr,"-vcodec copy and -vhook are incompatible (frames are not decoded)\n");
1605 codec->pix_fmt = icodec->pix_fmt;
1606 codec->width = icodec->width;
1607 codec->height = icodec->height;
1608 codec->has_b_frames = icodec->has_b_frames;
1610 case CODEC_TYPE_SUBTITLE:
1616 switch(codec->codec_type) {
1617 case CODEC_TYPE_AUDIO:
1618 if (av_fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1621 if (codec->channels == icodec->channels &&
1622 codec->sample_rate == icodec->sample_rate) {
1623 ost->audio_resample = 0;
1625 if (codec->channels != icodec->channels &&
1626 (icodec->codec_id == CODEC_ID_AC3 ||
1627 icodec->codec_id == CODEC_ID_DTS)) {
1628 /* Special case for 5:1 AC3 and DTS input */
1629 /* and mono or stereo output */
1630 /* Request specific number of channels */
1631 icodec->channels = codec->channels;
1632 if (codec->sample_rate == icodec->sample_rate)
1633 ost->audio_resample = 0;
1635 ost->audio_resample = 1;
1638 ost->audio_resample = 1;
1641 if(audio_sync_method>1)
1642 ost->audio_resample = 1;
1644 if(ost->audio_resample){
1645 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1646 codec->sample_rate, icodec->sample_rate);
1648 printf("Can't resample. Aborting.\n");
1652 ist->decoding_needed = 1;
1653 ost->encoding_needed = 1;
1655 case CODEC_TYPE_VIDEO:
1656 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1657 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1658 ost->video_resample = ((codec->width != icodec->width -
1659 (frame_leftBand + frame_rightBand) +
1660 (frame_padleft + frame_padright)) ||
1661 (codec->height != icodec->height -
1662 (frame_topBand + frame_bottomBand) +
1663 (frame_padtop + frame_padbottom)) ||
1664 (codec->pix_fmt != icodec->pix_fmt));
1665 if (ost->video_crop) {
1666 ost->topBand = frame_topBand;
1667 ost->leftBand = frame_leftBand;
1669 if (ost->video_pad) {
1670 ost->padtop = frame_padtop;
1671 ost->padleft = frame_padleft;
1672 ost->padbottom = frame_padbottom;
1673 ost->padright = frame_padright;
1674 if (!ost->video_resample) {
1675 avcodec_get_frame_defaults(&ost->pict_tmp);
1676 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1677 codec->width, codec->height ) )
1681 if (ost->video_resample) {
1682 avcodec_get_frame_defaults(&ost->pict_tmp);
1683 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1684 codec->width, codec->height ) ) {
1685 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1688 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1689 ost->img_resample_ctx = sws_getContext(
1690 icodec->width - (frame_leftBand + frame_rightBand),
1691 icodec->height - (frame_topBand + frame_bottomBand),
1693 codec->width - (frame_padleft + frame_padright),
1694 codec->height - (frame_padtop + frame_padbottom),
1696 sws_flags, NULL, NULL, NULL);
1697 if (ost->img_resample_ctx == NULL) {
1698 fprintf(stderr, "Cannot get resampling context\n");
1701 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1703 ost->encoding_needed = 1;
1704 ist->decoding_needed = 1;
1706 case CODEC_TYPE_SUBTITLE:
1707 ost->encoding_needed = 1;
1708 ist->decoding_needed = 1;
1715 if (ost->encoding_needed &&
1716 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1717 char logfilename[1024];
1722 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1724 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1725 if (codec->flags & CODEC_FLAG_PASS1) {
1726 f = fopen(logfilename, "w");
1728 perror(logfilename);
1733 /* read the log file */
1734 f = fopen(logfilename, "r");
1736 perror(logfilename);
1739 fseek(f, 0, SEEK_END);
1741 fseek(f, 0, SEEK_SET);
1742 logbuffer = av_malloc(size + 1);
1744 fprintf(stderr, "Could not allocate log buffer\n");
1747 size = fread(logbuffer, 1, size, f);
1749 logbuffer[size] = '\0';
1750 codec->stats_in = logbuffer;
1754 if(codec->codec_type == CODEC_TYPE_VIDEO){
1755 int size= codec->width * codec->height;
1756 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1761 bit_buffer = av_malloc(bit_buffer_size);
1765 /* dump the file output parameters - cannot be done before in case
1767 for(i=0;i<nb_output_files;i++) {
1768 dump_format(output_files[i], i, output_files[i]->filename, 1);
1771 /* dump the stream mapping */
1773 fprintf(stderr, "Stream mapping:\n");
1774 for(i=0;i<nb_ostreams;i++) {
1776 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1777 ist_table[ost->source_index]->file_index,
1778 ist_table[ost->source_index]->index,
1781 if (ost->sync_ist != ist_table[ost->source_index])
1782 fprintf(stderr, " [sync #%d.%d]",
1783 ost->sync_ist->file_index,
1784 ost->sync_ist->index);
1785 fprintf(stderr, "\n");
1789 /* open each encoder */
1790 for(i=0;i<nb_ostreams;i++) {
1792 if (ost->encoding_needed) {
1794 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1796 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1797 ost->file_index, ost->index);
1800 if (avcodec_open(ost->st->codec, codec) < 0) {
1801 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1802 ost->file_index, ost->index);
1805 extra_size += ost->st->codec->extradata_size;
1809 /* open each decoder */
1810 for(i=0;i<nb_istreams;i++) {
1812 if (ist->decoding_needed) {
1814 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1816 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1817 ist->st->codec->codec_id, ist->file_index, ist->index);
1820 if (avcodec_open(ist->st->codec, codec) < 0) {
1821 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1822 ist->file_index, ist->index);
1825 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1826 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1831 for(i=0;i<nb_istreams;i++) {
1833 is = input_files[ist->file_index];
1836 if( input_files_ts_offset[ist->file_index] != -is->start_time
1837 && !(is->start_time == AV_NOPTS_VALUE && input_files_ts_offset[ist->file_index]==0))
1838 ist->next_pts= AV_NOPTS_VALUE;
1842 /* set meta data information from input file if required */
1843 for (i=0;i<nb_meta_data_maps;i++) {
1844 AVFormatContext *out_file;
1845 AVFormatContext *in_file;
1847 int out_file_index = meta_data_maps[i].out_file;
1848 int in_file_index = meta_data_maps[i].in_file;
1849 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1850 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1851 ret = AVERROR(EINVAL);
1854 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1855 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1856 ret = AVERROR(EINVAL);
1860 out_file = output_files[out_file_index];
1861 in_file = input_files[in_file_index];
1863 strcpy(out_file->title, in_file->title);
1864 strcpy(out_file->author, in_file->author);
1865 strcpy(out_file->copyright, in_file->copyright);
1866 strcpy(out_file->comment, in_file->comment);
1867 strcpy(out_file->album, in_file->album);
1868 out_file->year = in_file->year;
1869 out_file->track = in_file->track;
1870 strcpy(out_file->genre, in_file->genre);
1873 /* open files and write file headers */
1874 for(i=0;i<nb_output_files;i++) {
1875 os = output_files[i];
1876 if (av_write_header(os) < 0) {
1877 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1878 ret = AVERROR(EINVAL);
1881 if (strcmp(output_files[i]->oformat->name, "rtp")) {
1886 print_sdp(output_files, nb_output_files);
1889 if ( !using_stdin && verbose >= 0) {
1890 fprintf(stderr, "Press [q] to stop encoding\n");
1891 url_set_interrupt_cb(decode_interrupt_cb);
1896 timer_start = av_gettime();
1898 for(; received_sigterm == 0;) {
1899 int file_index, ist_index;
1907 /* if 'q' pressed, exits */
1911 /* read_key() returns 0 on EOF */
1917 /* select the stream that we must read now by looking at the
1918 smallest output pts */
1920 for(i=0;i<nb_ostreams;i++) {
1923 os = output_files[ost->file_index];
1924 ist = ist_table[ost->source_index];
1925 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1926 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1928 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1929 ipts = (double)ist->pts;
1930 if (!file_table[ist->file_index].eof_reached){
1931 if(ipts < ipts_min) {
1933 if(input_sync ) file_index = ist->file_index;
1935 if(opts < opts_min) {
1937 if(!input_sync) file_index = ist->file_index;
1940 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1945 /* if none, if is finished */
1946 if (file_index < 0) {
1950 /* finish if recording time exhausted */
1951 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1954 /* finish if limit size exhausted */
1955 if (limit_filesize != 0 && limit_filesize < url_ftell(&output_files[0]->pb))
1958 /* read a frame from it and output it in the fifo */
1959 is = input_files[file_index];
1960 if (av_read_frame(is, &pkt) < 0) {
1961 file_table[file_index].eof_reached = 1;
1969 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
1971 /* the following test is needed in case new streams appear
1972 dynamically in stream : we ignore them */
1973 if (pkt.stream_index >= file_table[file_index].nb_streams)
1974 goto discard_packet;
1975 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1976 ist = ist_table[ist_index];
1978 goto discard_packet;
1980 if (pkt.dts != AV_NOPTS_VALUE)
1981 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1982 if (pkt.pts != AV_NOPTS_VALUE)
1983 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
1985 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1986 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1987 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
1988 int64_t delta= pkt_dts - ist->next_pts;
1989 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
1990 input_files_ts_offset[ist->file_index]-= delta;
1992 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1993 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1994 if(pkt.pts != AV_NOPTS_VALUE)
1995 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
1999 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2000 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2003 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2004 ist->file_index, ist->index);
2006 av_free_packet(&pkt);
2011 av_free_packet(&pkt);
2013 /* dump report by using the output first video and audio streams */
2014 print_report(output_files, ost_table, nb_ostreams, 0);
2017 /* at the end of stream, we must flush the decoder buffers */
2018 for(i=0;i<nb_istreams;i++) {
2020 if (ist->decoding_needed) {
2021 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2027 /* write the trailer if needed and close file */
2028 for(i=0;i<nb_output_files;i++) {
2029 os = output_files[i];
2030 av_write_trailer(os);
2033 /* dump report by using the first video and audio streams */
2034 print_report(output_files, ost_table, nb_ostreams, 1);
2036 /* close each encoder */
2037 for(i=0;i<nb_ostreams;i++) {
2039 if (ost->encoding_needed) {
2040 av_freep(&ost->st->codec->stats_in);
2041 avcodec_close(ost->st->codec);
2045 /* close each decoder */
2046 for(i=0;i<nb_istreams;i++) {
2048 if (ist->decoding_needed) {
2049 avcodec_close(ist->st->codec);
2057 av_freep(&bit_buffer);
2058 av_free(file_table);
2061 for(i=0;i<nb_istreams;i++) {
2068 for(i=0;i<nb_ostreams;i++) {
2072 fclose(ost->logfile);
2073 ost->logfile = NULL;
2075 av_fifo_free(&ost->fifo); /* works even if fifo is not
2076 initialized but set to zero */
2077 av_free(ost->pict_tmp.data[0]);
2078 if (ost->video_resample)
2079 sws_freeContext(ost->img_resample_ctx);
2080 if (ost->audio_resample)
2081 audio_resample_close(ost->resample);
2089 ret = AVERROR(ENOMEM);
2094 int file_read(const char *filename)
2097 unsigned char buffer[1024];
2100 if (url_open(&h, filename, O_RDONLY) < 0) {
2101 printf("could not open '%s'\n", filename);
2105 len = url_read(h, buffer, sizeof(buffer));
2108 for(i=0;i<len;i++) putchar(buffer[i]);
2115 static void opt_format(const char *arg)
2117 /* compatibility stuff for pgmyuv */
2118 if (!strcmp(arg, "pgmyuv")) {
2119 pgmyuv_compatibility_hack=1;
2120 // opt_image_format(arg);
2122 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2125 file_iformat = av_find_input_format(arg);
2126 file_oformat = guess_format(arg, NULL, NULL);
2127 if (!file_iformat && !file_oformat) {
2128 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2133 static void opt_video_rc_eq(char *arg)
2138 static void opt_video_rc_override_string(char *arg)
2140 video_rc_override_string = arg;
2143 static void opt_me_threshold(const char *arg)
2145 me_threshold = atoi(arg);
2148 static void opt_verbose(const char *arg)
2150 verbose = atoi(arg);
2151 av_log_level = atoi(arg);
2154 static void opt_frame_rate(const char *arg)
2156 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2157 fprintf(stderr, "Incorrect frame rate\n");
2162 static void opt_frame_crop_top(const char *arg)
2164 frame_topBand = atoi(arg);
2165 if (frame_topBand < 0) {
2166 fprintf(stderr, "Incorrect top crop size\n");
2169 if ((frame_topBand % 2) != 0) {
2170 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2173 if ((frame_topBand) >= frame_height){
2174 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2177 frame_height -= frame_topBand;
2180 static void opt_frame_crop_bottom(const char *arg)
2182 frame_bottomBand = atoi(arg);
2183 if (frame_bottomBand < 0) {
2184 fprintf(stderr, "Incorrect bottom crop size\n");
2187 if ((frame_bottomBand % 2) != 0) {
2188 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2191 if ((frame_bottomBand) >= frame_height){
2192 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2195 frame_height -= frame_bottomBand;
2198 static void opt_frame_crop_left(const char *arg)
2200 frame_leftBand = atoi(arg);
2201 if (frame_leftBand < 0) {
2202 fprintf(stderr, "Incorrect left crop size\n");
2205 if ((frame_leftBand % 2) != 0) {
2206 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2209 if ((frame_leftBand) >= frame_width){
2210 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2213 frame_width -= frame_leftBand;
2216 static void opt_frame_crop_right(const char *arg)
2218 frame_rightBand = atoi(arg);
2219 if (frame_rightBand < 0) {
2220 fprintf(stderr, "Incorrect right crop size\n");
2223 if ((frame_rightBand % 2) != 0) {
2224 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2227 if ((frame_rightBand) >= frame_width){
2228 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2231 frame_width -= frame_rightBand;
2234 static void opt_frame_size(const char *arg)
2236 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2237 fprintf(stderr, "Incorrect frame size\n");
2240 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2241 fprintf(stderr, "Frame size must be a multiple of 2\n");
2247 #define SCALEBITS 10
2248 #define ONE_HALF (1 << (SCALEBITS - 1))
2249 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2251 #define RGB_TO_Y(r, g, b) \
2252 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2253 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2255 #define RGB_TO_U(r1, g1, b1, shift)\
2256 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2257 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2259 #define RGB_TO_V(r1, g1, b1, shift)\
2260 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2261 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2263 static void opt_pad_color(const char *arg) {
2264 /* Input is expected to be six hex digits similar to
2265 how colors are expressed in html tags (but without the #) */
2266 int rgb = strtol(arg, NULL, 16);
2270 g = ((rgb >> 8) & 255);
2273 padcolor[0] = RGB_TO_Y(r,g,b);
2274 padcolor[1] = RGB_TO_U(r,g,b,0);
2275 padcolor[2] = RGB_TO_V(r,g,b,0);
2278 static void opt_frame_pad_top(const char *arg)
2280 frame_padtop = atoi(arg);
2281 if (frame_padtop < 0) {
2282 fprintf(stderr, "Incorrect top pad size\n");
2285 if ((frame_padtop % 2) != 0) {
2286 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2291 static void opt_frame_pad_bottom(const char *arg)
2293 frame_padbottom = atoi(arg);
2294 if (frame_padbottom < 0) {
2295 fprintf(stderr, "Incorrect bottom pad size\n");
2298 if ((frame_padbottom % 2) != 0) {
2299 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2305 static void opt_frame_pad_left(const char *arg)
2307 frame_padleft = atoi(arg);
2308 if (frame_padleft < 0) {
2309 fprintf(stderr, "Incorrect left pad size\n");
2312 if ((frame_padleft % 2) != 0) {
2313 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2319 static void opt_frame_pad_right(const char *arg)
2321 frame_padright = atoi(arg);
2322 if (frame_padright < 0) {
2323 fprintf(stderr, "Incorrect right pad size\n");
2326 if ((frame_padright % 2) != 0) {
2327 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2332 void list_pix_fmts(void)
2335 char pix_fmt_str[128];
2336 for (i=-1; i < PIX_FMT_NB; i++) {
2337 avcodec_pix_fmt_string (pix_fmt_str, sizeof(pix_fmt_str), i);
2338 fprintf(stdout, "%s\n", pix_fmt_str);
2342 static void opt_frame_pix_fmt(const char *arg)
2344 if (strcmp(arg, "list"))
2345 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2352 static void opt_frame_aspect_ratio(const char *arg)
2358 p = strchr(arg, ':');
2360 x = strtol(arg, (char **)&arg, 10);
2362 y = strtol(arg+1, (char **)&arg, 10);
2364 ar = (double)x / (double)y;
2366 ar = strtod(arg, (char **)&arg);
2369 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2372 frame_aspect_ratio = ar;
2375 static void opt_qscale(const char *arg)
2377 video_qscale = atof(arg);
2378 if (video_qscale <= 0 ||
2379 video_qscale > 255) {
2380 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2385 static void opt_qdiff(const char *arg)
2387 video_qdiff = atoi(arg);
2388 if (video_qdiff < 0 ||
2390 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2395 static void opt_strict(const char *arg)
2400 static void opt_top_field_first(const char *arg)
2402 top_field_first= atoi(arg);
2405 static void opt_thread_count(const char *arg)
2407 thread_count= atoi(arg);
2408 #if !defined(HAVE_THREADS)
2410 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2414 static void opt_audio_rate(const char *arg)
2416 audio_sample_rate = atoi(arg);
2419 static void opt_audio_channels(const char *arg)
2421 audio_channels = atoi(arg);
2424 static void opt_video_channel(const char *arg)
2426 video_channel = strtol(arg, NULL, 0);
2429 static void opt_video_standard(const char *arg)
2431 video_standard = av_strdup(arg);
2434 static void opt_codec(int *pstream_copy, char **pcodec_name,
2435 int codec_type, const char *arg)
2437 av_freep(pcodec_name);
2438 if (!strcmp(arg, "copy")) {
2441 *pcodec_name = av_strdup(arg);
2445 static void opt_audio_codec(const char *arg)
2447 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2450 static void opt_audio_tag(const char *arg)
2453 audio_codec_tag= strtol(arg, &tail, 0);
2456 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2459 static void opt_video_tag(const char *arg)
2462 video_codec_tag= strtol(arg, &tail, 0);
2465 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2469 static void add_frame_hooker(const char *arg)
2474 char *args = av_strdup(arg);
2478 argv[0] = strtok(args, " ");
2479 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2482 i = frame_hook_add(argc, argv);
2485 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2491 static void opt_video_codec(const char *arg)
2493 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2496 static void opt_subtitle_codec(const char *arg)
2498 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2501 static void opt_map(const char *arg)
2507 m = &stream_maps[nb_stream_maps++];
2509 m->file_index = strtol(arg, (char **)&p, 0);
2513 m->stream_index = strtol(p, (char **)&p, 0);
2516 m->sync_file_index = strtol(p, (char **)&p, 0);
2519 m->sync_stream_index = strtol(p, (char **)&p, 0);
2521 m->sync_file_index = m->file_index;
2522 m->sync_stream_index = m->stream_index;
2526 static void opt_map_meta_data(const char *arg)
2532 m = &meta_data_maps[nb_meta_data_maps++];
2534 m->out_file = strtol(arg, (char **)&p, 0);
2538 m->in_file = strtol(p, (char **)&p, 0);
2541 static int64_t parse_time_or_die(const char *timestr, int is_duration)
2543 int64_t us = parse_date(timestr, is_duration);
2544 if (us == INT64_MIN) {
2545 fprintf(stderr, "Invalid %s specification: %s\n",
2546 is_duration ? "duration" : "date", timestr);
2552 static void opt_recording_time(const char *arg)
2554 recording_time = parse_time_or_die(arg, 1);
2557 static void opt_start_time(const char *arg)
2559 start_time = parse_time_or_die(arg, 1);
2562 static void opt_rec_timestamp(const char *arg)
2564 rec_timestamp = parse_time_or_die(arg, 0) / 1000000;
2567 static void opt_input_ts_offset(const char *arg)
2569 input_ts_offset = parse_time_or_die(arg, 1);
2572 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2574 char *codec_string = encoder ? "encoder" : "decoder";
2578 return CODEC_ID_NONE;
2580 avcodec_find_encoder_by_name(name) :
2581 avcodec_find_decoder_by_name(name);
2583 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2586 if(codec->type != type) {
2587 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2593 static void opt_input_file(const char *filename)
2595 AVFormatContext *ic;
2596 AVFormatParameters params, *ap = ¶ms;
2597 int err, i, ret, rfps, rfps_base;
2600 if (!strcmp(filename, "-"))
2603 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2604 !strcmp( filename, "/dev/stdin" );
2606 /* get default parameters from command line */
2607 ic = av_alloc_format_context();
2609 memset(ap, 0, sizeof(*ap));
2610 ap->prealloced_context = 1;
2611 ap->sample_rate = audio_sample_rate;
2612 ap->channels = audio_channels;
2613 ap->time_base.den = frame_rate.num;
2614 ap->time_base.num = frame_rate.den;
2615 ap->width = frame_width + frame_padleft + frame_padright;
2616 ap->height = frame_height + frame_padtop + frame_padbottom;
2617 ap->pix_fmt = frame_pix_fmt;
2618 ap->channel = video_channel;
2619 ap->standard = video_standard;
2620 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2621 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2622 if(pgmyuv_compatibility_hack)
2623 ap->video_codec_id= CODEC_ID_PGMYUV;
2625 for(i=0; i<opt_name_count; i++){
2626 const AVOption *opt;
2627 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2628 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2629 av_set_double(ic, opt_names[i], d);
2631 /* open the input file with generic libav function */
2632 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2634 print_error(filename, err);
2639 for(i=0; i<ic->nb_programs; i++)
2640 if(ic->programs[i]->id != opt_programid)
2641 ic->programs[i]->discard = AVDISCARD_ALL;
2644 ic->loop_input = loop_input;
2646 /* If not enough info to get the stream parameters, we decode the
2647 first frames to get it. (used in mpeg case for example) */
2648 ret = av_find_stream_info(ic);
2649 if (ret < 0 && verbose >= 0) {
2650 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2654 timestamp = start_time;
2655 /* add the stream start time */
2656 if (ic->start_time != AV_NOPTS_VALUE)
2657 timestamp += ic->start_time;
2659 /* if seeking requested, we execute it */
2660 if (start_time != 0) {
2661 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2663 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2664 filename, (double)timestamp / AV_TIME_BASE);
2666 /* reset seek info */
2670 /* update the current parameters so that they match the one of the input stream */
2671 for(i=0;i<ic->nb_streams;i++) {
2673 AVCodecContext *enc = ic->streams[i]->codec;
2675 avcodec_thread_init(enc, thread_count);
2676 enc->thread_count= thread_count;
2677 switch(enc->codec_type) {
2678 case CODEC_TYPE_AUDIO:
2679 for(j=0; j<opt_name_count; j++){
2680 const AVOption *opt;
2681 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[j], &opt);
2682 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2683 av_set_double(enc, opt_names[j], d);
2685 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2686 audio_channels = enc->channels;
2687 audio_sample_rate = enc->sample_rate;
2689 ic->streams[i]->discard= AVDISCARD_ALL;
2691 case CODEC_TYPE_VIDEO:
2692 for(j=0; j<opt_name_count; j++){
2693 const AVOption *opt;
2694 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[j], &opt);
2695 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2696 av_set_double(enc, opt_names[j], d);
2698 frame_height = enc->height;
2699 frame_width = enc->width;
2700 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2701 frame_pix_fmt = enc->pix_fmt;
2702 rfps = ic->streams[i]->r_frame_rate.num;
2703 rfps_base = ic->streams[i]->r_frame_rate.den;
2704 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2706 enc->debug |= FF_DEBUG_MV;
2708 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2711 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2712 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2714 (float)rfps / rfps_base, rfps, rfps_base);
2716 /* update the current frame rate to match the stream frame rate */
2717 frame_rate.num = rfps;
2718 frame_rate.den = rfps_base;
2720 enc->rate_emu = rate_emu;
2722 ic->streams[i]->discard= AVDISCARD_ALL;
2723 else if(video_discard)
2724 ic->streams[i]->discard= video_discard;
2726 case CODEC_TYPE_DATA:
2728 case CODEC_TYPE_SUBTITLE:
2729 if(subtitle_disable)
2730 ic->streams[i]->discard = AVDISCARD_ALL;
2732 case CODEC_TYPE_UNKNOWN:
2739 input_files[nb_input_files] = ic;
2740 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2741 /* dump the file content */
2743 dump_format(ic, nb_input_files, filename, 0);
2746 file_iformat = NULL;
2747 file_oformat = NULL;
2754 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
2755 int *has_subtitle_ptr)
2757 int has_video, has_audio, has_subtitle, i, j;
2758 AVFormatContext *ic;
2763 for(j=0;j<nb_input_files;j++) {
2764 ic = input_files[j];
2765 for(i=0;i<ic->nb_streams;i++) {
2766 AVCodecContext *enc = ic->streams[i]->codec;
2767 switch(enc->codec_type) {
2768 case CODEC_TYPE_AUDIO:
2771 case CODEC_TYPE_VIDEO:
2774 case CODEC_TYPE_SUBTITLE:
2777 case CODEC_TYPE_DATA:
2778 case CODEC_TYPE_UNKNOWN:
2785 *has_video_ptr = has_video;
2786 *has_audio_ptr = has_audio;
2787 *has_subtitle_ptr = has_subtitle;
2790 static void new_video_stream(AVFormatContext *oc)
2793 AVCodecContext *video_enc;
2796 st = av_new_stream(oc, oc->nb_streams);
2798 fprintf(stderr, "Could not alloc stream\n");
2801 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
2802 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2803 video_bitstream_filters= NULL;
2806 avcodec_thread_init(st->codec, thread_count);
2808 video_enc = st->codec;
2811 video_enc->codec_tag= video_codec_tag;
2813 if( (video_global_header&1)
2814 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2815 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2816 avctx_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2818 if(video_global_header&2){
2819 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2820 avctx_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2823 if (video_stream_copy) {
2824 st->stream_copy = 1;
2825 video_enc->codec_type = CODEC_TYPE_VIDEO;
2831 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
2832 if (video_codec_name)
2833 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
2835 video_enc->codec_id = codec_id;
2836 codec = avcodec_find_encoder(codec_id);
2838 for(i=0; i<opt_name_count; i++){
2839 const AVOption *opt;
2840 double d= av_get_double(avctx_opts[CODEC_TYPE_VIDEO], opt_names[i], &opt);
2841 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2842 av_set_double(video_enc, opt_names[i], d);
2845 video_enc->time_base.den = frame_rate.num;
2846 video_enc->time_base.num = frame_rate.den;
2847 if(codec && codec->supported_framerates){
2848 const AVRational *p= codec->supported_framerates;
2849 AVRational req= (AVRational){frame_rate.num, frame_rate.den};
2850 const AVRational *best=NULL;
2851 AVRational best_error= (AVRational){INT_MAX, 1};
2852 for(; p->den!=0; p++){
2853 AVRational error= av_sub_q(req, *p);
2854 if(error.num <0) error.num *= -1;
2855 if(av_cmp_q(error, best_error) < 0){
2860 video_enc->time_base.den= best->num;
2861 video_enc->time_base.num= best->den;
2864 video_enc->width = frame_width + frame_padright + frame_padleft;
2865 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2866 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
2867 video_enc->pix_fmt = frame_pix_fmt;
2869 if(codec && codec->pix_fmts){
2870 const enum PixelFormat *p= codec->pix_fmts;
2872 if(*p == video_enc->pix_fmt)
2876 video_enc->pix_fmt = codec->pix_fmts[0];
2880 video_enc->gop_size = 0;
2881 if (video_qscale || same_quality) {
2882 video_enc->flags |= CODEC_FLAG_QSCALE;
2883 video_enc->global_quality=
2884 st->quality = FF_QP2LAMBDA * video_qscale;
2888 video_enc->intra_matrix = intra_matrix;
2890 video_enc->inter_matrix = inter_matrix;
2892 video_enc->max_qdiff = video_qdiff;
2893 video_enc->rc_eq = video_rc_eq;
2894 video_enc->thread_count = thread_count;
2895 p= video_rc_override_string;
2898 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
2900 fprintf(stderr, "error parsing rc_override\n");
2903 video_enc->rc_override=
2904 av_realloc(video_enc->rc_override,
2905 sizeof(RcOverride)*(i+1));
2906 video_enc->rc_override[i].start_frame= start;
2907 video_enc->rc_override[i].end_frame = end;
2909 video_enc->rc_override[i].qscale= q;
2910 video_enc->rc_override[i].quality_factor= 1.0;
2913 video_enc->rc_override[i].qscale= 0;
2914 video_enc->rc_override[i].quality_factor= -q/100.0;
2919 video_enc->rc_override_count=i;
2920 if (!video_enc->rc_initial_buffer_occupancy)
2921 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
2922 video_enc->me_threshold= me_threshold;
2923 video_enc->intra_dc_precision= intra_dc_precision - 8;
2924 video_enc->strict_std_compliance = strict;
2927 video_enc->flags|= CODEC_FLAG_PSNR;
2932 video_enc->flags |= CODEC_FLAG_PASS1;
2934 video_enc->flags |= CODEC_FLAG_PASS2;
2939 /* reset some key parameters */
2941 av_freep(&video_codec_name);
2942 video_stream_copy = 0;
2945 static void new_audio_stream(AVFormatContext *oc)
2948 AVCodecContext *audio_enc;
2951 st = av_new_stream(oc, oc->nb_streams);
2953 fprintf(stderr, "Could not alloc stream\n");
2956 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
2958 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
2959 audio_bitstream_filters= NULL;
2962 avcodec_thread_init(st->codec, thread_count);
2964 audio_enc = st->codec;
2965 audio_enc->codec_type = CODEC_TYPE_AUDIO;
2966 audio_enc->strict_std_compliance = strict;
2969 audio_enc->codec_tag= audio_codec_tag;
2971 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
2972 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2973 avctx_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
2975 if (audio_stream_copy) {
2976 st->stream_copy = 1;
2977 audio_enc->channels = audio_channels;
2979 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
2981 for(i=0; i<opt_name_count; i++){
2982 const AVOption *opt;
2983 double d= av_get_double(avctx_opts[CODEC_TYPE_AUDIO], opt_names[i], &opt);
2984 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
2985 av_set_double(audio_enc, opt_names[i], d);
2988 if (audio_codec_name)
2989 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
2990 audio_enc->codec_id = codec_id;
2992 if (audio_qscale > QSCALE_NONE) {
2993 audio_enc->flags |= CODEC_FLAG_QSCALE;
2994 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
2996 audio_enc->thread_count = thread_count;
2997 audio_enc->channels = audio_channels;
2999 audio_enc->sample_rate = audio_sample_rate;
3000 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3001 if (audio_language) {
3002 av_strlcpy(st->language, audio_language, sizeof(st->language));
3003 av_free(audio_language);
3004 audio_language = NULL;
3007 /* reset some key parameters */
3009 av_freep(&audio_codec_name);
3010 audio_stream_copy = 0;
3013 static void new_subtitle_stream(AVFormatContext *oc)
3016 AVCodecContext *subtitle_enc;
3019 st = av_new_stream(oc, oc->nb_streams);
3021 fprintf(stderr, "Could not alloc stream\n");
3024 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3026 subtitle_enc = st->codec;
3027 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3028 if (subtitle_stream_copy) {
3029 st->stream_copy = 1;
3031 for(i=0; i<opt_name_count; i++){
3032 const AVOption *opt;
3033 double d= av_get_double(avctx_opts[CODEC_TYPE_SUBTITLE], opt_names[i], &opt);
3034 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3035 av_set_double(subtitle_enc, opt_names[i], d);
3037 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3040 if (subtitle_language) {
3041 av_strlcpy(st->language, subtitle_language, sizeof(st->language));
3042 av_free(subtitle_language);
3043 subtitle_language = NULL;
3046 subtitle_disable = 0;
3047 av_freep(&subtitle_codec_name);
3048 subtitle_stream_copy = 0;
3051 static void opt_new_audio_stream(void)
3053 AVFormatContext *oc;
3054 if (nb_output_files <= 0) {
3055 fprintf(stderr, "At least one output file must be specified\n");
3058 oc = output_files[nb_output_files - 1];
3059 new_audio_stream(oc);
3062 static void opt_new_video_stream(void)
3064 AVFormatContext *oc;
3065 if (nb_output_files <= 0) {
3066 fprintf(stderr, "At least one output file must be specified\n");
3069 oc = output_files[nb_output_files - 1];
3070 new_video_stream(oc);
3073 static void opt_new_subtitle_stream(void)
3075 AVFormatContext *oc;
3076 if (nb_output_files <= 0) {
3077 fprintf(stderr, "At least one output file must be specified\n");
3080 oc = output_files[nb_output_files - 1];
3081 new_subtitle_stream(oc);
3084 static void opt_output_file(const char *filename)
3086 AVFormatContext *oc;
3087 int use_video, use_audio, use_subtitle;
3088 int input_has_video, input_has_audio, input_has_subtitle, i;
3089 AVFormatParameters params, *ap = ¶ms;
3091 if (!strcmp(filename, "-"))
3094 oc = av_alloc_format_context();
3096 if (!file_oformat) {
3097 file_oformat = guess_format(NULL, filename, NULL);
3098 if (!file_oformat) {
3099 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3105 oc->oformat = file_oformat;
3106 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3108 if (!strcmp(file_oformat->name, "ffm") &&
3109 av_strstart(filename, "http:", NULL)) {
3110 /* special case for files sent to ffserver: we get the stream
3111 parameters from ffserver */
3112 if (read_ffserver_streams(oc, filename) < 0) {
3113 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3117 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3118 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3119 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3121 /* disable if no corresponding type found and at least one
3123 if (nb_input_files > 0) {
3124 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3125 &input_has_subtitle);
3126 if (!input_has_video)
3128 if (!input_has_audio)
3130 if (!input_has_subtitle)
3134 /* manual disable */
3135 if (audio_disable) {
3138 if (video_disable) {
3141 if (subtitle_disable) {
3146 new_video_stream(oc);
3150 new_audio_stream(oc);
3154 new_subtitle_stream(oc);
3157 oc->timestamp = rec_timestamp;
3160 av_strlcpy(oc->title, str_title, sizeof(oc->title));
3162 av_strlcpy(oc->author, str_author, sizeof(oc->author));
3164 av_strlcpy(oc->copyright, str_copyright, sizeof(oc->copyright));
3166 av_strlcpy(oc->comment, str_comment, sizeof(oc->comment));
3168 av_strlcpy(oc->album, str_album, sizeof(oc->album));
3171 output_files[nb_output_files++] = oc;
3173 /* check filename in case of an image number is expected */
3174 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3175 if (!av_filename_number_test(oc->filename)) {
3176 print_error(oc->filename, AVERROR_NUMEXPECTED);
3181 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3182 /* test if it already exists to avoid loosing precious files */
3183 if (!file_overwrite &&
3184 (strchr(filename, ':') == NULL ||
3185 av_strstart(filename, "file:", NULL))) {
3186 if (url_exist(filename)) {
3189 if ( !using_stdin ) {
3190 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3193 if (toupper(c) != 'Y') {
3194 fprintf(stderr, "Not overwriting - exiting\n");
3199 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3206 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3207 fprintf(stderr, "Could not open '%s'\n", filename);
3212 memset(ap, 0, sizeof(*ap));
3213 if (av_set_parameters(oc, ap) < 0) {
3214 fprintf(stderr, "%s: Invalid encoding parameters\n",
3219 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3220 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3221 oc->loop_output = loop_output;
3223 for(i=0; i<opt_name_count; i++){
3224 const AVOption *opt;
3225 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3226 if(!isnan(d) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3227 av_set_double(oc, opt_names[i], d);
3230 /* reset some options */
3231 file_oformat = NULL;
3232 file_iformat = NULL;
3235 /* same option as mencoder */
3236 static void opt_pass(const char *pass_str)
3239 pass = atoi(pass_str);
3240 if (pass != 1 && pass != 2) {
3241 fprintf(stderr, "pass number can be only 1 or 2\n");
3247 static int64_t getutime(void)
3249 #ifdef HAVE_GETRUSAGE
3250 struct rusage rusage;
3252 getrusage(RUSAGE_SELF, &rusage);
3253 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3254 #elif defined(HAVE_GETPROCESSTIMES)
3256 FILETIME c, e, k, u;
3257 proc = GetCurrentProcess();
3258 GetProcessTimes(proc, &c, &e, &k, &u);
3259 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3261 return av_gettime();
3265 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3266 extern int ffm_nopts;
3269 static void opt_show_formats(void)
3271 AVInputFormat *ifmt;
3272 AVOutputFormat *ofmt;
3275 const char *last_name;
3277 printf("File formats:\n");
3282 const char *name=NULL;
3283 const char *long_name=NULL;
3285 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3286 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3287 strcmp(ofmt->name, last_name)>0){
3289 long_name= ofmt->long_name;
3293 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3294 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3295 strcmp(ifmt->name, last_name)>0){
3297 long_name= ifmt->long_name;
3300 if(name && strcmp(ifmt->name, name)==0)
3312 long_name ? long_name:" ");
3316 printf("Codecs:\n");
3322 const char *type_str;
3325 for(p = first_avcodec; p != NULL; p = p->next) {
3326 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3327 strcmp(p->name, last_name)>0){
3329 decode= encode= cap=0;
3331 if(p2 && strcmp(p->name, p2->name)==0){
3332 if(p->decode) decode=1;
3333 if(p->encode) encode=1;
3334 cap |= p->capabilities;
3339 last_name= p2->name;
3342 case CODEC_TYPE_VIDEO:
3345 case CODEC_TYPE_AUDIO:
3348 case CODEC_TYPE_SUBTITLE:
3357 decode ? "D": (/*p2->decoder ? "d":*/" "),
3360 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3361 cap & CODEC_CAP_DR1 ? "D":" ",
3362 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3364 /* if(p2->decoder && decode==0)
3365 printf(" use %s for decoding", p2->decoder->name);*/
3370 printf("Supported file protocols:\n");
3371 for(up = first_protocol; up != NULL; up = up->next)
3372 printf(" %s:", up->name);
3375 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3378 "Note, the names of encoders and decoders do not always match, so there are\n"
3379 "several cases where the above table shows encoder only or decoder only entries\n"
3380 "even though both encoding and decoding are supported. For example, the h263\n"
3381 "decoder corresponds to the h263 and h263p encoders, for file formats it is even\n"
3386 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3389 const char *p = str;
3396 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3403 static void opt_inter_matrix(const char *arg)
3405 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3406 parse_matrix_coeffs(inter_matrix, arg);
3409 static void opt_intra_matrix(const char *arg)
3411 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3412 parse_matrix_coeffs(intra_matrix, arg);
3415 static void opt_show_help(void)
3421 static void opt_target(const char *arg)
3424 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3426 if(!strncmp(arg, "pal-", 4)) {
3429 } else if(!strncmp(arg, "ntsc-", 5)) {
3432 } else if(!strncmp(arg, "film-", 5)) {
3437 /* Calculate FR via float to avoid int overflow */
3438 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3441 } else if((fr == 29970) || (fr == 23976)) {
3444 /* Try to determine PAL/NTSC by peeking in the input files */
3445 if(nb_input_files) {
3447 for(j = 0; j < nb_input_files; j++) {
3448 for(i = 0; i < input_files[j]->nb_streams; i++) {
3449 AVCodecContext *c = input_files[j]->streams[i]->codec;
3450 if(c->codec_type != CODEC_TYPE_VIDEO)
3452 fr = c->time_base.den * 1000 / c->time_base.num;
3456 } else if((fr == 29970) || (fr == 23976)) {
3466 if(verbose && norm >= 0)
3467 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3471 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3472 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3473 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3477 if(!strcmp(arg, "vcd")) {
3479 opt_video_codec("mpeg1video");
3480 opt_audio_codec("mp2");
3483 opt_frame_size(norm ? "352x240" : "352x288");
3484 opt_frame_rate(frame_rates[norm]);
3485 opt_default("gop", norm ? "18" : "15");
3487 opt_default("b", "1150000");
3488 opt_default("maxrate", "1150000");
3489 opt_default("minrate", "1150000");
3490 opt_default("bufsize", "327680"); // 40*1024*8;
3492 opt_default("ab", "224000");
3493 audio_sample_rate = 44100;
3496 opt_default("packetsize", "2324");
3497 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3499 /* We have to offset the PTS, so that it is consistent with the SCR.
3500 SCR starts at 36000, but the first two packs contain only padding
3501 and the first pack from the other stream, respectively, may also have
3502 been written before.
3503 So the real data starts at SCR 36000+3*1200. */
3504 mux_preload= (36000+3*1200) / 90000.0; //0.44
3505 } else if(!strcmp(arg, "svcd")) {
3507 opt_video_codec("mpeg2video");
3508 opt_audio_codec("mp2");
3511 opt_frame_size(norm ? "480x480" : "480x576");
3512 opt_frame_rate(frame_rates[norm]);
3513 opt_default("gop", norm ? "18" : "15");
3515 opt_default("b", "2040000");
3516 opt_default("maxrate", "2516000");
3517 opt_default("minrate", "0"); //1145000;
3518 opt_default("bufsize", "1835008"); //224*1024*8;
3519 opt_default("flags", "+SCAN_OFFSET");
3522 opt_default("ab", "224000");
3523 audio_sample_rate = 44100;
3525 opt_default("packetsize", "2324");
3527 } else if(!strcmp(arg, "dvd")) {
3529 opt_video_codec("mpeg2video");
3530 opt_audio_codec("ac3");
3533 opt_frame_size(norm ? "720x480" : "720x576");
3534 opt_frame_rate(frame_rates[norm]);
3535 opt_default("gop", norm ? "18" : "15");
3537 opt_default("b", "6000000");
3538 opt_default("maxrate", "9000000");
3539 opt_default("minrate", "0"); //1500000;
3540 opt_default("bufsize", "1835008"); //224*1024*8;
3542 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3543 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3545 opt_default("ab", "448000");
3546 audio_sample_rate = 48000;
3548 } else if(!strncmp(arg, "dv", 2)) {
3552 opt_frame_size(norm ? "720x480" : "720x576");
3553 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3554 (norm ? "yuv411p" : "yuv420p"));
3555 opt_frame_rate(frame_rates[norm]);
3557 audio_sample_rate = 48000;
3561 fprintf(stderr, "Unknown target: %s\n", arg);
3566 static void opt_vstats_file (const char *arg)
3568 av_free (vstats_filename);
3569 vstats_filename=av_strdup (arg);
3572 static void opt_vstats (void)
3575 time_t today2 = time(NULL);
3576 struct tm *today = localtime(&today2);
3578 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3580 opt_vstats_file(filename);
3583 static void opt_bsf(const char *opt, const char *arg)
3585 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3586 AVBitStreamFilterContext **bsfp;
3589 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3593 bsfp= *opt == 'v' ? &video_bitstream_filters : &audio_bitstream_filters;
3595 bsfp= &(*bsfp)->next;
3600 static void opt_show_version(void)
3602 show_version(program_name);
3606 static int opt_default(const char *opt, const char *arg){
3608 const AVOption *o= NULL;
3609 int opt_types[]={AV_OPT_FLAG_VIDEO_PARAM, AV_OPT_FLAG_AUDIO_PARAM, 0, AV_OPT_FLAG_SUBTITLE_PARAM, 0};
3611 for(type=0; type<CODEC_TYPE_NB; type++){
3612 const AVOption *o2 = av_find_opt(avctx_opts[0], opt, NULL, opt_types[type], opt_types[type]);
3614 o = av_set_string(avctx_opts[type], opt, arg);
3617 o = av_set_string(avformat_opts, opt, arg);
3619 o = av_set_string(sws_opts, opt, arg);
3622 o = av_set_string(avctx_opts[CODEC_TYPE_AUDIO], opt+1, arg);
3623 else if(opt[0] == 'v')
3624 o = av_set_string(avctx_opts[CODEC_TYPE_VIDEO], opt+1, arg);
3625 else if(opt[0] == 's')
3626 o = av_set_string(avctx_opts[CODEC_TYPE_SUBTITLE], opt+1, arg);
3631 // av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
3633 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3634 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3635 opt_names[opt_name_count++]= o->name;
3637 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3638 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3639 if(avctx_opts[0]->flags & CODEC_FLAG_BITEXACT)
3643 if(avctx_opts[0]->debug)
3644 av_log_level = AV_LOG_DEBUG;
3648 const OptionDef options[] = {
3650 { "L", 0, {(void*)opt_show_license}, "show license" },
3651 { "h", 0, {(void*)opt_show_help}, "show help" },
3652 { "version", 0, {(void*)opt_show_version}, "show version" },
3653 { "formats", 0, {(void*)opt_show_formats}, "show available formats, codecs, protocols, ..." },
3654 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3655 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3656 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3657 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3658 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3659 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3660 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3661 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3662 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3663 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3664 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3665 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3666 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3667 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3668 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3669 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3670 "add timings for benchmarking" },
3671 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3672 "dump each input packet" },
3673 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3674 "when dumping packets, also dump the payload" },
3675 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3676 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3677 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
3678 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3679 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3680 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3681 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3682 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3683 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "" },
3684 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3685 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3686 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3687 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3688 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3691 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3692 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3693 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3694 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3695 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3696 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3697 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3698 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3699 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3700 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3701 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3702 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3703 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3704 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3705 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3706 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3707 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3708 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3709 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3710 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantizer scale (VBR)", "q" },
3711 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3712 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3713 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3714 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3715 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3716 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3717 "use same video quality as source (implies VBR)" },
3718 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3719 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3720 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3721 "deinterlace pictures" },
3722 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3723 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3724 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3726 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3728 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3729 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3730 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3731 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3732 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3733 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3734 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3737 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3738 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3739 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3740 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3741 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3742 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3743 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3744 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3745 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3746 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3748 /* subtitle options */
3749 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3750 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3751 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3752 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3755 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3756 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3757 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3760 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3761 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3763 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3764 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream filter" },
3766 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3770 static void opt_show_license(void)
3777 * Trivial log callback.
3778 * Only suitable for show_help and similar since it lacks prefix handling.
3780 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3782 vfprintf(stdout, fmt, vl);
3785 static void show_help(void)
3787 av_log_set_callback(log_callback_help);
3788 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3789 "Hyper fast Audio and Video encoder\n");
3791 show_help_options(options, "Main options:\n",
3792 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3793 show_help_options(options, "\nVideo options:\n",
3794 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3796 show_help_options(options, "\nAdvanced Video options:\n",
3797 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3798 OPT_VIDEO | OPT_EXPERT);
3799 show_help_options(options, "\nAudio options:\n",
3800 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3802 show_help_options(options, "\nAdvanced Audio options:\n",
3803 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3804 OPT_AUDIO | OPT_EXPERT);
3805 show_help_options(options, "\nSubtitle options:\n",
3806 OPT_SUBTITLE | OPT_GRAB,
3808 show_help_options(options, "\nAudio/Video grab options:\n",
3811 show_help_options(options, "\nAdvanced options:\n",
3812 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3814 av_opt_show(avctx_opts[0], NULL);
3815 av_opt_show(avformat_opts, NULL);
3816 av_opt_show(sws_opts, NULL);
3819 static int av_exit()
3824 for(i=0;i<nb_output_files;i++) {
3825 /* maybe av_close_output_file ??? */
3826 AVFormatContext *s = output_files[i];
3828 if (!(s->oformat->flags & AVFMT_NOFILE))
3830 for(j=0;j<s->nb_streams;j++) {
3831 av_free(s->streams[j]->codec);
3832 av_free(s->streams[j]);
3836 for(i=0;i<nb_input_files;i++)
3837 av_close_input_file(input_files[i]);
3841 av_free(intra_matrix);
3842 av_free(inter_matrix);
3845 fclose(vstats_file);
3846 av_free(vstats_filename);
3850 av_free(video_codec_name);
3851 av_free(audio_codec_name);
3852 av_free(subtitle_codec_name);
3854 av_free(video_standard);
3856 #ifdef CONFIG_POWERPC_PERF
3857 extern void powerpc_display_perf_report(void);
3858 powerpc_display_perf_report();
3859 #endif /* CONFIG_POWERPC_PERF */
3861 if (received_sigterm) {
3863 "Received signal %d: terminating.\n",
3864 (int) received_sigterm);
3868 exit(0); /* not all OS-es handle main() return value */
3872 int main(int argc, char **argv)
3879 for(i=0; i<CODEC_TYPE_NB; i++){
3880 avctx_opts[i]= avcodec_alloc_context2(i);
3882 avformat_opts = av_alloc_format_context();
3883 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3885 show_banner(program_name, program_birth_year);
3892 parse_options(argc, argv, options, opt_output_file);
3894 /* file converter / grab */
3895 if (nb_output_files <= 0) {
3896 fprintf(stderr, "Must supply at least one output file\n");
3900 if (nb_input_files == 0) {
3901 fprintf(stderr, "Must supply at least one input file\n");
3906 av_encode(output_files, nb_output_files, input_files, nb_input_files,
3907 stream_maps, nb_stream_maps);
3908 ti = getutime() - ti;
3910 printf("bench: utime=%0.3fs\n", ti / 1000000.0);