3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 #define HAVE_AV_CONFIG_H
22 #include "framehook.h"
29 #include <sys/ioctl.h>
32 #include <sys/resource.h>
36 #include <sys/types.h>
37 #include <sys/select.h>
40 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
49 #if !defined(INFINITY) && defined(HUGE_VAL)
50 #define INFINITY HUGE_VAL
53 /* select an input stream for an output stream */
54 typedef struct AVStreamMap {
58 int sync_stream_index;
61 /** select an input file for an output file */
62 typedef struct AVMetaDataMap {
67 extern const OptionDef options[];
69 static void show_help(void);
70 static void show_license(void);
71 static int opt_default(const char *opt, const char *arg);
75 static AVFormatContext *input_files[MAX_FILES];
76 static int64_t input_files_ts_offset[MAX_FILES];
77 static int nb_input_files = 0;
79 static AVFormatContext *output_files[MAX_FILES];
80 static int nb_output_files = 0;
82 static AVStreamMap stream_maps[MAX_FILES];
83 static int nb_stream_maps;
85 static AVMetaDataMap meta_data_maps[MAX_FILES];
86 static int nb_meta_data_maps;
88 static AVInputFormat *file_iformat;
89 static AVOutputFormat *file_oformat;
90 static AVImageFormat *image_format;
91 static int frame_width = 0;
92 static int frame_height = 0;
93 static float frame_aspect_ratio = 0;
94 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
95 static int frame_padtop = 0;
96 static int frame_padbottom = 0;
97 static int frame_padleft = 0;
98 static int frame_padright = 0;
99 static int padcolor[3] = {16,128,128}; /* default to black */
100 static int frame_topBand = 0;
101 static int frame_bottomBand = 0;
102 static int frame_leftBand = 0;
103 static int frame_rightBand = 0;
104 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
105 static int frame_rate = 25;
106 static int frame_rate_base = 1;
107 static int video_bit_rate = 200*1000;
108 static int video_bit_rate_tolerance = 4000*1000;
109 static float video_qscale = 0;
110 static int video_qmin = 2;
111 static int video_qmax = 31;
112 static int video_lmin = 2*FF_QP2LAMBDA;
113 static int video_lmax = 31*FF_QP2LAMBDA;
114 static int video_mb_lmin = 2*FF_QP2LAMBDA;
115 static int video_mb_lmax = 31*FF_QP2LAMBDA;
116 static int video_qdiff = 3;
117 static float video_qblur = 0.5;
118 static float video_qsquish = 0.0;
119 static float video_qcomp = 0.5;
120 static uint16_t *intra_matrix = NULL;
121 static uint16_t *inter_matrix = NULL;
122 #if 0 //experimental, (can be removed)
123 static float video_rc_qsquish=1.0;
124 static float video_rc_qmod_amp=0;
125 static int video_rc_qmod_freq=0;
127 static char *video_rc_override_string=NULL;
128 static char *video_rc_eq="tex^qComp";
129 static int video_rc_buffer_size=0;
130 static float video_rc_buffer_aggressivity=1.0;
131 static int video_rc_max_rate=0;
132 static int video_rc_min_rate=0;
133 static float video_rc_initial_cplx=0;
134 static float video_b_qfactor = 1.25;
135 static float video_b_qoffset = 1.25;
136 static float video_i_qfactor = -0.8;
137 static float video_i_qoffset = 0.0;
138 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
139 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
140 static int me_method = ME_EPZS;
141 static int video_disable = 0;
142 static int video_discard = 0;
143 static int video_codec_id = CODEC_ID_NONE;
144 static int video_codec_tag = 0;
145 static int same_quality = 0;
146 static int b_frames = 0;
147 static int pre_me = 0;
148 static int do_deinterlace = 0;
149 static int workaround_bugs = FF_BUG_AUTODETECT;
150 static int packet_size = 0;
151 static int error_rate = 0;
152 static int strict = 0;
153 static int top_field_first = -1;
154 static int sc_threshold = 0;
155 static int me_threshold = 0;
156 static int mb_threshold = 0;
157 static int intra_dc_precision = 8;
158 static int me_penalty_compensation= 256;
159 static int frame_skip_threshold= 0;
160 static int frame_skip_factor= 0;
161 static int frame_skip_exp= 0;
162 extern int loop_input; /* currently a hack */
163 static int loop_output = AVFMT_NOOUTPUTLOOP;
164 static int genpts = 0;
165 static int qp_hist = 0;
167 static int gop_size = 12;
168 static int intra_only = 0;
169 static int audio_sample_rate = 44100;
170 static int audio_bit_rate = 64000;
171 #define QSCALE_NONE -99999
172 static float audio_qscale = QSCALE_NONE;
173 static int audio_disable = 0;
174 static int audio_channels = 1;
175 static int audio_codec_id = CODEC_ID_NONE;
176 static int audio_codec_tag = 0;
177 static char *audio_language = NULL;
179 static int subtitle_codec_id = CODEC_ID_NONE;
180 static char *subtitle_language = NULL;
182 static int mux_rate= 0;
183 static int mux_packet_size= 0;
184 static float mux_preload= 0.5;
185 static float mux_max_delay= 0.7;
187 static int64_t recording_time = 0;
188 static int64_t start_time = 0;
189 static int64_t rec_timestamp = 0;
190 static int64_t input_ts_offset = 0;
191 static int file_overwrite = 0;
192 static char *str_title = NULL;
193 static char *str_author = NULL;
194 static char *str_copyright = NULL;
195 static char *str_comment = NULL;
196 static int do_benchmark = 0;
197 static int do_hex_dump = 0;
198 static int do_pkt_dump = 0;
199 static int do_psnr = 0;
200 static int do_vstats = 0;
201 static int do_pass = 0;
202 static char *pass_logfilename = NULL;
203 static int audio_stream_copy = 0;
204 static int video_stream_copy = 0;
205 static int subtitle_stream_copy = 0;
206 static int video_sync_method= 1;
207 static int audio_sync_method= 0;
208 static int copy_ts= 0;
209 static int opt_shortest = 0; //
210 static int video_global_header = 0;
212 static int rate_emu = 0;
215 static const char *video_grab_format = "bktr";
217 #ifdef CONFIG_VIDEO4LINUX2
218 static const char *video_grab_format = "video4linux2";
220 static const char *video_grab_format = "video4linux";
223 static char *video_device = NULL;
224 static char *grab_device = NULL;
225 static int video_channel = 0;
226 static char *video_standard = "ntsc";
228 static const char *audio_grab_format = "audio_device";
229 static char *audio_device = NULL;
230 static int audio_volume = 256;
232 static int using_stdin = 0;
233 static int using_vhook = 0;
234 static int verbose = 1;
235 static int thread_count= 1;
236 static int q_pressed = 0;
237 static int me_range = 0;
238 static int64_t video_size = 0;
239 static int64_t audio_size = 0;
240 static int64_t extra_size = 0;
241 static int nb_frames_dup = 0;
242 static int nb_frames_drop = 0;
243 static int input_sync;
244 static int limit_filesize = 0; //
246 static int pgmyuv_compatibility_hack=0;
247 static int dts_delta_threshold = 10;
249 const char **opt_names=NULL;
250 int opt_name_count=0;
251 AVCodecContext *avctx_opts;
253 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
254 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
255 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
257 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
259 struct AVInputStream;
261 typedef struct AVOutputStream {
262 int file_index; /* file index */
263 int index; /* stream index in the output file */
264 int source_index; /* AVInputStream index */
265 AVStream *st; /* stream in the output file */
266 int encoding_needed; /* true if encoding needed for this stream */
268 /* input pts and corresponding output pts
270 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
271 struct AVInputStream *sync_ist; /* input stream to sync against */
272 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
275 AVFrame pict_tmp; /* temporary image for resampling */
276 ImgReSampleContext *img_resample_ctx; /* for image resampling */
279 int topBand; /* cropping area sizes */
283 int padtop; /* padding area sizes */
290 ReSampleContext *resample; /* for audio resampling */
291 FifoBuffer fifo; /* for compression: one audio fifo per codec */
295 typedef struct AVInputStream {
299 int discard; /* true if stream data should be discarded */
300 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
301 int64_t sample_index; /* current sample */
303 int64_t start; /* time when read started */
304 unsigned long frame; /* current frame */
305 int64_t next_pts; /* synthetic pts for cases where pkt.pts
307 int64_t pts; /* current pts */
308 int is_start; /* is 1 at the start and after a discontinuity */
311 typedef struct AVInputFile {
312 int eof_reached; /* true if eof reached */
313 int ist_index; /* index of first stream in ist_table */
314 int buffer_size; /* current total buffer size */
315 int buffer_size_max; /* buffer size at which we consider we can stop
317 int nb_streams; /* nb streams we are aware of */
322 /* init terminal so that we can grab keys */
323 static struct termios oldtty;
325 static void term_exit(void)
327 tcsetattr (0, TCSANOW, &oldtty);
330 static volatile sig_atomic_t received_sigterm = 0;
333 sigterm_handler(int sig)
335 received_sigterm = sig;
339 static void term_init(void)
346 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
347 |INLCR|IGNCR|ICRNL|IXON);
348 tty.c_oflag |= OPOST;
349 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
350 tty.c_cflag &= ~(CSIZE|PARENB);
355 tcsetattr (0, TCSANOW, &tty);
357 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
358 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
359 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
361 register a function to be called at normal program termination
364 #ifdef CONFIG_BEOS_NETSERVER
365 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
369 /* read a key without blocking */
370 static int read_key(void)
374 #ifndef CONFIG_BEOS_NETSERVER
382 n = select(1, &rfds, NULL, NULL, &tv);
394 static int decode_interrupt_cb(void)
396 return q_pressed || (q_pressed = read_key() == 'q');
401 static volatile int received_sigterm = 0;
403 /* no interactive support */
404 static void term_exit(void)
408 static void term_init(void)
412 static int read_key(void)
419 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
424 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
427 /* copy stream format */
428 s->nb_streams = ic->nb_streams;
429 for(i=0;i<ic->nb_streams;i++) {
432 // FIXME: a more elegant solution is needed
433 st = av_mallocz(sizeof(AVStream));
434 memcpy(st, ic->streams[i], sizeof(AVStream));
435 st->codec = avcodec_alloc_context();
436 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
440 av_close_input_file(ic);
445 get_sync_ipts(const AVOutputStream *ost)
447 const AVInputStream *ist = ost->sync_ist;
448 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
451 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
453 AVPacket new_pkt= *pkt;
454 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
455 &new_pkt.data, &new_pkt.size,
456 pkt->data, pkt->size,
457 pkt->flags & PKT_FLAG_KEY);
460 new_pkt.destruct= av_destruct_packet;
467 av_interleaved_write_frame(s, pkt);
470 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
472 static void do_audio_out(AVFormatContext *s,
475 unsigned char *buf, int size)
478 static uint8_t *audio_buf = NULL;
479 static uint8_t *audio_out = NULL;
480 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
482 int size_out, frame_bytes, ret;
483 AVCodecContext *enc= ost->st->codec;
485 /* SC: dynamic allocation of buffers */
487 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
489 audio_out = av_malloc(audio_out_size);
490 if (!audio_buf || !audio_out)
491 return; /* Should signal an error ! */
493 if(audio_sync_method){
494 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
495 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
496 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
497 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
499 //FIXME resample delay
500 if(fabs(delta) > 50){
503 byte_delta= FFMAX(byte_delta, -size);
507 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
512 static uint8_t *input_tmp= NULL;
513 input_tmp= av_realloc(input_tmp, byte_delta + size);
515 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
518 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
520 memset(input_tmp, 0, byte_delta);
521 memcpy(input_tmp + byte_delta, buf, size);
525 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
527 }else if(audio_sync_method>1){
528 int comp= clip(delta, -audio_sync_method, audio_sync_method);
529 assert(ost->audio_resample);
531 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
532 // fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2));
533 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
537 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
538 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
540 if (ost->audio_resample) {
542 size_out = audio_resample(ost->resample,
543 (short *)buftmp, (short *)buf,
544 size / (ist->st->codec->channels * 2));
545 size_out = size_out * enc->channels * 2;
551 /* now encode as many frames as possible */
552 if (enc->frame_size > 1) {
553 /* output resampled raw samples */
554 fifo_write(&ost->fifo, buftmp, size_out,
557 frame_bytes = enc->frame_size * 2 * enc->channels;
559 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
560 &ost->fifo.rptr) == 0) {
562 av_init_packet(&pkt);
564 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
567 pkt.stream_index= ost->index;
570 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
571 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
572 pkt.flags |= PKT_FLAG_KEY;
573 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
575 ost->sync_opts += enc->frame_size;
579 av_init_packet(&pkt);
581 ost->sync_opts += size_out / (2 * enc->channels);
583 /* output a pcm frame */
584 /* XXX: change encoding codec API to avoid this ? */
585 switch(enc->codec->id) {
586 case CODEC_ID_PCM_S32LE:
587 case CODEC_ID_PCM_S32BE:
588 case CODEC_ID_PCM_U32LE:
589 case CODEC_ID_PCM_U32BE:
590 size_out = size_out << 1;
592 case CODEC_ID_PCM_S24LE:
593 case CODEC_ID_PCM_S24BE:
594 case CODEC_ID_PCM_U24LE:
595 case CODEC_ID_PCM_U24BE:
596 case CODEC_ID_PCM_S24DAUD:
597 size_out = size_out / 2 * 3;
599 case CODEC_ID_PCM_S16LE:
600 case CODEC_ID_PCM_S16BE:
601 case CODEC_ID_PCM_U16LE:
602 case CODEC_ID_PCM_U16BE:
605 size_out = size_out >> 1;
608 ret = avcodec_encode_audio(enc, audio_out, size_out,
611 pkt.stream_index= ost->index;
614 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
615 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
616 pkt.flags |= PKT_FLAG_KEY;
617 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
621 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
625 AVPicture picture_tmp;
628 dec = ist->st->codec;
630 /* deinterlace : must be done before any resize */
631 if (do_deinterlace || using_vhook) {
634 /* create temporary picture */
635 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
636 buf = av_malloc(size);
640 picture2 = &picture_tmp;
641 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
644 if(avpicture_deinterlace(picture2, picture,
645 dec->pix_fmt, dec->width, dec->height) < 0) {
646 /* if error, do not deinterlace */
652 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
658 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
660 if (picture != picture2)
661 *picture = *picture2;
665 /* we begin to correct av delay at this threshold */
666 #define AV_DELAY_MAX 0.100
668 static void do_subtitle_out(AVFormatContext *s,
674 static uint8_t *subtitle_out = NULL;
675 int subtitle_out_max_size = 65536;
676 int subtitle_out_size, nb, i;
680 if (pts == AV_NOPTS_VALUE) {
681 fprintf(stderr, "Subtitle packets must have a pts\n");
685 enc = ost->st->codec;
688 subtitle_out = av_malloc(subtitle_out_max_size);
691 /* Note: DVB subtitle need one packet to draw them and one other
692 packet to clear them */
693 /* XXX: signal it in the codec context ? */
694 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
699 for(i = 0; i < nb; i++) {
700 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
701 subtitle_out_max_size, sub);
703 av_init_packet(&pkt);
704 pkt.stream_index = ost->index;
705 pkt.data = subtitle_out;
706 pkt.size = subtitle_out_size;
707 pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
708 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
709 /* XXX: the pts correction is handled here. Maybe handling
710 it in the codec would be better */
712 pkt.pts += 90 * sub->start_display_time;
714 pkt.pts += 90 * sub->end_display_time;
716 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
720 static int bit_buffer_size= 1024*256;
721 static uint8_t *bit_buffer= NULL;
723 static void do_video_out(AVFormatContext *s,
729 int nb_frames, i, ret;
730 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
731 AVFrame picture_format_temp, picture_crop_temp, picture_pad_temp;
732 uint8_t *buf = NULL, *buf1 = NULL;
733 AVCodecContext *enc, *dec;
734 enum PixelFormat target_pixfmt;
736 avcodec_get_frame_defaults(&picture_format_temp);
737 avcodec_get_frame_defaults(&picture_crop_temp);
738 avcodec_get_frame_defaults(&picture_pad_temp);
740 enc = ost->st->codec;
741 dec = ist->st->codec;
743 /* by default, we output a single frame */
748 if(video_sync_method){
750 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
751 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
754 else if (vdelta > 1.1)
755 nb_frames = lrintf(vdelta);
756 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%lld, ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, ost->sync_ipts, nb_frames);
760 fprintf(stderr, "*** drop!\n");
761 }else if (nb_frames > 1) {
762 nb_frames_dup += nb_frames;
764 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
767 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
769 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
773 /* convert pixel format if needed */
774 target_pixfmt = ost->video_resample ? PIX_FMT_YUV420P : enc->pix_fmt;
775 if (dec->pix_fmt != target_pixfmt) {
778 /* create temporary picture */
779 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
780 buf = av_malloc(size);
783 formatted_picture = &picture_format_temp;
784 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
786 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
787 (AVPicture *)in_picture, dec->pix_fmt,
788 dec->width, dec->height) < 0) {
791 fprintf(stderr, "pixel format conversion not handled\n");
796 formatted_picture = in_picture;
799 if (ost->video_crop) {
800 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)formatted_picture, target_pixfmt, ost->topBand, ost->leftBand) < 0) {
801 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
804 formatted_picture = &picture_crop_temp;
807 final_picture = formatted_picture;
808 padding_src = formatted_picture;
809 resampling_dst = &ost->pict_tmp;
810 if (ost->video_pad) {
811 final_picture = &ost->pict_tmp;
812 if (ost->video_resample) {
813 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, target_pixfmt, ost->padtop, ost->padleft) < 0) {
814 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
817 resampling_dst = &picture_pad_temp;
821 /* XXX: resampling could be done before raw format conversion in
822 some cases to go faster */
823 /* XXX: only works for YUV420P */
824 if (ost->video_resample) {
826 final_picture = &ost->pict_tmp;
827 img_resample(ost->img_resample_ctx, (AVPicture *)resampling_dst, (AVPicture*)formatted_picture);
830 if (enc->pix_fmt != target_pixfmt) {
834 /* create temporary picture */
835 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
836 buf = av_malloc(size);
839 final_picture = &picture_format_temp;
840 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
842 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
843 (AVPicture*)&ost->pict_tmp, target_pixfmt,
844 enc->width, enc->height) < 0) {
847 fprintf(stderr, "pixel format conversion not handled\n");
853 if (ost->video_pad) {
854 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
855 enc->height, enc->width, enc->pix_fmt,
856 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
859 /* duplicates frame if needed */
860 for(i=0;i<nb_frames;i++) {
862 av_init_packet(&pkt);
863 pkt.stream_index= ost->index;
865 if (s->oformat->flags & AVFMT_RAWPICTURE) {
866 /* raw pictures are written as AVPicture structure to
867 avoid any copies. We support temorarily the older
869 AVFrame* old_frame = enc->coded_frame;
870 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
871 pkt.data= (uint8_t *)final_picture;
872 pkt.size= sizeof(AVPicture);
873 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
874 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
875 if(dec->coded_frame && dec->coded_frame->key_frame)
876 pkt.flags |= PKT_FLAG_KEY;
878 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
879 enc->coded_frame = old_frame;
883 big_picture= *final_picture;
884 /* better than nothing: use input picture interlaced
886 big_picture.interlaced_frame = in_picture->interlaced_frame;
887 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
888 if(top_field_first == -1)
889 big_picture.top_field_first = in_picture->top_field_first;
891 big_picture.top_field_first = top_field_first;
894 /* handles sameq here. This is not correct because it may
895 not be a global option */
897 big_picture.quality = ist->st->quality;
899 big_picture.quality = ost->st->quality;
901 big_picture.pict_type = 0;
902 // big_picture.pts = AV_NOPTS_VALUE;
903 big_picture.pts= ost->sync_opts;
904 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
905 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
906 ret = avcodec_encode_video(enc,
907 bit_buffer, bit_buffer_size,
909 //enc->frame_number = enc->real_pict_num;
911 pkt.data= bit_buffer;
913 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
914 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
915 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
916 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
917 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
919 if(enc->coded_frame && enc->coded_frame->key_frame)
920 pkt.flags |= PKT_FLAG_KEY;
921 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
923 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
924 // enc->frame_number-1, enc->real_pict_num, ret,
926 /* if two pass, output log */
927 if (ost->logfile && enc->stats_out) {
928 fprintf(ost->logfile, "%s", enc->stats_out);
940 static double psnr(double d){
941 if(d==0) return INFINITY;
942 return -10.0*log(d)/log(10.0);
945 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
948 static FILE *fvstats=NULL;
955 double ti1, bitrate, avg_bitrate;
959 today = localtime(&today2);
960 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
963 fvstats = fopen(filename,"w");
971 enc = ost->st->codec;
972 if (enc->codec_type == CODEC_TYPE_VIDEO) {
973 frame_number = ost->frame_number;
974 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
975 if (enc->flags&CODEC_FLAG_PSNR)
976 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
978 fprintf(fvstats,"f_size= %6d ", frame_size);
979 /* compute pts value */
980 ti1 = ost->sync_opts * av_q2d(enc->time_base);
984 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
985 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
986 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
987 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
988 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
992 static void print_report(AVFormatContext **output_files,
993 AVOutputStream **ost_table, int nb_ostreams,
998 AVFormatContext *oc, *os;
1000 AVCodecContext *enc;
1001 int frame_number, vid, i;
1002 double bitrate, ti1, pts;
1003 static int64_t last_time = -1;
1004 static int qp_histogram[52];
1006 if (!is_last_report) {
1008 /* display the report every 0.5 seconds */
1009 cur_time = av_gettime();
1010 if (last_time == -1) {
1011 last_time = cur_time;
1014 if ((cur_time - last_time) < 500000)
1016 last_time = cur_time;
1020 oc = output_files[0];
1022 total_size = url_ftell(&oc->pb);
1027 for(i=0;i<nb_ostreams;i++) {
1029 os = output_files[ost->file_index];
1030 enc = ost->st->codec;
1031 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1032 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1033 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1035 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1036 frame_number = ost->frame_number;
1037 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
1038 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1040 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1041 if(qp_hist && enc->coded_frame){
1043 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1044 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1047 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1049 if (enc->flags&CODEC_FLAG_PSNR){
1051 double error, error_sum=0;
1052 double scale, scale_sum=0;
1053 char type[3]= {'Y','U','V'};
1054 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1057 error= enc->error[j];
1058 scale= enc->width*enc->height*255.0*255.0*frame_number;
1060 error= enc->coded_frame->error[j];
1061 scale= enc->width*enc->height*255.0*255.0;
1066 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1068 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1072 /* compute min output value */
1073 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1074 if ((pts < ti1) && (pts > 0))
1080 if (verbose || is_last_report) {
1081 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1083 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1084 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1085 (double)total_size / 1024, ti1, bitrate);
1088 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1089 nb_frames_dup, nb_frames_drop);
1092 fprintf(stderr, "%s \r", buf);
1097 if (is_last_report && verbose >= 0){
1098 int64_t raw= audio_size + video_size + extra_size;
1099 fprintf(stderr, "\n");
1100 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1104 100.0*(total_size - raw)/raw
1109 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1110 static int output_packet(AVInputStream *ist, int ist_index,
1111 AVOutputStream **ost_table, int nb_ostreams,
1112 const AVPacket *pkt)
1114 AVFormatContext *os;
1115 AVOutputStream *ost;
1119 int data_size, got_picture;
1121 void *buffer_to_free;
1122 static unsigned int samples_size= 0;
1123 static short *samples= NULL;
1124 AVSubtitle subtitle, *subtitle_to_free;
1128 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1129 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1130 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1132 // assert(ist->pts == ist->next_pts);
1146 /* decode the packet if needed */
1147 data_buf = NULL; /* fail safe */
1149 subtitle_to_free = NULL;
1150 if (ist->decoding_needed) {
1151 switch(ist->st->codec->codec_type) {
1152 case CODEC_TYPE_AUDIO:{
1154 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1155 /* XXX: could avoid copy if PCM 16 bits with same
1156 endianness as CPU */
1157 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1163 /* Some bug in mpeg audio decoder gives */
1164 /* data_size < 0, it seems they are overflows */
1165 if (data_size <= 0) {
1166 /* no audio frame */
1169 data_buf = (uint8_t *)samples;
1170 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1171 (ist->st->codec->sample_rate * ist->st->codec->channels);
1173 case CODEC_TYPE_VIDEO:
1174 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1175 /* XXX: allocate picture correctly */
1176 avcodec_get_frame_defaults(&picture);
1178 ret = avcodec_decode_video(ist->st->codec,
1179 &picture, &got_picture, ptr, len);
1180 ist->st->quality= picture.quality;
1184 /* no picture yet */
1185 goto discard_packet;
1187 if (ist->st->codec->time_base.num != 0) {
1188 ist->next_pts += ((int64_t)AV_TIME_BASE *
1189 ist->st->codec->time_base.num) /
1190 ist->st->codec->time_base.den;
1194 case CODEC_TYPE_SUBTITLE:
1195 ret = avcodec_decode_subtitle(ist->st->codec,
1196 &subtitle, &got_subtitle, ptr, len);
1199 if (!got_subtitle) {
1200 goto discard_packet;
1202 subtitle_to_free = &subtitle;
1209 switch(ist->st->codec->codec_type) {
1210 case CODEC_TYPE_AUDIO:
1211 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1212 (ist->st->codec->sample_rate * ist->st->codec->channels);
1214 case CODEC_TYPE_VIDEO:
1215 if (ist->st->codec->time_base.num != 0) {
1216 ist->next_pts += ((int64_t)AV_TIME_BASE *
1217 ist->st->codec->time_base.num) /
1218 ist->st->codec->time_base.den;
1228 buffer_to_free = NULL;
1229 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1230 pre_process_video_frame(ist, (AVPicture *)&picture,
1234 // preprocess audio (volume)
1235 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1236 if (audio_volume != 256) {
1239 for(i=0;i<(data_size / sizeof(short));i++) {
1240 int v = ((*volp) * audio_volume + 128) >> 8;
1241 if (v < -32768) v = -32768;
1242 if (v > 32767) v = 32767;
1248 /* frame rate emulation */
1249 if (ist->st->codec->rate_emu) {
1250 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1251 int64_t now = av_gettime() - ist->start;
1259 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1260 is the one of the next displayed one */
1261 /* XXX: add mpeg4 too ? */
1262 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1263 if (ist->st->codec->pict_type != B_TYPE) {
1265 tmp = ist->last_ip_pts;
1266 ist->last_ip_pts = ist->frac_pts.val;
1267 ist->frac_pts.val = tmp;
1271 /* if output time reached then transcode raw format,
1272 encode packets and output them */
1273 if (start_time == 0 || ist->pts >= start_time)
1274 for(i=0;i<nb_ostreams;i++) {
1278 if (ost->source_index == ist_index) {
1279 os = output_files[ost->file_index];
1282 printf("%d: got pts=%0.3f %0.3f\n", i,
1283 (double)pkt->pts / AV_TIME_BASE,
1284 ((double)ist->pts / AV_TIME_BASE) -
1285 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1287 /* set the input output pts pairs */
1288 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1290 if (ost->encoding_needed) {
1291 switch(ost->st->codec->codec_type) {
1292 case CODEC_TYPE_AUDIO:
1293 do_audio_out(os, ost, ist, data_buf, data_size);
1295 case CODEC_TYPE_VIDEO:
1296 do_video_out(os, ost, ist, &picture, &frame_size);
1297 video_size += frame_size;
1298 if (do_vstats && frame_size)
1299 do_video_stats(os, ost, frame_size);
1301 case CODEC_TYPE_SUBTITLE:
1302 do_subtitle_out(os, ost, ist, &subtitle,
1309 AVFrame avframe; //FIXME/XXX remove this
1311 av_init_packet(&opkt);
1313 /* no reencoding needed : output the packet directly */
1314 /* force the input stream PTS */
1316 avcodec_get_frame_defaults(&avframe);
1317 ost->st->codec->coded_frame= &avframe;
1318 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1320 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1321 audio_size += data_size;
1322 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1323 video_size += data_size;
1327 opkt.stream_index= ost->index;
1328 if(pkt->pts != AV_NOPTS_VALUE)
1329 opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1331 opkt.pts= AV_NOPTS_VALUE;
1335 if (pkt->dts == AV_NOPTS_VALUE)
1336 dts = ist->next_pts;
1338 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1339 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1341 opkt.flags= pkt->flags;
1343 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1344 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1345 opkt.destruct= av_destruct_packet;
1347 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1348 ost->st->codec->frame_number++;
1349 ost->frame_number++;
1350 av_free_packet(&opkt);
1354 av_free(buffer_to_free);
1355 /* XXX: allocate the subtitles in the codec ? */
1356 if (subtitle_to_free) {
1357 if (subtitle_to_free->rects != NULL) {
1358 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1359 av_free(subtitle_to_free->rects[i].bitmap);
1360 av_free(subtitle_to_free->rects[i].rgba_palette);
1362 av_freep(&subtitle_to_free->rects);
1364 subtitle_to_free->num_rects = 0;
1365 subtitle_to_free = NULL;
1372 for(i=0;i<nb_ostreams;i++) {
1374 if (ost->source_index == ist_index) {
1375 AVCodecContext *enc= ost->st->codec;
1376 os = output_files[ost->file_index];
1378 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1380 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1383 if (ost->encoding_needed) {
1387 av_init_packet(&pkt);
1388 pkt.stream_index= ost->index;
1390 switch(ost->st->codec->codec_type) {
1391 case CODEC_TYPE_AUDIO:
1392 fifo_bytes = fifo_size(&ost->fifo, NULL);
1394 /* encode any samples remaining in fifo */
1395 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1396 int fs_tmp = enc->frame_size;
1397 enc->frame_size = fifo_bytes / (2 * enc->channels);
1398 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1399 &ost->fifo.rptr) == 0) {
1400 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1402 enc->frame_size = fs_tmp;
1405 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1408 pkt.flags |= PKT_FLAG_KEY;
1410 case CODEC_TYPE_VIDEO:
1411 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1413 if(enc->coded_frame && enc->coded_frame->key_frame)
1414 pkt.flags |= PKT_FLAG_KEY;
1415 if (ost->logfile && enc->stats_out) {
1416 fprintf(ost->logfile, "%s", enc->stats_out);
1425 pkt.data= bit_buffer;
1427 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1428 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1429 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1443 * The following code is the main loop of the file converter
1445 static int av_encode(AVFormatContext **output_files,
1446 int nb_output_files,
1447 AVFormatContext **input_files,
1449 AVStreamMap *stream_maps, int nb_stream_maps)
1451 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1452 AVFormatContext *is, *os;
1453 AVCodecContext *codec, *icodec;
1454 AVOutputStream *ost, **ost_table = NULL;
1455 AVInputStream *ist, **ist_table = NULL;
1456 AVInputFile *file_table;
1457 AVFormatContext *stream_no_data;
1460 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1464 /* input stream init */
1466 for(i=0;i<nb_input_files;i++) {
1467 is = input_files[i];
1468 file_table[i].ist_index = j;
1469 file_table[i].nb_streams = is->nb_streams;
1470 j += is->nb_streams;
1474 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1478 for(i=0;i<nb_istreams;i++) {
1479 ist = av_mallocz(sizeof(AVInputStream));
1485 for(i=0;i<nb_input_files;i++) {
1486 is = input_files[i];
1487 for(k=0;k<is->nb_streams;k++) {
1488 ist = ist_table[j++];
1489 ist->st = is->streams[k];
1490 ist->file_index = i;
1492 ist->discard = 1; /* the stream is discarded by default
1495 if (ist->st->codec->rate_emu) {
1496 ist->start = av_gettime();
1502 /* output stream init */
1504 for(i=0;i<nb_output_files;i++) {
1505 os = output_files[i];
1506 nb_ostreams += os->nb_streams;
1508 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1509 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1513 /* Sanity check the mapping args -- do the input files & streams exist? */
1514 for(i=0;i<nb_stream_maps;i++) {
1515 int fi = stream_maps[i].file_index;
1516 int si = stream_maps[i].stream_index;
1518 if (fi < 0 || fi > nb_input_files - 1 ||
1519 si < 0 || si > file_table[fi].nb_streams - 1) {
1520 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1523 fi = stream_maps[i].sync_file_index;
1524 si = stream_maps[i].sync_stream_index;
1525 if (fi < 0 || fi > nb_input_files - 1 ||
1526 si < 0 || si > file_table[fi].nb_streams - 1) {
1527 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1532 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1535 for(i=0;i<nb_ostreams;i++) {
1536 ost = av_mallocz(sizeof(AVOutputStream));
1543 for(k=0;k<nb_output_files;k++) {
1544 os = output_files[k];
1545 for(i=0;i<os->nb_streams;i++) {
1547 ost = ost_table[n++];
1548 ost->file_index = k;
1550 ost->st = os->streams[i];
1551 if (nb_stream_maps > 0) {
1552 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1553 stream_maps[n-1].stream_index;
1555 /* Sanity check that the stream types match */
1556 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1557 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1558 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1559 ost->file_index, ost->index);
1564 /* get corresponding input stream index : we select the first one with the right type */
1566 for(j=0;j<nb_istreams;j++) {
1569 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1570 ost->source_index = j;
1577 /* try again and reuse existing stream */
1578 for(j=0;j<nb_istreams;j++) {
1580 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1581 ost->source_index = j;
1586 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1587 ost->file_index, ost->index);
1592 ist = ist_table[ost->source_index];
1594 ost->sync_ist = (nb_stream_maps > 0) ?
1595 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1596 stream_maps[n-1].sync_stream_index] : ist;
1600 /* for each output stream, we compute the right encoding parameters */
1601 for(i=0;i<nb_ostreams;i++) {
1603 ist = ist_table[ost->source_index];
1605 codec = ost->st->codec;
1606 icodec = ist->st->codec;
1608 if (ost->st->stream_copy) {
1609 /* if stream_copy is selected, no need to decode or encode */
1610 codec->codec_id = icodec->codec_id;
1611 codec->codec_type = icodec->codec_type;
1612 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1613 codec->bit_rate = icodec->bit_rate;
1614 codec->extradata= icodec->extradata;
1615 codec->extradata_size= icodec->extradata_size;
1616 codec->time_base = icodec->time_base;
1617 switch(codec->codec_type) {
1618 case CODEC_TYPE_AUDIO:
1619 codec->sample_rate = icodec->sample_rate;
1620 codec->channels = icodec->channels;
1621 codec->frame_size = icodec->frame_size;
1622 codec->block_align= icodec->block_align;
1624 case CODEC_TYPE_VIDEO:
1625 codec->pix_fmt = icodec->pix_fmt;
1626 codec->width = icodec->width;
1627 codec->height = icodec->height;
1628 codec->has_b_frames = icodec->has_b_frames;
1630 case CODEC_TYPE_SUBTITLE:
1636 switch(codec->codec_type) {
1637 case CODEC_TYPE_AUDIO:
1638 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1641 if (codec->channels == icodec->channels &&
1642 codec->sample_rate == icodec->sample_rate) {
1643 ost->audio_resample = 0;
1645 if (codec->channels != icodec->channels &&
1646 (icodec->codec_id == CODEC_ID_AC3 ||
1647 icodec->codec_id == CODEC_ID_DTS)) {
1648 /* Special case for 5:1 AC3 and DTS input */
1649 /* and mono or stereo output */
1650 /* Request specific number of channels */
1651 icodec->channels = codec->channels;
1652 if (codec->sample_rate == icodec->sample_rate)
1653 ost->audio_resample = 0;
1655 ost->audio_resample = 1;
1658 ost->audio_resample = 1;
1661 if(audio_sync_method>1)
1662 ost->audio_resample = 1;
1664 if(ost->audio_resample){
1665 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1666 codec->sample_rate, icodec->sample_rate);
1668 printf("Can't resample. Aborting.\n");
1672 ist->decoding_needed = 1;
1673 ost->encoding_needed = 1;
1675 case CODEC_TYPE_VIDEO:
1676 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1677 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1678 ost->video_resample = ((codec->width != icodec->width -
1679 (frame_leftBand + frame_rightBand) +
1680 (frame_padleft + frame_padright)) ||
1681 (codec->height != icodec->height -
1682 (frame_topBand + frame_bottomBand) +
1683 (frame_padtop + frame_padbottom)));
1684 if (ost->video_crop) {
1685 ost->topBand = frame_topBand;
1686 ost->leftBand = frame_leftBand;
1688 if (ost->video_pad) {
1689 ost->padtop = frame_padtop;
1690 ost->padleft = frame_padleft;
1691 ost->padbottom = frame_padbottom;
1692 ost->padright = frame_padright;
1693 if (!ost->video_resample) {
1694 avcodec_get_frame_defaults(&ost->pict_tmp);
1695 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1696 codec->width, codec->height ) )
1700 if (ost->video_resample) {
1701 avcodec_get_frame_defaults(&ost->pict_tmp);
1702 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1703 codec->width, codec->height ) )
1706 ost->img_resample_ctx = img_resample_init(
1707 codec->width - (frame_padleft + frame_padright),
1708 codec->height - (frame_padtop + frame_padbottom),
1709 icodec->width - (frame_leftBand + frame_rightBand),
1710 icodec->height - (frame_topBand + frame_bottomBand));
1713 ost->encoding_needed = 1;
1714 ist->decoding_needed = 1;
1716 case CODEC_TYPE_SUBTITLE:
1717 ost->encoding_needed = 1;
1718 ist->decoding_needed = 1;
1725 if (ost->encoding_needed &&
1726 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1727 char logfilename[1024];
1732 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1734 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1735 if (codec->flags & CODEC_FLAG_PASS1) {
1736 f = fopen(logfilename, "w");
1738 perror(logfilename);
1743 /* read the log file */
1744 f = fopen(logfilename, "r");
1746 perror(logfilename);
1749 fseek(f, 0, SEEK_END);
1751 fseek(f, 0, SEEK_SET);
1752 logbuffer = av_malloc(size + 1);
1754 fprintf(stderr, "Could not allocate log buffer\n");
1757 size = fread(logbuffer, 1, size, f);
1759 logbuffer[size] = '\0';
1760 codec->stats_in = logbuffer;
1764 if(codec->codec_type == CODEC_TYPE_VIDEO){
1765 int size= codec->width * codec->height;
1766 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1771 bit_buffer = av_malloc(bit_buffer_size);
1775 /* dump the file output parameters - cannot be done before in case
1777 for(i=0;i<nb_output_files;i++) {
1778 dump_format(output_files[i], i, output_files[i]->filename, 1);
1781 /* dump the stream mapping */
1783 fprintf(stderr, "Stream mapping:\n");
1784 for(i=0;i<nb_ostreams;i++) {
1786 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1787 ist_table[ost->source_index]->file_index,
1788 ist_table[ost->source_index]->index,
1791 if (ost->sync_ist != ist_table[ost->source_index])
1792 fprintf(stderr, " [sync #%d.%d]",
1793 ost->sync_ist->file_index,
1794 ost->sync_ist->index);
1795 fprintf(stderr, "\n");
1799 /* open each encoder */
1800 for(i=0;i<nb_ostreams;i++) {
1802 if (ost->encoding_needed) {
1804 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1806 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1807 ost->file_index, ost->index);
1810 if (avcodec_open(ost->st->codec, codec) < 0) {
1811 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1812 ost->file_index, ost->index);
1815 extra_size += ost->st->codec->extradata_size;
1819 /* open each decoder */
1820 for(i=0;i<nb_istreams;i++) {
1822 if (ist->decoding_needed) {
1824 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1826 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1827 ist->st->codec->codec_id, ist->file_index, ist->index);
1830 if (avcodec_open(ist->st->codec, codec) < 0) {
1831 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1832 ist->file_index, ist->index);
1835 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1836 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1841 for(i=0;i<nb_istreams;i++) {
1843 is = input_files[ist->file_index];
1845 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1846 if(ist->st->start_time == AV_NOPTS_VALUE)
1848 if(input_files_ts_offset[ist->file_index])
1849 ist->next_pts= AV_NOPTS_VALUE;
1853 /* compute buffer size max (should use a complete heuristic) */
1854 for(i=0;i<nb_input_files;i++) {
1855 file_table[i].buffer_size_max = 2048;
1858 /* set meta data information from input file if required */
1859 for (i=0;i<nb_meta_data_maps;i++) {
1860 AVFormatContext *out_file;
1861 AVFormatContext *in_file;
1863 int out_file_index = meta_data_maps[i].out_file;
1864 int in_file_index = meta_data_maps[i].in_file;
1865 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1866 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1870 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1871 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1876 out_file = output_files[out_file_index];
1877 in_file = input_files[in_file_index];
1879 strcpy(out_file->title, in_file->title);
1880 strcpy(out_file->author, in_file->author);
1881 strcpy(out_file->copyright, in_file->copyright);
1882 strcpy(out_file->comment, in_file->comment);
1883 strcpy(out_file->album, in_file->album);
1884 out_file->year = in_file->year;
1885 out_file->track = in_file->track;
1886 strcpy(out_file->genre, in_file->genre);
1889 /* open files and write file headers */
1890 for(i=0;i<nb_output_files;i++) {
1891 os = output_files[i];
1892 if (av_write_header(os) < 0) {
1893 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1899 #ifndef CONFIG_WIN32
1900 if ( !using_stdin && verbose >= 0) {
1901 fprintf(stderr, "Press [q] to stop encoding\n");
1902 url_set_interrupt_cb(decode_interrupt_cb);
1910 for(; received_sigterm == 0;) {
1911 int file_index, ist_index;
1919 /* if 'q' pressed, exits */
1923 /* read_key() returns 0 on EOF */
1929 /* select the stream that we must read now by looking at the
1930 smallest output pts */
1932 for(i=0;i<nb_ostreams;i++) {
1935 os = output_files[ost->file_index];
1936 ist = ist_table[ost->source_index];
1937 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1938 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1940 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1941 ipts = (double)ist->pts;
1942 if (!file_table[ist->file_index].eof_reached){
1943 if(ipts < ipts_min) {
1945 if(input_sync ) file_index = ist->file_index;
1947 if(opts < opts_min) {
1949 if(!input_sync) file_index = ist->file_index;
1952 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1957 /* if none, if is finished */
1958 if (file_index < 0) {
1962 /* finish if recording time exhausted */
1963 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1966 /* finish if limit size exhausted */
1967 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1970 /* read a frame from it and output it in the fifo */
1971 is = input_files[file_index];
1972 if (av_read_frame(is, &pkt) < 0) {
1973 file_table[file_index].eof_reached = 1;
1974 if (opt_shortest) break; else continue; //
1978 stream_no_data = is;
1983 av_pkt_dump(stdout, &pkt, do_hex_dump);
1985 /* the following test is needed in case new streams appear
1986 dynamically in stream : we ignore them */
1987 if (pkt.stream_index >= file_table[file_index].nb_streams)
1988 goto discard_packet;
1989 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1990 ist = ist_table[ist_index];
1992 goto discard_packet;
1994 // fprintf(stderr, "next:%lld dts:%lld off:%lld %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
1995 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1996 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1997 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1998 input_files_ts_offset[ist->file_index]-= delta;
2000 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2001 for(i=0; i<file_table[file_index].nb_streams; i++){
2002 int index= file_table[file_index].ist_index + i;
2003 ist_table[index]->next_pts += delta;
2004 ist_table[index]->is_start=1;
2009 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2010 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2013 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2014 ist->file_index, ist->index);
2016 av_free_packet(&pkt);
2021 av_free_packet(&pkt);
2023 /* dump report by using the output first video and audio streams */
2024 print_report(output_files, ost_table, nb_ostreams, 0);
2027 /* at the end of stream, we must flush the decoder buffers */
2028 for(i=0;i<nb_istreams;i++) {
2030 if (ist->decoding_needed) {
2031 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2037 /* write the trailer if needed and close file */
2038 for(i=0;i<nb_output_files;i++) {
2039 os = output_files[i];
2040 av_write_trailer(os);
2043 /* dump report by using the first video and audio streams */
2044 print_report(output_files, ost_table, nb_ostreams, 1);
2046 /* close each encoder */
2047 for(i=0;i<nb_ostreams;i++) {
2049 if (ost->encoding_needed) {
2050 av_freep(&ost->st->codec->stats_in);
2051 avcodec_close(ost->st->codec);
2055 /* close each decoder */
2056 for(i=0;i<nb_istreams;i++) {
2058 if (ist->decoding_needed) {
2059 avcodec_close(ist->st->codec);
2067 av_freep(&bit_buffer);
2068 av_free(file_table);
2071 for(i=0;i<nb_istreams;i++) {
2078 for(i=0;i<nb_ostreams;i++) {
2082 fclose(ost->logfile);
2083 ost->logfile = NULL;
2085 fifo_free(&ost->fifo); /* works even if fifo is not
2086 initialized but set to zero */
2087 av_free(ost->pict_tmp.data[0]);
2088 if (ost->video_resample)
2089 img_resample_close(ost->img_resample_ctx);
2090 if (ost->audio_resample)
2091 audio_resample_close(ost->resample);
2104 int file_read(const char *filename)
2107 unsigned char buffer[1024];
2110 if (url_open(&h, filename, O_RDONLY) < 0) {
2111 printf("could not open '%s'\n", filename);
2115 len = url_read(h, buffer, sizeof(buffer));
2118 for(i=0;i<len;i++) putchar(buffer[i]);
2125 static void opt_image_format(const char *arg)
2129 for(f = first_image_format; f != NULL; f = f->next) {
2130 if (!strcmp(arg, f->name))
2134 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2140 static void opt_format(const char *arg)
2142 /* compatibility stuff for pgmyuv */
2143 if (!strcmp(arg, "pgmyuv")) {
2144 pgmyuv_compatibility_hack=1;
2145 // opt_image_format(arg);
2149 file_iformat = av_find_input_format(arg);
2150 file_oformat = guess_format(arg, NULL, NULL);
2151 if (!file_iformat && !file_oformat) {
2152 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2157 static void opt_video_bitrate(const char *arg)
2159 video_bit_rate = atoi(arg) * 1000;
2162 static void opt_video_bitrate_tolerance(const char *arg)
2164 video_bit_rate_tolerance = atoi(arg) * 1000;
2167 static void opt_video_bitrate_max(const char *arg)
2169 video_rc_max_rate = atoi(arg) * 1000;
2172 static void opt_video_bitrate_min(const char *arg)
2174 video_rc_min_rate = atoi(arg) * 1000;
2177 static void opt_video_buffer_size(const char *arg)
2179 video_rc_buffer_size = atoi(arg) * 8*1024;
2182 static void opt_video_rc_eq(char *arg)
2187 static void opt_video_rc_override_string(char *arg)
2189 video_rc_override_string = arg;
2193 static void opt_workaround_bugs(const char *arg)
2195 workaround_bugs = atoi(arg);
2198 static void opt_me_threshold(const char *arg)
2200 me_threshold = atoi(arg);
2203 static void opt_mb_threshold(const char *arg)
2205 mb_threshold = atoi(arg);
2208 static void opt_verbose(const char *arg)
2210 verbose = atoi(arg);
2211 av_log_set_level(atoi(arg));
2214 static void opt_frame_rate(const char *arg)
2216 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2217 fprintf(stderr, "Incorrect frame rate\n");
2222 static void opt_frame_crop_top(const char *arg)
2224 frame_topBand = atoi(arg);
2225 if (frame_topBand < 0) {
2226 fprintf(stderr, "Incorrect top crop size\n");
2229 if ((frame_topBand % 2) != 0) {
2230 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2233 if ((frame_topBand) >= frame_height){
2234 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2237 frame_height -= frame_topBand;
2240 static void opt_frame_crop_bottom(const char *arg)
2242 frame_bottomBand = atoi(arg);
2243 if (frame_bottomBand < 0) {
2244 fprintf(stderr, "Incorrect bottom crop size\n");
2247 if ((frame_bottomBand % 2) != 0) {
2248 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2251 if ((frame_bottomBand) >= frame_height){
2252 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2255 frame_height -= frame_bottomBand;
2258 static void opt_frame_crop_left(const char *arg)
2260 frame_leftBand = atoi(arg);
2261 if (frame_leftBand < 0) {
2262 fprintf(stderr, "Incorrect left crop size\n");
2265 if ((frame_leftBand % 2) != 0) {
2266 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2269 if ((frame_leftBand) >= frame_width){
2270 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2273 frame_width -= frame_leftBand;
2276 static void opt_frame_crop_right(const char *arg)
2278 frame_rightBand = atoi(arg);
2279 if (frame_rightBand < 0) {
2280 fprintf(stderr, "Incorrect right crop size\n");
2283 if ((frame_rightBand % 2) != 0) {
2284 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2287 if ((frame_rightBand) >= frame_width){
2288 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2291 frame_width -= frame_rightBand;
2294 static void opt_frame_size(const char *arg)
2296 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2297 fprintf(stderr, "Incorrect frame size\n");
2300 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2301 fprintf(stderr, "Frame size must be a multiple of 2\n");
2307 #define SCALEBITS 10
2308 #define ONE_HALF (1 << (SCALEBITS - 1))
2309 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2311 #define RGB_TO_Y(r, g, b) \
2312 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2313 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2315 #define RGB_TO_U(r1, g1, b1, shift)\
2316 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2317 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2319 #define RGB_TO_V(r1, g1, b1, shift)\
2320 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2321 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2323 static void opt_pad_color(const char *arg) {
2324 /* Input is expected to be six hex digits similar to
2325 how colors are expressed in html tags (but without the #) */
2326 int rgb = strtol(arg, NULL, 16);
2330 g = ((rgb >> 8) & 255);
2333 padcolor[0] = RGB_TO_Y(r,g,b);
2334 padcolor[1] = RGB_TO_U(r,g,b,0);
2335 padcolor[2] = RGB_TO_V(r,g,b,0);
2338 static void opt_frame_pad_top(const char *arg)
2340 frame_padtop = atoi(arg);
2341 if (frame_padtop < 0) {
2342 fprintf(stderr, "Incorrect top pad size\n");
2345 if ((frame_padtop % 2) != 0) {
2346 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2351 static void opt_frame_pad_bottom(const char *arg)
2353 frame_padbottom = atoi(arg);
2354 if (frame_padbottom < 0) {
2355 fprintf(stderr, "Incorrect bottom pad size\n");
2358 if ((frame_padbottom % 2) != 0) {
2359 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2365 static void opt_frame_pad_left(const char *arg)
2367 frame_padleft = atoi(arg);
2368 if (frame_padleft < 0) {
2369 fprintf(stderr, "Incorrect left pad size\n");
2372 if ((frame_padleft % 2) != 0) {
2373 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2379 static void opt_frame_pad_right(const char *arg)
2381 frame_padright = atoi(arg);
2382 if (frame_padright < 0) {
2383 fprintf(stderr, "Incorrect right pad size\n");
2386 if ((frame_padright % 2) != 0) {
2387 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2393 static void opt_frame_pix_fmt(const char *arg)
2395 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2398 static void opt_frame_aspect_ratio(const char *arg)
2404 p = strchr(arg, ':');
2406 x = strtol(arg, (char **)&arg, 10);
2408 y = strtol(arg+1, (char **)&arg, 10);
2410 ar = (double)x / (double)y;
2412 ar = strtod(arg, (char **)&arg);
2415 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2418 frame_aspect_ratio = ar;
2421 static void opt_gop_size(const char *arg)
2423 gop_size = atoi(arg);
2426 static void opt_b_frames(const char *arg)
2428 b_frames = atoi(arg);
2429 if (b_frames > FF_MAX_B_FRAMES) {
2430 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2432 } else if (b_frames < 1) {
2433 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2438 static void opt_pre_me(const char *arg)
2443 static void opt_qscale(const char *arg)
2445 video_qscale = atof(arg);
2446 if (video_qscale <= 0 ||
2447 video_qscale > 255) {
2448 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2453 static void opt_qsquish(const char *arg)
2455 video_qsquish = atof(arg);
2456 if (video_qsquish < 0.0 ||
2457 video_qsquish > 99.0) {
2458 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2463 static void opt_lmax(const char *arg)
2465 video_lmax = atof(arg)*FF_QP2LAMBDA;
2468 static void opt_lmin(const char *arg)
2470 video_lmin = atof(arg)*FF_QP2LAMBDA;
2473 static void opt_qmin(const char *arg)
2475 video_qmin = atoi(arg);
2476 if (video_qmin < 1 ||
2478 fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2483 static void opt_qmax(const char *arg)
2485 video_qmax = atoi(arg);
2486 if (video_qmax < 1 ||
2488 fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2493 static void opt_mb_lmin(const char *arg)
2495 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2496 if (video_mb_lmin < 1 ||
2497 video_mb_lmin > FF_LAMBDA_MAX) {
2498 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2503 static void opt_mb_lmax(const char *arg)
2505 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2506 if (video_mb_lmax < 1 ||
2507 video_mb_lmax > FF_LAMBDA_MAX) {
2508 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2513 static void opt_qdiff(const char *arg)
2515 video_qdiff = atoi(arg);
2516 if (video_qdiff < 0 ||
2518 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2523 static void opt_qblur(const char *arg)
2525 video_qblur = atof(arg);
2528 static void opt_qcomp(const char *arg)
2530 video_qcomp = atof(arg);
2533 static void opt_rc_initial_cplx(const char *arg)
2535 video_rc_initial_cplx = atof(arg);
2537 static void opt_b_qfactor(const char *arg)
2539 video_b_qfactor = atof(arg);
2541 static void opt_i_qfactor(const char *arg)
2543 video_i_qfactor = atof(arg);
2545 static void opt_b_qoffset(const char *arg)
2547 video_b_qoffset = atof(arg);
2549 static void opt_i_qoffset(const char *arg)
2551 video_i_qoffset = atof(arg);
2554 static void opt_ibias(const char *arg)
2556 video_intra_quant_bias = atoi(arg);
2558 static void opt_pbias(const char *arg)
2560 video_inter_quant_bias = atoi(arg);
2563 static void opt_packet_size(const char *arg)
2565 packet_size= atoi(arg);
2568 static void opt_error_rate(const char *arg)
2570 error_rate= atoi(arg);
2573 static void opt_strict(const char *arg)
2578 static void opt_top_field_first(const char *arg)
2580 top_field_first= atoi(arg);
2583 static void opt_sc_threshold(const char *arg)
2585 sc_threshold= atoi(arg);
2588 static void opt_me_range(const char *arg)
2590 me_range = atoi(arg);
2593 static void opt_thread_count(const char *arg)
2595 thread_count= atoi(arg);
2596 #if !defined(HAVE_THREADS)
2598 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2602 static void opt_audio_bitrate(const char *arg)
2604 audio_bit_rate = atoi(arg) * 1000;
2607 static void opt_audio_rate(const char *arg)
2609 audio_sample_rate = atoi(arg);
2612 static void opt_audio_channels(const char *arg)
2614 audio_channels = atoi(arg);
2617 static void opt_video_device(const char *arg)
2619 video_device = av_strdup(arg);
2622 static void opt_grab_device(const char *arg)
2624 grab_device = av_strdup(arg);
2627 static void opt_video_channel(const char *arg)
2629 video_channel = strtol(arg, NULL, 0);
2632 static void opt_video_standard(const char *arg)
2634 video_standard = av_strdup(arg);
2637 static void opt_audio_device(const char *arg)
2639 audio_device = av_strdup(arg);
2642 static void opt_codec(int *pstream_copy, int *pcodec_id,
2643 int codec_type, const char *arg)
2647 if (!strcmp(arg, "copy")) {
2652 if (!strcmp(p->name, arg) && p->type == codec_type)
2657 fprintf(stderr, "Unknown codec '%s'\n", arg);
2665 static void opt_audio_codec(const char *arg)
2667 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2670 static void opt_audio_tag(const char *arg)
2673 audio_codec_tag= strtol(arg, &tail, 0);
2676 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2679 static void opt_video_tag(const char *arg)
2682 video_codec_tag= strtol(arg, &tail, 0);
2685 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2688 static void add_frame_hooker(const char *arg)
2693 char *args = av_strdup(arg);
2697 argv[0] = strtok(args, " ");
2698 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2701 i = frame_hook_add(argc, argv);
2704 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2709 const char *motion_str[] = {
2722 static void opt_motion_estimation(const char *arg)
2728 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2731 if (!strcmp(*p, arg))
2735 me_method = (p - motion_str) + 1;
2738 static void opt_video_codec(const char *arg)
2740 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2743 static void opt_subtitle_codec(const char *arg)
2745 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2748 static void opt_map(const char *arg)
2754 m = &stream_maps[nb_stream_maps++];
2756 m->file_index = strtol(arg, (char **)&p, 0);
2760 m->stream_index = strtol(p, (char **)&p, 0);
2763 m->sync_file_index = strtol(p, (char **)&p, 0);
2766 m->sync_stream_index = strtol(p, (char **)&p, 0);
2768 m->sync_file_index = m->file_index;
2769 m->sync_stream_index = m->stream_index;
2773 static void opt_map_meta_data(const char *arg)
2779 m = &meta_data_maps[nb_meta_data_maps++];
2781 m->out_file = strtol(arg, (char **)&p, 0);
2785 m->in_file = strtol(p, (char **)&p, 0);
2788 static void opt_recording_time(const char *arg)
2790 recording_time = parse_date(arg, 1);
2793 static void opt_start_time(const char *arg)
2795 start_time = parse_date(arg, 1);
2798 static void opt_rec_timestamp(const char *arg)
2800 rec_timestamp = parse_date(arg, 0) / 1000000;
2803 static void opt_input_ts_offset(const char *arg)
2805 input_ts_offset = parse_date(arg, 1);
2808 static void opt_input_file(const char *filename)
2810 AVFormatContext *ic;
2811 AVFormatParameters params, *ap = ¶ms;
2812 int err, i, ret, rfps, rfps_base;
2815 if (!strcmp(filename, "-"))
2818 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2819 !strcmp( filename, "/dev/stdin" );
2821 /* get default parameters from command line */
2822 memset(ap, 0, sizeof(*ap));
2823 ap->sample_rate = audio_sample_rate;
2824 ap->channels = audio_channels;
2825 ap->time_base.den = frame_rate;
2826 ap->time_base.num = frame_rate_base;
2827 ap->width = frame_width + frame_padleft + frame_padright;
2828 ap->height = frame_height + frame_padtop + frame_padbottom;
2829 ap->image_format = image_format;
2830 ap->pix_fmt = frame_pix_fmt;
2831 ap->device = grab_device;
2832 ap->channel = video_channel;
2833 ap->standard = video_standard;
2834 ap->video_codec_id = video_codec_id;
2835 ap->audio_codec_id = audio_codec_id;
2836 if(pgmyuv_compatibility_hack)
2837 ap->video_codec_id= CODEC_ID_PGMYUV;
2839 /* open the input file with generic libav function */
2840 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2842 print_error(filename, err);
2847 ic->flags|= AVFMT_FLAG_GENPTS;
2849 /* If not enough info to get the stream parameters, we decode the
2850 first frames to get it. (used in mpeg case for example) */
2851 ret = av_find_stream_info(ic);
2852 if (ret < 0 && verbose >= 0) {
2853 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2857 timestamp = start_time;
2858 /* add the stream start time */
2859 if (ic->start_time != AV_NOPTS_VALUE)
2860 timestamp += ic->start_time;
2862 /* if seeking requested, we execute it */
2863 if (start_time != 0) {
2864 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2866 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2867 filename, (double)timestamp / AV_TIME_BASE);
2869 /* reset seek info */
2873 /* update the current parameters so that they match the one of the input stream */
2874 for(i=0;i<ic->nb_streams;i++) {
2876 AVCodecContext *enc = ic->streams[i]->codec;
2877 #if defined(HAVE_THREADS)
2879 avcodec_thread_init(enc, thread_count);
2881 enc->thread_count= thread_count;
2882 switch(enc->codec_type) {
2883 case CODEC_TYPE_AUDIO:
2884 for(j=0; j<opt_name_count; j++){
2886 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2887 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2888 av_set_double(enc, opt_names[j], d);
2890 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2891 audio_channels = enc->channels;
2892 audio_sample_rate = enc->sample_rate;
2894 ic->streams[i]->discard= AVDISCARD_ALL;
2896 case CODEC_TYPE_VIDEO:
2897 for(j=0; j<opt_name_count; j++){
2899 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2900 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2901 av_set_double(enc, opt_names[j], d);
2903 frame_height = enc->height;
2904 frame_width = enc->width;
2905 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2906 frame_pix_fmt = enc->pix_fmt;
2907 rfps = ic->streams[i]->r_frame_rate.num;
2908 rfps_base = ic->streams[i]->r_frame_rate.den;
2909 enc->workaround_bugs = workaround_bugs;
2910 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2912 enc->debug |= FF_DEBUG_MV;
2914 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2917 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2918 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2920 (float)rfps / rfps_base, rfps, rfps_base);
2922 /* update the current frame rate to match the stream frame rate */
2924 frame_rate_base = rfps_base;
2926 enc->rate_emu = rate_emu;
2928 ic->streams[i]->discard= AVDISCARD_ALL;
2929 else if(video_discard)
2930 ic->streams[i]->discard= video_discard;
2932 case CODEC_TYPE_DATA:
2934 case CODEC_TYPE_SUBTITLE:
2936 case CODEC_TYPE_UNKNOWN:
2943 input_files[nb_input_files] = ic;
2944 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2945 /* dump the file content */
2947 dump_format(ic, nb_input_files, filename, 0);
2950 file_iformat = NULL;
2951 file_oformat = NULL;
2952 image_format = NULL;
2960 static void opt_grab(const char *arg)
2962 file_iformat = av_find_input_format(arg);
2966 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2968 int has_video, has_audio, i, j;
2969 AVFormatContext *ic;
2973 for(j=0;j<nb_input_files;j++) {
2974 ic = input_files[j];
2975 for(i=0;i<ic->nb_streams;i++) {
2976 AVCodecContext *enc = ic->streams[i]->codec;
2977 switch(enc->codec_type) {
2978 case CODEC_TYPE_AUDIO:
2981 case CODEC_TYPE_VIDEO:
2984 case CODEC_TYPE_DATA:
2985 case CODEC_TYPE_UNKNOWN:
2986 case CODEC_TYPE_SUBTITLE:
2993 *has_video_ptr = has_video;
2994 *has_audio_ptr = has_audio;
2997 static void new_video_stream(AVFormatContext *oc)
3000 AVCodecContext *video_enc;
3003 st = av_new_stream(oc, oc->nb_streams);
3005 fprintf(stderr, "Could not alloc stream\n");
3008 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3009 video_bitstream_filters= NULL;
3011 #if defined(HAVE_THREADS)
3013 avcodec_thread_init(st->codec, thread_count);
3016 video_enc = st->codec;
3019 video_enc->codec_tag= video_codec_tag;
3021 if( (video_global_header&1)
3022 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3023 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3024 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3026 if(video_global_header&2){
3027 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3028 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3031 if (video_stream_copy) {
3032 st->stream_copy = 1;
3033 video_enc->codec_type = CODEC_TYPE_VIDEO;
3039 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3040 if (video_codec_id != CODEC_ID_NONE)
3041 codec_id = video_codec_id;
3043 video_enc->codec_id = codec_id;
3044 codec = avcodec_find_encoder(codec_id);
3046 for(i=0; i<opt_name_count; i++){
3048 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3049 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3050 av_set_double(video_enc, opt_names[i], d);
3053 video_enc->bit_rate = video_bit_rate;
3054 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3055 video_enc->time_base.den = frame_rate;
3056 video_enc->time_base.num = frame_rate_base;
3057 if(codec && codec->supported_framerates){
3058 const AVRational *p= codec->supported_framerates;
3059 AVRational req= (AVRational){frame_rate, frame_rate_base};
3060 const AVRational *best=NULL;
3061 AVRational best_error= (AVRational){INT_MAX, 1};
3062 for(; p->den!=0; p++){
3063 AVRational error= av_sub_q(req, *p);
3064 if(error.num <0) error.num *= -1;
3065 if(av_cmp_q(error, best_error) < 0){
3070 video_enc->time_base.den= best->num;
3071 video_enc->time_base.num= best->den;
3074 video_enc->width = frame_width + frame_padright + frame_padleft;
3075 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3076 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3077 video_enc->pix_fmt = frame_pix_fmt;
3079 if(codec && codec->pix_fmts){
3080 const enum PixelFormat *p= codec->pix_fmts;
3082 if(*p == video_enc->pix_fmt)
3086 video_enc->pix_fmt = codec->pix_fmts[0];
3090 video_enc->gop_size = gop_size;
3092 video_enc->gop_size = 0;
3093 if (video_qscale || same_quality) {
3094 video_enc->flags |= CODEC_FLAG_QSCALE;
3095 video_enc->global_quality=
3096 st->quality = FF_QP2LAMBDA * video_qscale;
3100 video_enc->intra_matrix = intra_matrix;
3102 video_enc->inter_matrix = inter_matrix;
3104 video_enc->pre_me = pre_me;
3107 video_enc->max_b_frames = b_frames;
3108 video_enc->b_quant_factor = 2.0;
3110 video_enc->qmin = video_qmin;
3111 video_enc->qmax = video_qmax;
3112 video_enc->lmin = video_lmin;
3113 video_enc->lmax = video_lmax;
3114 video_enc->rc_qsquish = video_qsquish;
3115 video_enc->mb_lmin = video_mb_lmin;
3116 video_enc->mb_lmax = video_mb_lmax;
3117 video_enc->max_qdiff = video_qdiff;
3118 video_enc->qblur = video_qblur;
3119 video_enc->qcompress = video_qcomp;
3120 video_enc->rc_eq = video_rc_eq;
3121 video_enc->workaround_bugs = workaround_bugs;
3122 video_enc->thread_count = thread_count;
3123 p= video_rc_override_string;
3126 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3128 fprintf(stderr, "error parsing rc_override\n");
3131 video_enc->rc_override=
3132 av_realloc(video_enc->rc_override,
3133 sizeof(RcOverride)*(i+1));
3134 video_enc->rc_override[i].start_frame= start;
3135 video_enc->rc_override[i].end_frame = end;
3137 video_enc->rc_override[i].qscale= q;
3138 video_enc->rc_override[i].quality_factor= 1.0;
3141 video_enc->rc_override[i].qscale= 0;
3142 video_enc->rc_override[i].quality_factor= -q/100.0;
3147 video_enc->rc_override_count=i;
3149 video_enc->rc_max_rate = video_rc_max_rate;
3150 video_enc->rc_min_rate = video_rc_min_rate;
3151 video_enc->rc_buffer_size = video_rc_buffer_size;
3152 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3153 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3154 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3155 video_enc->i_quant_factor = video_i_qfactor;
3156 video_enc->b_quant_factor = video_b_qfactor;
3157 video_enc->i_quant_offset = video_i_qoffset;
3158 video_enc->b_quant_offset = video_b_qoffset;
3159 video_enc->intra_quant_bias = video_intra_quant_bias;
3160 video_enc->inter_quant_bias = video_inter_quant_bias;
3161 video_enc->me_threshold= me_threshold;
3162 video_enc->mb_threshold= mb_threshold;
3163 video_enc->intra_dc_precision= intra_dc_precision - 8;
3164 video_enc->strict_std_compliance = strict;
3165 video_enc->error_rate = error_rate;
3166 video_enc->scenechange_threshold= sc_threshold;
3167 video_enc->me_range = me_range;
3168 video_enc->me_penalty_compensation= me_penalty_compensation;
3169 video_enc->frame_skip_threshold= frame_skip_threshold;
3170 video_enc->frame_skip_factor= frame_skip_factor;
3171 video_enc->frame_skip_exp= frame_skip_exp;
3174 video_enc->rtp_mode= 1;
3175 video_enc->rtp_payload_size= packet_size;
3179 video_enc->flags|= CODEC_FLAG_PSNR;
3181 video_enc->me_method = me_method;
3186 video_enc->flags |= CODEC_FLAG_PASS1;
3188 video_enc->flags |= CODEC_FLAG_PASS2;
3193 /* reset some key parameters */
3195 video_codec_id = CODEC_ID_NONE;
3196 video_stream_copy = 0;
3199 static void new_audio_stream(AVFormatContext *oc)
3202 AVCodecContext *audio_enc;
3205 st = av_new_stream(oc, oc->nb_streams);
3207 fprintf(stderr, "Could not alloc stream\n");
3211 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3212 audio_bitstream_filters= NULL;
3214 #if defined(HAVE_THREADS)
3216 avcodec_thread_init(st->codec, thread_count);
3219 audio_enc = st->codec;
3220 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3223 audio_enc->codec_tag= audio_codec_tag;
3225 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3226 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3227 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3229 if (audio_stream_copy) {
3230 st->stream_copy = 1;
3231 audio_enc->channels = audio_channels;
3233 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3235 for(i=0; i<opt_name_count; i++){
3237 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3238 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3239 av_set_double(audio_enc, opt_names[i], d);
3242 if (audio_codec_id != CODEC_ID_NONE)
3243 codec_id = audio_codec_id;
3244 audio_enc->codec_id = codec_id;
3246 audio_enc->bit_rate = audio_bit_rate;
3247 if (audio_qscale > QSCALE_NONE) {
3248 audio_enc->flags |= CODEC_FLAG_QSCALE;
3249 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3251 audio_enc->strict_std_compliance = strict;
3252 audio_enc->thread_count = thread_count;
3253 /* For audio codecs other than AC3 or DTS we limit */
3254 /* the number of coded channels to stereo */
3255 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3256 && codec_id != CODEC_ID_DTS) {
3257 audio_enc->channels = 2;
3259 audio_enc->channels = audio_channels;
3261 audio_enc->sample_rate = audio_sample_rate;
3262 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3263 if (audio_language) {
3264 pstrcpy(st->language, sizeof(st->language), audio_language);
3265 av_free(audio_language);
3266 audio_language = NULL;
3269 /* reset some key parameters */
3271 audio_codec_id = CODEC_ID_NONE;
3272 audio_stream_copy = 0;
3275 static void opt_new_subtitle_stream(void)
3277 AVFormatContext *oc;
3279 AVCodecContext *subtitle_enc;
3282 if (nb_output_files <= 0) {
3283 fprintf(stderr, "At least one output file must be specified\n");
3286 oc = output_files[nb_output_files - 1];
3288 st = av_new_stream(oc, oc->nb_streams);
3290 fprintf(stderr, "Could not alloc stream\n");
3294 subtitle_enc = st->codec;
3295 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3296 if (subtitle_stream_copy) {
3297 st->stream_copy = 1;
3299 for(i=0; i<opt_name_count; i++){
3301 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3302 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3303 av_set_double(subtitle_enc, opt_names[i], d);
3305 subtitle_enc->codec_id = subtitle_codec_id;
3308 if (subtitle_language) {
3309 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3310 av_free(subtitle_language);
3311 subtitle_language = NULL;
3314 subtitle_codec_id = CODEC_ID_NONE;
3315 subtitle_stream_copy = 0;
3318 static void opt_new_audio_stream(void)
3320 AVFormatContext *oc;
3321 if (nb_output_files <= 0) {
3322 fprintf(stderr, "At least one output file must be specified\n");
3325 oc = output_files[nb_output_files - 1];
3326 new_audio_stream(oc);
3329 static void opt_new_video_stream(void)
3331 AVFormatContext *oc;
3332 if (nb_output_files <= 0) {
3333 fprintf(stderr, "At least one output file must be specified\n");
3336 oc = output_files[nb_output_files - 1];
3337 new_video_stream(oc);
3340 static void opt_output_file(const char *filename)
3342 AVFormatContext *oc;
3343 int use_video, use_audio, input_has_video, input_has_audio;
3344 AVFormatParameters params, *ap = ¶ms;
3346 if (!strcmp(filename, "-"))
3349 oc = av_alloc_format_context();
3351 if (!file_oformat) {
3352 file_oformat = guess_format(NULL, filename, NULL);
3353 if (!file_oformat) {
3354 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3360 oc->oformat = file_oformat;
3361 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3363 if (!strcmp(file_oformat->name, "ffm") &&
3364 strstart(filename, "http:", NULL)) {
3365 /* special case for files sent to ffserver: we get the stream
3366 parameters from ffserver */
3367 if (read_ffserver_streams(oc, filename) < 0) {
3368 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3372 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3373 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3375 /* disable if no corresponding type found and at least one
3377 if (nb_input_files > 0) {
3378 check_audio_video_inputs(&input_has_video, &input_has_audio);
3379 if (!input_has_video)
3381 if (!input_has_audio)
3385 /* manual disable */
3386 if (audio_disable) {
3389 if (video_disable) {
3394 new_video_stream(oc);
3398 new_audio_stream(oc);
3401 if (!oc->nb_streams) {
3402 fprintf(stderr, "No audio or video streams available\n");
3406 oc->timestamp = rec_timestamp;
3409 pstrcpy(oc->title, sizeof(oc->title), str_title);
3411 pstrcpy(oc->author, sizeof(oc->author), str_author);
3413 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3415 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3418 output_files[nb_output_files++] = oc;
3420 /* check filename in case of an image number is expected */
3421 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3422 if (filename_number_test(oc->filename) < 0) {
3423 print_error(oc->filename, AVERROR_NUMEXPECTED);
3428 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3429 /* test if it already exists to avoid loosing precious files */
3430 if (!file_overwrite &&
3431 (strchr(filename, ':') == NULL ||
3432 strstart(filename, "file:", NULL))) {
3433 if (url_exist(filename)) {
3436 if ( !using_stdin ) {
3437 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3440 if (toupper(c) != 'Y') {
3441 fprintf(stderr, "Not overwriting - exiting\n");
3446 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3453 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3454 fprintf(stderr, "Could not open '%s'\n", filename);
3459 memset(ap, 0, sizeof(*ap));
3460 ap->image_format = image_format;
3461 if (av_set_parameters(oc, ap) < 0) {
3462 fprintf(stderr, "%s: Invalid encoding parameters\n",
3467 oc->packet_size= mux_packet_size;
3468 oc->mux_rate= mux_rate;
3469 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3470 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3471 oc->loop_output = loop_output;
3473 /* reset some options */
3474 file_oformat = NULL;
3475 file_iformat = NULL;
3476 image_format = NULL;
3479 /* prepare dummy protocols for grab */
3480 static void prepare_grab(void)
3482 int has_video, has_audio, i, j;
3483 AVFormatContext *oc;
3484 AVFormatContext *ic;
3485 AVFormatParameters vp1, *vp = &vp1;
3486 AVFormatParameters ap1, *ap = &ap1;
3488 /* see if audio/video inputs are needed */
3491 memset(ap, 0, sizeof(*ap));
3492 memset(vp, 0, sizeof(*vp));
3493 vp->time_base.num= 1;
3494 for(j=0;j<nb_output_files;j++) {
3495 oc = output_files[j];
3496 for(i=0;i<oc->nb_streams;i++) {
3497 AVCodecContext *enc = oc->streams[i]->codec;
3498 switch(enc->codec_type) {
3499 case CODEC_TYPE_AUDIO:
3500 if (enc->sample_rate > ap->sample_rate)
3501 ap->sample_rate = enc->sample_rate;
3502 if (enc->channels > ap->channels)
3503 ap->channels = enc->channels;
3506 case CODEC_TYPE_VIDEO:
3507 if (enc->width > vp->width)
3508 vp->width = enc->width;
3509 if (enc->height > vp->height)
3510 vp->height = enc->height;
3512 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3513 vp->time_base = enc->time_base;
3514 vp->width += frame_leftBand + frame_rightBand;
3515 vp->width -= (frame_padleft + frame_padright);
3516 vp->height += frame_topBand + frame_bottomBand;
3517 vp->height -= (frame_padtop + frame_padbottom);
3527 if (has_video == 0 && has_audio == 0) {
3528 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3533 AVInputFormat *fmt1;
3534 fmt1 = av_find_input_format(video_grab_format);
3535 vp->device = video_device;
3536 vp->channel = video_channel;
3537 vp->standard = video_standard;
3538 vp->pix_fmt = frame_pix_fmt;
3539 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3540 fprintf(stderr, "Could not find video grab device\n");
3543 /* If not enough info to get the stream parameters, we decode the
3544 first frames to get it. */
3545 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3546 fprintf(stderr, "Could not find video grab parameters\n");
3549 /* by now video grab has one stream */
3550 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3551 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3552 input_files[nb_input_files] = ic;
3555 dump_format(ic, nb_input_files, "", 0);
3559 if (has_audio && audio_grab_format) {
3560 AVInputFormat *fmt1;
3561 fmt1 = av_find_input_format(audio_grab_format);
3562 ap->device = audio_device;
3563 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3564 fprintf(stderr, "Could not find audio grab device\n");
3567 input_files[nb_input_files] = ic;
3570 dump_format(ic, nb_input_files, "", 0);
3576 /* same option as mencoder */
3577 static void opt_pass(const char *pass_str)
3580 pass = atoi(pass_str);
3581 if (pass != 1 && pass != 2) {
3582 fprintf(stderr, "pass number can be only 1 or 2\n");
3588 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3589 static int64_t getutime(void)
3591 return av_gettime();
3594 static int64_t getutime(void)
3596 struct rusage rusage;
3598 getrusage(RUSAGE_SELF, &rusage);
3599 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3603 extern int ffm_nopts;
3605 static void show_formats(void)
3607 AVInputFormat *ifmt;
3608 AVOutputFormat *ofmt;
3609 AVImageFormat *image_fmt;
3612 const char **pp, *last_name;
3614 printf("File formats:\n");
3619 const char *name=NULL;
3620 const char *long_name=NULL;
3622 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3623 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3624 strcmp(ofmt->name, last_name)>0){
3626 long_name= ofmt->long_name;
3630 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3631 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3632 strcmp(ifmt->name, last_name)>0){
3634 long_name= ifmt->long_name;
3637 if(name && strcmp(ifmt->name, name)==0)
3649 long_name ? long_name:" ");
3653 printf("Image formats (filename extensions, if any, follow):\n");
3654 for(image_fmt = first_image_format; image_fmt != NULL;
3655 image_fmt = image_fmt->next) {
3658 image_fmt->img_read ? "D":" ",
3659 image_fmt->img_write ? "E":" ",
3661 image_fmt->extensions ? image_fmt->extensions:" ");
3665 printf("Codecs:\n");
3671 const char *type_str;
3674 for(p = first_avcodec; p != NULL; p = p->next) {
3675 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3676 strcmp(p->name, last_name)>0){
3678 decode= encode= cap=0;
3680 if(p2 && strcmp(p->name, p2->name)==0){
3681 if(p->decode) decode=1;
3682 if(p->encode) encode=1;
3683 cap |= p->capabilities;
3688 last_name= p2->name;
3691 case CODEC_TYPE_VIDEO:
3694 case CODEC_TYPE_AUDIO:
3697 case CODEC_TYPE_SUBTITLE:
3706 decode ? "D": (/*p2->decoder ? "d":*/" "),
3709 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3710 cap & CODEC_CAP_DR1 ? "D":" ",
3711 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3713 /* if(p2->decoder && decode==0)
3714 printf(" use %s for decoding", p2->decoder->name);*/
3719 printf("Supported file protocols:\n");
3720 for(up = first_protocol; up != NULL; up = up->next)
3721 printf(" %s:", up->name);
3724 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3725 printf("Motion estimation methods:\n");
3729 if ((pp - motion_str + 1) == ME_ZERO)
3730 printf("(fastest)");
3731 else if ((pp - motion_str + 1) == ME_FULL)
3732 printf("(slowest)");
3733 else if ((pp - motion_str + 1) == ME_EPZS)
3734 printf("(default)");
3739 "Note, the names of encoders and decoders dont always match, so there are\n"
3740 "several cases where the above table shows encoder only or decoder only entries\n"
3741 "even though both encoding and decoding are supported for example, the h263\n"
3742 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3747 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3750 const char *p = str;
3757 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3764 static void opt_inter_matrix(const char *arg)
3766 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3767 parse_matrix_coeffs(inter_matrix, arg);
3770 static void opt_intra_matrix(const char *arg)
3772 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3773 parse_matrix_coeffs(intra_matrix, arg);
3776 static void opt_target(const char *arg)
3779 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3781 if(!strncmp(arg, "pal-", 4)) {
3784 } else if(!strncmp(arg, "ntsc-", 5)) {
3787 } else if(!strncmp(arg, "film-", 5)) {
3792 /* Calculate FR via float to avoid int overflow */
3793 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3796 } else if((fr == 29970) || (fr == 23976)) {
3799 /* Try to determine PAL/NTSC by peeking in the input files */
3800 if(nb_input_files) {
3802 for(j = 0; j < nb_input_files; j++) {
3803 for(i = 0; i < input_files[j]->nb_streams; i++) {
3804 AVCodecContext *c = input_files[j]->streams[i]->codec;
3805 if(c->codec_type != CODEC_TYPE_VIDEO)
3807 fr = c->time_base.den * 1000 / c->time_base.num;
3811 } else if((fr == 29970) || (fr == 23976)) {
3821 if(verbose && norm >= 0)
3822 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3826 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3827 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3828 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3832 if(!strcmp(arg, "vcd")) {
3834 opt_video_codec("mpeg1video");
3835 opt_audio_codec("mp2");
3838 opt_frame_size(norm ? "352x240" : "352x288");
3839 opt_frame_rate(frame_rates[norm]);
3840 opt_gop_size(norm ? "18" : "15");
3842 video_bit_rate = 1150000;
3843 video_rc_max_rate = 1150000;
3844 video_rc_min_rate = 1150000;
3845 video_rc_buffer_size = 40*1024*8;
3847 audio_bit_rate = 224000;
3848 audio_sample_rate = 44100;
3850 mux_packet_size= 2324;
3851 mux_rate= 2352 * 75 * 8;
3853 /* We have to offset the PTS, so that it is consistent with the SCR.
3854 SCR starts at 36000, but the first two packs contain only padding
3855 and the first pack from the other stream, respectively, may also have
3856 been written before.
3857 So the real data starts at SCR 36000+3*1200. */
3858 mux_preload= (36000+3*1200) / 90000.0; //0.44
3859 } else if(!strcmp(arg, "svcd")) {
3861 opt_video_codec("mpeg2video");
3862 opt_audio_codec("mp2");
3865 opt_frame_size(norm ? "480x480" : "480x576");
3866 opt_frame_rate(frame_rates[norm]);
3867 opt_gop_size(norm ? "18" : "15");
3869 video_bit_rate = 2040000;
3870 video_rc_max_rate = 2516000;
3871 video_rc_min_rate = 0; //1145000;
3872 video_rc_buffer_size = 224*1024*8;
3873 opt_default("flags", "+SCAN_OFFSET");
3876 audio_bit_rate = 224000;
3877 audio_sample_rate = 44100;
3879 mux_packet_size= 2324;
3881 } else if(!strcmp(arg, "dvd")) {
3883 opt_video_codec("mpeg2video");
3884 opt_audio_codec("ac3");
3887 opt_frame_size(norm ? "720x480" : "720x576");
3888 opt_frame_rate(frame_rates[norm]);
3889 opt_gop_size(norm ? "18" : "15");
3891 video_bit_rate = 6000000;
3892 video_rc_max_rate = 9000000;
3893 video_rc_min_rate = 0; //1500000;
3894 video_rc_buffer_size = 224*1024*8;
3896 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3897 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3899 audio_bit_rate = 448000;
3900 audio_sample_rate = 48000;
3902 } else if(!strncmp(arg, "dv", 2)) {
3906 opt_frame_size(norm ? "720x480" : "720x576");
3907 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3908 (norm ? "yuv411p" : "yuv420p"));
3909 opt_frame_rate(frame_rates[norm]);
3911 audio_sample_rate = 48000;
3915 fprintf(stderr, "Unknown target: %s\n", arg);
3920 static void opt_video_bsf(const char *arg)
3922 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3923 AVBitStreamFilterContext **bsfp;
3926 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3930 bsfp= &video_bitstream_filters;
3932 bsfp= &(*bsfp)->next;
3937 //FIXME avoid audio - video code duplication
3938 static void opt_audio_bsf(const char *arg)
3940 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3941 AVBitStreamFilterContext **bsfp;
3944 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3948 bsfp= &audio_bitstream_filters;
3950 bsfp= &(*bsfp)->next;
3955 static void show_version(void)
3957 /* TODO: add function interface to avutil and avformat */
3958 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3962 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3966 static int opt_default(const char *opt, const char *arg){
3967 AVOption *o= av_set_string(avctx_opts, opt, arg);
3971 // 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));
3973 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3974 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3975 opt_names[opt_name_count++]= o->name;
3977 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3978 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3981 if(avctx_opts->debug)
3982 av_log_set_level(AV_LOG_DEBUG);
3986 const OptionDef options[] = {
3988 { "L", 0, {(void*)show_license}, "show license" },
3989 { "h", 0, {(void*)show_help}, "show help" },
3990 { "version", 0, {(void*)show_version}, "show version" },
3991 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3992 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3993 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3994 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3995 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3996 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3997 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3998 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3999 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
4000 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4001 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4002 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4003 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
4004 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
4005 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
4006 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
4007 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4008 "add timings for benchmarking" },
4009 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4010 "dump each input packet" },
4011 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4012 "when dumping packets, also dump the payload" },
4013 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4014 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4015 { "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)", "" },
4016 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4017 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4018 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4019 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4020 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4021 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4022 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4023 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4024 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
4027 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4028 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4029 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4030 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4031 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4032 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4033 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4034 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4035 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4036 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4037 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4038 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4039 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4040 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4041 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4042 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4043 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4044 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4045 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4046 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4047 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4048 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4049 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4050 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4051 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4052 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4053 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4054 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4055 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4056 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4057 { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
4058 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4059 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4060 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4061 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4062 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4063 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4064 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4065 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4066 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4067 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4068 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4069 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4070 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4071 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4072 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4073 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4075 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
4076 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
4077 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4078 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4079 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4080 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4081 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4082 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4083 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4084 "use same video quality as source (implies VBR)" },
4085 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4086 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4087 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4088 "deinterlace pictures" },
4089 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4090 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4091 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4092 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4093 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4094 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4095 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4096 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4097 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4098 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4099 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4100 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4101 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4102 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4103 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4104 { "genpts", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&genpts }, "generate pts" },
4105 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4108 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4109 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4110 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4111 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4112 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4113 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4114 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4115 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4116 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4117 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4119 /* subtitle options */
4120 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4121 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4122 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4125 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4126 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4127 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4128 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4130 /* G.2 grab options */
4131 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4132 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4135 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4136 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4137 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4138 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4140 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
4141 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
4143 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4147 static void show_banner(void)
4149 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4150 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
4151 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4152 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4153 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4154 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4156 fprintf(stderr, ", gcc: " __VERSION__ "\n");
4158 fprintf(stderr, ", using a non-gcc compiler\n");
4162 static void show_license(void)
4167 "This program is free software; you can redistribute it and/or modify\n"
4168 "it under the terms of the GNU General Public License as published by\n"
4169 "the Free Software Foundation; either version 2 of the License, or\n"
4170 "(at your option) any later version.\n"
4172 "This program is distributed in the hope that it will be useful,\n"
4173 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4174 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4175 "GNU General Public License for more details.\n"
4177 "You should have received a copy of the GNU General Public License\n"
4178 "along with this program; if not, write to the Free Software\n"
4179 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4183 "This library is free software; you can redistribute it and/or\n"
4184 "modify it under the terms of the GNU Lesser General Public\n"
4185 "License as published by the Free Software Foundation; either\n"
4186 "version 2 of the License, or (at your option) any later version.\n"
4188 "This library is distributed in the hope that it will be useful,\n"
4189 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4190 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4191 "Lesser General Public License for more details.\n"
4193 "You should have received a copy of the GNU Lesser General Public\n"
4194 "License along with this library; if not, write to the Free Software\n"
4195 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4201 static void show_help(void)
4204 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4205 "Hyper fast Audio and Video encoder\n");
4207 show_help_options(options, "Main options:\n",
4208 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4209 show_help_options(options, "\nVideo options:\n",
4210 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4212 show_help_options(options, "\nAdvanced Video options:\n",
4213 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4214 OPT_VIDEO | OPT_EXPERT);
4215 show_help_options(options, "\nAudio options:\n",
4216 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4218 show_help_options(options, "\nAdvanced Audio options:\n",
4219 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4220 OPT_AUDIO | OPT_EXPERT);
4221 show_help_options(options, "\nSubtitle options:\n",
4222 OPT_SUBTITLE | OPT_GRAB,
4224 show_help_options(options, "\nAudio/Video grab options:\n",
4227 show_help_options(options, "\nAdvanced options:\n",
4228 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4230 av_opt_show(avctx_opts, NULL);
4235 void parse_arg_file(const char *filename)
4237 opt_output_file(filename);
4240 int main(int argc, char **argv)
4247 avctx_opts= avcodec_alloc_context();
4255 parse_options(argc, argv, options);
4257 /* file converter / grab */
4258 if (nb_output_files <= 0) {
4259 fprintf(stderr, "Must supply at least one output file\n");
4263 if (nb_input_files == 0) {
4269 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4270 stream_maps, nb_stream_maps);
4271 ti = getutime() - ti;
4273 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4277 for(i=0;i<nb_output_files;i++) {
4278 /* maybe av_close_output_file ??? */
4279 AVFormatContext *s = output_files[i];
4281 if (!(s->oformat->flags & AVFMT_NOFILE))
4283 for(j=0;j<s->nb_streams;j++)
4284 av_free(s->streams[j]);
4287 for(i=0;i<nb_input_files;i++)
4288 av_close_input_file(input_files[i]);
4293 av_free(intra_matrix);
4295 av_free(inter_matrix);
4297 #ifdef POWERPC_PERFORMANCE_REPORT
4298 extern void powerpc_display_perf_report(void);
4299 powerpc_display_perf_report();
4300 #endif /* POWERPC_PERFORMANCE_REPORT */
4302 #ifndef CONFIG_WIN32
4303 if (received_sigterm) {
4305 "Received signal %d: terminating.\n",
4306 (int) received_sigterm);
4310 exit(0); /* not all OS-es handle main() return value */