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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 #define HAVE_AV_CONFIG_H
22 #include "framehook.h"
28 #include <sys/ioctl.h>
31 #include <sys/resource.h>
35 #include <sys/types.h>
36 #include <sys/select.h>
39 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
47 #if !defined(INFINITY) && defined(HUGE_VAL)
48 #define INFINITY HUGE_VAL
51 /* select an input stream for an output stream */
52 typedef struct AVStreamMap {
57 /** select an input file for an output file */
58 typedef struct AVMetaDataMap {
63 extern const OptionDef options[];
65 static void show_help(void);
66 static void show_license(void);
70 static AVFormatContext *input_files[MAX_FILES];
71 static int64_t input_files_ts_offset[MAX_FILES];
72 static int nb_input_files = 0;
74 static AVFormatContext *output_files[MAX_FILES];
75 static int nb_output_files = 0;
77 static AVStreamMap stream_maps[MAX_FILES];
78 static int nb_stream_maps;
80 static AVMetaDataMap meta_data_maps[MAX_FILES];
81 static int nb_meta_data_maps;
83 static AVInputFormat *file_iformat;
84 static AVOutputFormat *file_oformat;
85 static AVImageFormat *image_format;
86 static int frame_width = 160;
87 static int frame_height = 128;
88 static float frame_aspect_ratio = 0;
89 static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
90 static int frame_padtop = 0;
91 static int frame_padbottom = 0;
92 static int frame_padleft = 0;
93 static int frame_padright = 0;
94 static int padcolor[3] = {16,128,128}; /* default to black */
95 static int frame_topBand = 0;
96 static int frame_bottomBand = 0;
97 static int frame_leftBand = 0;
98 static int frame_rightBand = 0;
99 static int frame_rate = 25;
100 static int frame_rate_base = 1;
101 static int video_bit_rate = 200*1000;
102 static int video_bit_rate_tolerance = 4000*1000;
103 static float video_qscale = 0;
104 static int video_qmin = 2;
105 static int video_qmax = 31;
106 static int video_lmin = 2*FF_QP2LAMBDA;
107 static int video_lmax = 31*FF_QP2LAMBDA;
108 static int video_mb_qmin = 2;
109 static int video_mb_qmax = 31;
110 static int video_qdiff = 3;
111 static float video_qblur = 0.5;
112 static float video_qcomp = 0.5;
113 static uint16_t *intra_matrix = NULL;
114 static uint16_t *inter_matrix = NULL;
115 #if 0 //experimental, (can be removed)
116 static float video_rc_qsquish=1.0;
117 static float video_rc_qmod_amp=0;
118 static int video_rc_qmod_freq=0;
120 static char *video_rc_override_string=NULL;
121 static char *video_rc_eq="tex^qComp";
122 static int video_rc_buffer_size=0;
123 static float video_rc_buffer_aggressivity=1.0;
124 static int video_rc_max_rate=0;
125 static int video_rc_min_rate=0;
126 static float video_rc_initial_cplx=0;
127 static float video_b_qfactor = 1.25;
128 static float video_b_qoffset = 1.25;
129 static float video_i_qfactor = -0.8;
130 static float video_i_qoffset = 0.0;
131 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
132 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
133 static int me_method = ME_EPZS;
134 static int video_disable = 0;
135 static int video_codec_id = CODEC_ID_NONE;
136 static int video_codec_tag = 0;
137 static int same_quality = 0;
138 static int b_frames = 0;
139 static int mb_decision = FF_MB_DECISION_SIMPLE;
140 static int ildct_cmp = FF_CMP_VSAD;
141 static int mb_cmp = FF_CMP_SAD;
142 static int sub_cmp = FF_CMP_SAD;
143 static int cmp = FF_CMP_SAD;
144 static int pre_cmp = FF_CMP_SAD;
145 static int pre_me = 0;
146 static float lumi_mask = 0;
147 static float dark_mask = 0;
148 static float scplx_mask = 0;
149 static float tcplx_mask = 0;
150 static float p_mask = 0;
151 static int use_4mv = 0;
152 static int use_obmc = 0;
153 static int use_loop = 0;
154 static int use_aic = 0;
155 static int use_aiv = 0;
156 static int use_umv = 0;
157 static int use_ss = 0;
158 static int use_alt_scan = 0;
159 static int use_trell = 0;
160 static int use_scan_offset = 0;
161 static int use_qpel = 0;
162 static int use_qprd = 0;
163 static int use_cbprd = 0;
165 static int closed_gop = 0;
166 static int strict_gop = 0;
167 static int do_deinterlace = 0;
168 static int do_interlace_dct = 0;
169 static int do_interlace_me = 0;
170 static int workaround_bugs = FF_BUG_AUTODETECT;
171 static int error_resilience = 2;
172 static int error_concealment = 3;
173 static int dct_algo = 0;
174 static int idct_algo = 0;
175 static int use_part = 0;
176 static int packet_size = 0;
177 static int error_rate = 0;
178 static int strict = 0;
179 static int top_field_first = -1;
180 static int noise_reduction = 0;
181 static int sc_threshold = 0;
182 static int debug = 0;
183 static int debug_mv = 0;
184 static int me_threshold = 0;
185 static int mb_threshold = 0;
186 static int intra_dc_precision = 8;
187 static int coder = 0;
188 static int context = 0;
189 static int predictor = 0;
190 static int video_profile = FF_PROFILE_UNKNOWN;
191 static int video_level = FF_LEVEL_UNKNOWN;
192 static int nsse_weight = 8;
193 static int subpel_quality= 8;
194 static int lowres= 0;
195 extern int loop_input; /* currently a hack */
197 static int gop_size = 12;
198 static int intra_only = 0;
199 static int audio_sample_rate = 44100;
200 static int audio_bit_rate = 64000;
201 static int audio_disable = 0;
202 static int audio_channels = 1;
203 static int audio_codec_id = CODEC_ID_NONE;
204 static int audio_codec_tag = 0;
206 static int mux_rate= 0;
207 static int mux_packet_size= 0;
208 static float mux_preload= 0.5;
209 static float mux_max_delay= 0.7;
211 static int64_t recording_time = 0;
212 static int64_t start_time = 0;
213 static int64_t rec_timestamp = 0;
214 static int64_t input_ts_offset = 0;
215 static int file_overwrite = 0;
216 static char *str_title = NULL;
217 static char *str_author = NULL;
218 static char *str_copyright = NULL;
219 static char *str_comment = NULL;
220 static int do_benchmark = 0;
221 static int do_hex_dump = 0;
222 static int do_pkt_dump = 0;
223 static int do_psnr = 0;
224 static int do_vstats = 0;
225 static int do_pass = 0;
226 static int bitexact = 0;
227 static char *pass_logfilename = NULL;
228 static int audio_stream_copy = 0;
229 static int video_stream_copy = 0;
230 static int video_sync_method= 1;
231 static int audio_sync_method= 0;
232 static int copy_ts= 0;
234 static int rate_emu = 0;
236 static char *video_grab_format = "video4linux";
237 static char *video_device = NULL;
238 static char *grab_device = NULL;
239 static int video_channel = 0;
240 static char *video_standard = "ntsc";
242 static char *audio_grab_format = "audio_device";
243 static char *audio_device = NULL;
245 static int using_stdin = 0;
246 static int using_vhook = 0;
247 static int verbose = 1;
248 static int thread_count= 1;
249 static int q_pressed = 0;
250 static int me_range = 0;
251 static int64_t video_size = 0;
252 static int64_t audio_size = 0;
253 static int64_t extra_size = 0;
254 static int nb_frames_dup = 0;
255 static int nb_frames_drop = 0;
256 static int input_sync;
258 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
260 typedef struct AVOutputStream {
261 int file_index; /* file index */
262 int index; /* stream index in the output file */
263 int source_index; /* AVInputStream index */
264 AVStream *st; /* stream in the output file */
265 int encoding_needed; /* true if encoding needed for this stream */
267 /* input pts and corresponding output pts
269 double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
270 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
272 int video_resample; /* video_resample and video_crop are mutually exclusive */
273 AVFrame pict_tmp; /* temporary image for resampling */
274 ImgReSampleContext *img_resample_ctx; /* for image resampling */
276 int video_crop; /* video_resample and video_crop are mutually exclusive */
277 int topBand; /* cropping area sizes */
280 int video_pad; /* video_resample and video_pad are mutually exclusive */
281 int padtop; /* padding area sizes */
288 ReSampleContext *resample; /* for audio resampling */
289 FifoBuffer fifo; /* for compression: one audio fifo per codec */
293 typedef struct AVInputStream {
297 int discard; /* true if stream data should be discarded */
298 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
299 int64_t sample_index; /* current sample */
301 int64_t start; /* time when read started */
302 unsigned long frame; /* current frame */
303 int64_t next_pts; /* synthetic pts for cases where pkt.pts
305 int64_t pts; /* current pts */
306 int is_start; /* is 1 at the start and after a discontinuity */
309 typedef struct AVInputFile {
310 int eof_reached; /* true if eof reached */
311 int ist_index; /* index of first stream in ist_table */
312 int buffer_size; /* current total buffer size */
313 int buffer_size_max; /* buffer size at which we consider we can stop
315 int nb_streams; /* nb streams we are aware of */
320 /* init terminal so that we can grab keys */
321 static struct termios oldtty;
323 static void term_exit(void)
325 tcsetattr (0, TCSANOW, &oldtty);
328 static volatile sig_atomic_t received_sigterm = 0;
331 sigterm_handler(int sig)
333 received_sigterm = sig;
337 static void term_init(void)
344 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
345 |INLCR|IGNCR|ICRNL|IXON);
346 tty.c_oflag |= OPOST;
347 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
348 tty.c_cflag &= ~(CSIZE|PARENB);
353 tcsetattr (0, TCSANOW, &tty);
355 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
356 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
357 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
359 register a function to be called at normal program termination
362 #ifdef CONFIG_BEOS_NETSERVER
363 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
367 /* read a key without blocking */
368 static int read_key(void)
372 #ifndef CONFIG_BEOS_NETSERVER
380 n = select(1, &rfds, NULL, NULL, &tv);
392 static int decode_interrupt_cb(void)
394 return q_pressed || (q_pressed = read_key() == 'q');
399 static volatile int received_sigterm = 0;
401 /* no interactive support */
402 static void term_exit(void)
406 static void term_init(void)
410 static int read_key(void)
417 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
422 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
425 /* copy stream format */
426 s->nb_streams = ic->nb_streams;
427 for(i=0;i<ic->nb_streams;i++) {
430 st = av_mallocz(sizeof(AVStream));
431 memcpy(st, ic->streams[i], sizeof(AVStream));
435 av_close_input_file(ic);
439 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
441 static void do_audio_out(AVFormatContext *s,
444 unsigned char *buf, int size)
447 static uint8_t *audio_buf = NULL;
448 static uint8_t *audio_out = NULL;
449 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
451 int size_out, frame_bytes, ret;
452 AVCodecContext *enc= &ost->st->codec;
454 /* SC: dynamic allocation of buffers */
456 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
458 audio_out = av_malloc(audio_out_size);
459 if (!audio_buf || !audio_out)
460 return; /* Should signal an error ! */
462 if(audio_sync_method){
463 double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts
464 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
465 double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
466 int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
468 //FIXME resample delay
469 if(fabs(delta) > 50){
472 byte_delta= FFMAX(byte_delta, -size);
476 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
481 static uint8_t *input_tmp= NULL;
482 input_tmp= av_realloc(input_tmp, byte_delta + size);
484 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
487 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
489 memset(input_tmp, 0, byte_delta);
490 memcpy(input_tmp + byte_delta, buf, size);
494 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
496 }else if(audio_sync_method>1){
497 int comp= clip(delta, -audio_sync_method, audio_sync_method);
498 assert(ost->audio_resample);
500 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
501 // fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(ost->sync_ipts * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2));
502 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
506 ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
507 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
509 if (ost->audio_resample) {
511 size_out = audio_resample(ost->resample,
512 (short *)buftmp, (short *)buf,
513 size / (ist->st->codec.channels * 2));
514 size_out = size_out * enc->channels * 2;
520 /* now encode as many frames as possible */
521 if (enc->frame_size > 1) {
522 /* output resampled raw samples */
523 fifo_write(&ost->fifo, buftmp, size_out,
526 frame_bytes = enc->frame_size * 2 * enc->channels;
528 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
529 &ost->fifo.rptr) == 0) {
531 av_init_packet(&pkt);
533 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
536 pkt.stream_index= ost->index;
540 pkt.pts= enc->coded_frame->pts;
541 pkt.flags |= PKT_FLAG_KEY;
542 av_interleaved_write_frame(s, &pkt);
544 ost->sync_opts += enc->frame_size;
548 av_init_packet(&pkt);
550 ost->sync_opts += size_out / (2 * enc->channels);
552 /* output a pcm frame */
553 /* XXX: change encoding codec API to avoid this ? */
554 switch(enc->codec->id) {
555 case CODEC_ID_PCM_S16LE:
556 case CODEC_ID_PCM_S16BE:
557 case CODEC_ID_PCM_U16LE:
558 case CODEC_ID_PCM_U16BE:
561 size_out = size_out >> 1;
564 ret = avcodec_encode_audio(enc, audio_out, size_out,
567 pkt.stream_index= ost->index;
571 pkt.pts= enc->coded_frame->pts;
572 pkt.flags |= PKT_FLAG_KEY;
573 av_interleaved_write_frame(s, &pkt);
577 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
581 AVPicture picture_tmp;
584 dec = &ist->st->codec;
586 /* deinterlace : must be done before any resize */
587 if (do_deinterlace || using_vhook) {
590 /* create temporary picture */
591 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
592 buf = av_malloc(size);
596 picture2 = &picture_tmp;
597 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
600 if(avpicture_deinterlace(picture2, picture,
601 dec->pix_fmt, dec->width, dec->height) < 0) {
602 /* if error, do not deinterlace */
608 if (img_convert(picture2, dec->pix_fmt, picture,
609 dec->pix_fmt, dec->width, dec->height) < 0) {
610 /* if error, do not copy */
620 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
622 if (picture != picture2)
623 *picture = *picture2;
627 /* we begin to correct av delay at this threshold */
628 #define AV_DELAY_MAX 0.100
631 /* Expects img to be yuv420 */
632 static void fill_pad_region(AVPicture* img, int height, int width,
633 int padtop, int padbottom, int padleft, int padright, int *color) {
638 for (i = 0; i < 3; i++) {
639 shift = (i == 0) ? 0 : 1;
641 if (padtop || padleft) {
642 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
646 if (padleft || padright) {
647 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
648 (img->linesize[i] - (padright >> shift));
650 for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
651 memset(optr, color[i], (padleft + padright) >> shift);
652 optr += img->linesize[i];
657 optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
658 memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
663 static uint8_t *bit_buffer= NULL;
665 static void do_video_out(AVFormatContext *s,
671 int nb_frames, i, ret;
672 AVFrame *final_picture, *formatted_picture;
673 AVFrame picture_format_temp, picture_crop_temp;
674 uint8_t *buf = NULL, *buf1 = NULL;
675 AVCodecContext *enc, *dec;
676 enum PixelFormat target_pixfmt;
678 #define VIDEO_BUFFER_SIZE (1024*1024)
680 avcodec_get_frame_defaults(&picture_format_temp);
681 avcodec_get_frame_defaults(&picture_crop_temp);
683 enc = &ost->st->codec;
684 dec = &ist->st->codec;
686 /* by default, we output a single frame */
691 if(video_sync_method){
693 vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
694 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
697 else if (vdelta > 1.1)
698 nb_frames = lrintf(vdelta - 1.1 + 0.5);
699 //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);
703 fprintf(stderr, "*** drop!\n");
704 }else if (nb_frames > 1) {
705 nb_frames_dup += nb_frames;
707 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
710 ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
715 /* convert pixel format if needed */
716 target_pixfmt = ost->video_resample || ost->video_pad
717 ? PIX_FMT_YUV420P : enc->pix_fmt;
718 if (dec->pix_fmt != target_pixfmt) {
721 /* create temporary picture */
722 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
723 buf = av_malloc(size);
726 formatted_picture = &picture_format_temp;
727 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
729 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
730 (AVPicture *)in_picture, dec->pix_fmt,
731 dec->width, dec->height) < 0) {
734 fprintf(stderr, "pixel format conversion not handled\n");
739 formatted_picture = in_picture;
742 /* XXX: resampling could be done before raw format conversion in
743 some cases to go faster */
744 /* XXX: only works for YUV420P */
745 if (ost->video_resample) {
746 final_picture = &ost->pict_tmp;
747 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
749 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
750 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
751 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
755 if (enc->pix_fmt != PIX_FMT_YUV420P) {
759 /* create temporary picture */
760 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
761 buf = av_malloc(size);
764 final_picture = &picture_format_temp;
765 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
767 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
768 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
769 enc->width, enc->height) < 0) {
772 fprintf(stderr, "pixel format conversion not handled\n");
777 } else if (ost->video_crop) {
778 picture_crop_temp.data[0] = formatted_picture->data[0] +
779 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
781 picture_crop_temp.data[1] = formatted_picture->data[1] +
782 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
783 (ost->leftBand >> 1);
785 picture_crop_temp.data[2] = formatted_picture->data[2] +
786 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
787 (ost->leftBand >> 1);
789 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
790 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
791 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
792 final_picture = &picture_crop_temp;
793 } else if (ost->video_pad) {
794 final_picture = &ost->pict_tmp;
796 for (i = 0; i < 3; i++) {
797 uint8_t *optr, *iptr;
798 int shift = (i == 0) ? 0 : 1;
801 /* set offset to start writing image into */
802 optr = final_picture->data[i] + (((final_picture->linesize[i] *
803 ost->padtop) + ost->padleft) >> shift);
804 iptr = formatted_picture->data[i];
806 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
807 for (y = 0; y < yheight; y++) {
808 /* copy unpadded image row into padded image row */
809 memcpy(optr, iptr, formatted_picture->linesize[i]);
810 optr += final_picture->linesize[i];
811 iptr += formatted_picture->linesize[i];
815 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
816 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
819 if (enc->pix_fmt != PIX_FMT_YUV420P) {
823 /* create temporary picture */
824 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
825 buf = av_malloc(size);
828 final_picture = &picture_format_temp;
829 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
831 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
832 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
833 enc->width, enc->height) < 0) {
836 fprintf(stderr, "pixel format conversion not handled\n");
842 final_picture = formatted_picture;
844 /* duplicates frame if needed */
845 for(i=0;i<nb_frames;i++) {
847 av_init_packet(&pkt);
848 pkt.stream_index= ost->index;
850 if (s->oformat->flags & AVFMT_RAWPICTURE) {
851 /* raw pictures are written as AVPicture structure to
852 avoid any copies. We support temorarily the older
854 AVFrame* old_frame = enc->coded_frame;
855 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
856 pkt.data= (uint8_t *)final_picture;
857 pkt.size= sizeof(AVPicture);
859 pkt.pts= dec->coded_frame->pts;
860 if(dec->coded_frame && dec->coded_frame->key_frame)
861 pkt.flags |= PKT_FLAG_KEY;
863 av_interleaved_write_frame(s, &pkt);
864 enc->coded_frame = old_frame;
868 big_picture= *final_picture;
869 /* better than nothing: use input picture interlaced
871 big_picture.interlaced_frame = in_picture->interlaced_frame;
872 if(do_interlace_me || do_interlace_dct){
873 if(top_field_first == -1)
874 big_picture.top_field_first = in_picture->top_field_first;
876 big_picture.top_field_first = top_field_first;
879 /* handles sameq here. This is not correct because it may
880 not be a global option */
882 big_picture.quality = ist->st->quality;
884 big_picture.quality = ost->st->quality;
886 big_picture.pict_type = 0;
887 // big_picture.pts = AV_NOPTS_VALUE;
888 big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
889 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
890 ret = avcodec_encode_video(enc,
891 bit_buffer, VIDEO_BUFFER_SIZE,
893 //enc->frame_number = enc->real_pict_num;
895 pkt.data= bit_buffer;
898 pkt.pts= enc->coded_frame->pts;
899 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
900 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
901 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
903 if(enc->coded_frame && enc->coded_frame->key_frame)
904 pkt.flags |= PKT_FLAG_KEY;
905 av_interleaved_write_frame(s, &pkt);
907 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
908 // enc->frame_number-1, enc->real_pict_num, ret,
910 /* if two pass, output log */
911 if (ost->logfile && enc->stats_out) {
912 fprintf(ost->logfile, "%s", enc->stats_out);
924 static double psnr(double d){
925 if(d==0) return INFINITY;
926 return -10.0*log(d)/log(10.0);
929 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
932 static FILE *fvstats=NULL;
939 double ti1, bitrate, avg_bitrate;
943 today = localtime(&today2);
944 sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
947 fvstats = fopen(filename,"w");
955 enc = &ost->st->codec;
956 if (enc->codec_type == CODEC_TYPE_VIDEO) {
957 frame_number = ost->frame_number;
958 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
959 if (enc->flags&CODEC_FLAG_PSNR)
960 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
962 fprintf(fvstats,"f_size= %6d ", frame_size);
963 /* compute pts value */
964 ti1 = (double)ost->sync_opts *enc->frame_rate_base / enc->frame_rate;
968 bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
969 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
970 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
971 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
972 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
976 static void print_report(AVFormatContext **output_files,
977 AVOutputStream **ost_table, int nb_ostreams,
982 AVFormatContext *oc, *os;
985 int frame_number, vid, i;
986 double bitrate, ti1, pts;
987 static int64_t last_time = -1;
989 if (!is_last_report) {
991 /* display the report every 0.5 seconds */
992 cur_time = av_gettime();
993 if (last_time == -1) {
994 last_time = cur_time;
997 if ((cur_time - last_time) < 500000)
999 last_time = cur_time;
1003 oc = output_files[0];
1005 total_size = url_ftell(&oc->pb);
1010 for(i=0;i<nb_ostreams;i++) {
1012 os = output_files[ost->file_index];
1013 enc = &ost->st->codec;
1014 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1015 sprintf(buf + strlen(buf), "q=%2.1f ",
1016 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1018 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1019 frame_number = ost->frame_number;
1020 sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
1021 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1023 sprintf(buf + strlen(buf), "L");
1024 if (enc->flags&CODEC_FLAG_PSNR){
1026 double error, error_sum=0;
1027 double scale, scale_sum=0;
1028 char type[3]= {'Y','U','V'};
1029 sprintf(buf + strlen(buf), "PSNR=");
1032 error= enc->error[j];
1033 scale= enc->width*enc->height*255.0*255.0*frame_number;
1035 error= enc->coded_frame->error[j];
1036 scale= enc->width*enc->height*255.0*255.0;
1041 sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1043 sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1047 /* compute min output value */
1048 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1049 if ((pts < ti1) && (pts > 0))
1055 if (verbose || is_last_report) {
1056 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1058 sprintf(buf + strlen(buf),
1059 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1060 (double)total_size / 1024, ti1, bitrate);
1063 sprintf(buf + strlen(buf), " dup=%d drop=%d",
1064 nb_frames_dup, nb_frames_drop);
1067 fprintf(stderr, "%s \r", buf);
1072 if (is_last_report && verbose >= 0){
1073 int64_t raw= audio_size + video_size + extra_size;
1074 fprintf(stderr, "\n");
1075 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1079 100.0*(total_size - raw)/raw
1084 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1085 static int output_packet(AVInputStream *ist, int ist_index,
1086 AVOutputStream **ost_table, int nb_ostreams,
1087 const AVPacket *pkt)
1089 AVFormatContext *os;
1090 AVOutputStream *ost;
1094 int data_size, got_picture;
1096 void *buffer_to_free;
1097 static int samples_size= 0;
1098 static short *samples= NULL;
1101 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1102 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1103 ist->next_pts = ist->pts = pkt->dts;
1105 assert(ist->pts == ist->next_pts);
1119 /* decode the packet if needed */
1120 data_buf = NULL; /* fail safe */
1122 if (ist->decoding_needed) {
1123 switch(ist->st->codec.codec_type) {
1124 case CODEC_TYPE_AUDIO:{
1126 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1127 /* XXX: could avoid copy if PCM 16 bits with same
1128 endianness as CPU */
1129 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1135 /* Some bug in mpeg audio decoder gives */
1136 /* data_size < 0, it seems they are overflows */
1137 if (data_size <= 0) {
1138 /* no audio frame */
1141 data_buf = (uint8_t *)samples;
1142 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1143 (ist->st->codec.sample_rate * ist->st->codec.channels);
1145 case CODEC_TYPE_VIDEO:
1146 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1147 /* XXX: allocate picture correctly */
1148 avcodec_get_frame_defaults(&picture);
1150 ret = avcodec_decode_video(&ist->st->codec,
1151 &picture, &got_picture, ptr, len);
1152 ist->st->quality= picture.quality;
1156 /* no picture yet */
1157 goto discard_packet;
1159 if (ist->st->codec.frame_rate_base != 0) {
1160 ist->next_pts += ((int64_t)AV_TIME_BASE *
1161 ist->st->codec.frame_rate_base) /
1162 ist->st->codec.frame_rate;
1176 buffer_to_free = NULL;
1177 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1178 pre_process_video_frame(ist, (AVPicture *)&picture,
1182 /* frame rate emulation */
1183 if (ist->st->codec.rate_emu) {
1184 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1185 int64_t now = av_gettime() - ist->start;
1193 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1194 is the one of the next displayed one */
1195 /* XXX: add mpeg4 too ? */
1196 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1197 if (ist->st->codec.pict_type != B_TYPE) {
1199 tmp = ist->last_ip_pts;
1200 ist->last_ip_pts = ist->frac_pts.val;
1201 ist->frac_pts.val = tmp;
1205 /* if output time reached then transcode raw format,
1206 encode packets and output them */
1207 if (start_time == 0 || ist->pts >= start_time)
1208 for(i=0;i<nb_ostreams;i++) {
1212 if (ost->source_index == ist_index) {
1213 os = output_files[ost->file_index];
1216 printf("%d: got pts=%0.3f %0.3f\n", i,
1217 (double)pkt->pts / AV_TIME_BASE,
1218 ((double)ist->pts / AV_TIME_BASE) -
1219 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1221 /* set the input output pts pairs */
1222 ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1224 if (ost->encoding_needed) {
1225 switch(ost->st->codec.codec_type) {
1226 case CODEC_TYPE_AUDIO:
1227 do_audio_out(os, ost, ist, data_buf, data_size);
1229 case CODEC_TYPE_VIDEO:
1230 do_video_out(os, ost, ist, &picture, &frame_size);
1231 video_size += frame_size;
1232 if (do_vstats && frame_size)
1233 do_video_stats(os, ost, frame_size);
1239 AVFrame avframe; //FIXME/XXX remove this
1241 av_init_packet(&opkt);
1243 /* no reencoding needed : output the packet directly */
1244 /* force the input stream PTS */
1246 avcodec_get_frame_defaults(&avframe);
1247 ost->st->codec.coded_frame= &avframe;
1248 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1250 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1251 audio_size += data_size;
1252 else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1253 video_size += data_size;
1257 opkt.stream_index= ost->index;
1258 opkt.data= data_buf;
1259 opkt.size= data_size;
1260 if(pkt->pts != AV_NOPTS_VALUE)
1261 opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1263 opkt.pts= AV_NOPTS_VALUE;
1264 opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1265 opkt.flags= pkt->flags;
1267 av_interleaved_write_frame(os, &opkt);
1268 ost->st->codec.frame_number++;
1269 ost->frame_number++;
1273 av_free(buffer_to_free);
1279 for(i=0;i<nb_ostreams;i++) {
1281 if (ost->source_index == ist_index) {
1282 AVCodecContext *enc= &ost->st->codec;
1283 os = output_files[ost->file_index];
1285 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1287 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1290 if (ost->encoding_needed) {
1293 av_init_packet(&pkt);
1294 pkt.stream_index= ost->index;
1296 switch(ost->st->codec.codec_type) {
1297 case CODEC_TYPE_AUDIO:
1298 ret = avcodec_encode_audio(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1300 pkt.flags |= PKT_FLAG_KEY;
1302 case CODEC_TYPE_VIDEO:
1303 ret = avcodec_encode_video(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1305 if(enc->coded_frame && enc->coded_frame->key_frame)
1306 pkt.flags |= PKT_FLAG_KEY;
1307 if (ost->logfile && enc->stats_out) {
1308 fprintf(ost->logfile, "%s", enc->stats_out);
1317 pkt.data= bit_buffer;
1319 if(enc->coded_frame)
1320 pkt.pts= enc->coded_frame->pts;
1321 av_interleaved_write_frame(os, &pkt);
1335 * The following code is the main loop of the file converter
1337 static int av_encode(AVFormatContext **output_files,
1338 int nb_output_files,
1339 AVFormatContext **input_files,
1341 AVStreamMap *stream_maps, int nb_stream_maps)
1343 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1344 AVFormatContext *is, *os;
1345 AVCodecContext *codec, *icodec;
1346 AVOutputStream *ost, **ost_table = NULL;
1347 AVInputStream *ist, **ist_table = NULL;
1348 AVInputFile *file_table;
1349 AVFormatContext *stream_no_data;
1352 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1357 bit_buffer = av_malloc(VIDEO_BUFFER_SIZE);
1361 /* input stream init */
1363 for(i=0;i<nb_input_files;i++) {
1364 is = input_files[i];
1365 file_table[i].ist_index = j;
1366 file_table[i].nb_streams = is->nb_streams;
1367 j += is->nb_streams;
1371 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1375 for(i=0;i<nb_istreams;i++) {
1376 ist = av_mallocz(sizeof(AVInputStream));
1382 for(i=0;i<nb_input_files;i++) {
1383 is = input_files[i];
1384 for(k=0;k<is->nb_streams;k++) {
1385 ist = ist_table[j++];
1386 ist->st = is->streams[k];
1387 ist->file_index = i;
1389 ist->discard = 1; /* the stream is discarded by default
1392 if (ist->st->codec.rate_emu) {
1393 ist->start = av_gettime();
1399 /* output stream init */
1401 for(i=0;i<nb_output_files;i++) {
1402 os = output_files[i];
1403 nb_ostreams += os->nb_streams;
1405 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1406 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1410 /* Sanity check the mapping args -- do the input files & streams exist? */
1411 for(i=0;i<nb_stream_maps;i++) {
1412 int fi = stream_maps[i].file_index;
1413 int si = stream_maps[i].stream_index;
1415 if (fi < 0 || fi > nb_input_files - 1 ||
1416 si < 0 || si > file_table[fi].nb_streams - 1) {
1417 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1422 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1425 for(i=0;i<nb_ostreams;i++) {
1426 ost = av_mallocz(sizeof(AVOutputStream));
1433 for(k=0;k<nb_output_files;k++) {
1434 os = output_files[k];
1435 for(i=0;i<os->nb_streams;i++) {
1437 ost = ost_table[n++];
1438 ost->file_index = k;
1440 ost->st = os->streams[i];
1441 if (nb_stream_maps > 0) {
1442 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1443 stream_maps[n-1].stream_index;
1445 /* Sanity check that the stream types match */
1446 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1447 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1448 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1449 ost->file_index, ost->index);
1454 /* get corresponding input stream index : we select the first one with the right type */
1456 for(j=0;j<nb_istreams;j++) {
1459 ist->st->codec.codec_type == ost->st->codec.codec_type) {
1460 ost->source_index = j;
1467 /* try again and reuse existing stream */
1468 for(j=0;j<nb_istreams;j++) {
1470 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1471 ost->source_index = j;
1476 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1477 ost->file_index, ost->index);
1482 ist = ist_table[ost->source_index];
1487 /* for each output stream, we compute the right encoding parameters */
1488 for(i=0;i<nb_ostreams;i++) {
1490 ist = ist_table[ost->source_index];
1492 codec = &ost->st->codec;
1493 icodec = &ist->st->codec;
1495 if (ost->st->stream_copy) {
1496 /* if stream_copy is selected, no need to decode or encode */
1497 codec->codec_id = icodec->codec_id;
1498 codec->codec_type = icodec->codec_type;
1499 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1500 codec->bit_rate = icodec->bit_rate;
1501 switch(codec->codec_type) {
1502 case CODEC_TYPE_AUDIO:
1503 codec->sample_rate = icodec->sample_rate;
1504 codec->channels = icodec->channels;
1505 codec->frame_size = icodec->frame_size;
1507 case CODEC_TYPE_VIDEO:
1508 codec->frame_rate = icodec->frame_rate;
1509 codec->frame_rate_base = icodec->frame_rate_base;
1510 codec->width = icodec->width;
1511 codec->height = icodec->height;
1517 switch(codec->codec_type) {
1518 case CODEC_TYPE_AUDIO:
1519 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1522 if (codec->channels == icodec->channels &&
1523 codec->sample_rate == icodec->sample_rate) {
1524 ost->audio_resample = 0;
1526 if (codec->channels != icodec->channels &&
1527 (icodec->codec_id == CODEC_ID_AC3 ||
1528 icodec->codec_id == CODEC_ID_DTS)) {
1529 /* Special case for 5:1 AC3 and DTS input */
1530 /* and mono or stereo output */
1531 /* Request specific number of channels */
1532 icodec->channels = codec->channels;
1533 if (codec->sample_rate == icodec->sample_rate)
1534 ost->audio_resample = 0;
1536 ost->audio_resample = 1;
1539 ost->audio_resample = 1;
1542 if(audio_sync_method>1)
1543 ost->audio_resample = 1;
1545 if(ost->audio_resample){
1546 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1547 codec->sample_rate, icodec->sample_rate);
1549 printf("Can't resample. Aborting.\n");
1553 ist->decoding_needed = 1;
1554 ost->encoding_needed = 1;
1556 case CODEC_TYPE_VIDEO:
1557 if (codec->width == icodec->width &&
1558 codec->height == icodec->height &&
1559 frame_topBand == 0 &&
1560 frame_bottomBand == 0 &&
1561 frame_leftBand == 0 &&
1562 frame_rightBand == 0 &&
1563 frame_padtop == 0 &&
1564 frame_padbottom == 0 &&
1565 frame_padleft == 0 &&
1566 frame_padright == 0)
1568 ost->video_resample = 0;
1569 ost->video_crop = 0;
1571 } else if ((codec->width == icodec->width -
1572 (frame_leftBand + frame_rightBand)) &&
1573 (codec->height == icodec->height -
1574 (frame_topBand + frame_bottomBand)))
1576 ost->video_resample = 0;
1577 ost->video_crop = 1;
1578 ost->topBand = frame_topBand;
1579 ost->leftBand = frame_leftBand;
1580 } else if ((codec->width == icodec->width +
1581 (frame_padleft + frame_padright)) &&
1582 (codec->height == icodec->height +
1583 (frame_padtop + frame_padbottom))) {
1584 ost->video_resample = 0;
1585 ost->video_crop = 0;
1587 ost->padtop = frame_padtop;
1588 ost->padleft = frame_padleft;
1589 ost->padbottom = frame_padbottom;
1590 ost->padright = frame_padright;
1591 avcodec_get_frame_defaults(&ost->pict_tmp);
1592 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1593 codec->width, codec->height ) )
1596 ost->video_resample = 1;
1597 ost->video_crop = 0; // cropping is handled as part of resample
1598 avcodec_get_frame_defaults(&ost->pict_tmp);
1599 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1600 codec->width, codec->height ) )
1603 ost->img_resample_ctx = img_resample_full_init(
1604 ost->st->codec.width, ost->st->codec.height,
1605 ist->st->codec.width, ist->st->codec.height,
1606 frame_topBand, frame_bottomBand,
1607 frame_leftBand, frame_rightBand,
1608 frame_padtop, frame_padbottom,
1609 frame_padleft, frame_padright);
1611 ost->padtop = frame_padtop;
1612 ost->padleft = frame_padleft;
1613 ost->padbottom = frame_padbottom;
1614 ost->padright = frame_padright;
1617 ost->encoding_needed = 1;
1618 ist->decoding_needed = 1;
1624 if (ost->encoding_needed &&
1625 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1626 char logfilename[1024];
1631 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1633 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1634 if (codec->flags & CODEC_FLAG_PASS1) {
1635 f = fopen(logfilename, "w");
1637 perror(logfilename);
1642 /* read the log file */
1643 f = fopen(logfilename, "r");
1645 perror(logfilename);
1648 fseek(f, 0, SEEK_END);
1650 fseek(f, 0, SEEK_SET);
1651 logbuffer = av_malloc(size + 1);
1653 fprintf(stderr, "Could not allocate log buffer\n");
1656 size = fread(logbuffer, 1, size, f);
1658 logbuffer[size] = '\0';
1659 codec->stats_in = logbuffer;
1665 /* dump the file output parameters - cannot be done before in case
1667 for(i=0;i<nb_output_files;i++) {
1668 dump_format(output_files[i], i, output_files[i]->filename, 1);
1671 /* dump the stream mapping */
1673 fprintf(stderr, "Stream mapping:\n");
1674 for(i=0;i<nb_ostreams;i++) {
1676 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
1677 ist_table[ost->source_index]->file_index,
1678 ist_table[ost->source_index]->index,
1684 /* open each encoder */
1685 for(i=0;i<nb_ostreams;i++) {
1687 if (ost->encoding_needed) {
1689 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1691 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1692 ost->file_index, ost->index);
1695 if (avcodec_open(&ost->st->codec, codec) < 0) {
1696 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1697 ost->file_index, ost->index);
1700 extra_size += ost->st->codec.extradata_size;
1704 /* open each decoder */
1705 for(i=0;i<nb_istreams;i++) {
1707 if (ist->decoding_needed) {
1709 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1711 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1712 ist->st->codec.codec_id, ist->file_index, ist->index);
1715 if (avcodec_open(&ist->st->codec, codec) < 0) {
1716 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1717 ist->file_index, ist->index);
1720 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1721 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1726 for(i=0;i<nb_istreams;i++) {
1728 is = input_files[ist->file_index];
1730 ist->next_pts = ist->st->start_time;
1731 if(ist->next_pts == AV_NOPTS_VALUE)
1736 /* compute buffer size max (should use a complete heuristic) */
1737 for(i=0;i<nb_input_files;i++) {
1738 file_table[i].buffer_size_max = 2048;
1741 /* set meta data information from input file if required */
1742 for (i=0;i<nb_meta_data_maps;i++) {
1743 AVFormatContext *out_file;
1744 AVFormatContext *in_file;
1746 int out_file_index = meta_data_maps[i].out_file;
1747 int in_file_index = meta_data_maps[i].in_file;
1748 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1749 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1753 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1754 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1759 out_file = output_files[out_file_index];
1760 in_file = input_files[in_file_index];
1762 strcpy(out_file->title, in_file->title);
1763 strcpy(out_file->author, in_file->author);
1764 strcpy(out_file->copyright, in_file->copyright);
1765 strcpy(out_file->comment, in_file->comment);
1766 strcpy(out_file->album, in_file->album);
1767 out_file->year = in_file->year;
1768 out_file->track = in_file->track;
1769 strcpy(out_file->genre, in_file->genre);
1772 /* open files and write file headers */
1773 for(i=0;i<nb_output_files;i++) {
1774 os = output_files[i];
1775 if (av_write_header(os) < 0) {
1776 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1782 #ifndef CONFIG_WIN32
1783 if ( !using_stdin && verbose >= 0) {
1784 fprintf(stderr, "Press [q] to stop encoding\n");
1785 url_set_interrupt_cb(decode_interrupt_cb);
1793 for(; received_sigterm == 0;) {
1794 int file_index, ist_index;
1802 /* if 'q' pressed, exits */
1806 /* read_key() returns 0 on EOF */
1812 /* select the stream that we must read now by looking at the
1813 smallest output pts */
1815 for(i=0;i<nb_ostreams;i++) {
1818 os = output_files[ost->file_index];
1819 ist = ist_table[ost->source_index];
1820 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1821 opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1823 opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1824 ipts = (double)ist->pts;
1825 if (!file_table[ist->file_index].eof_reached){
1826 if(ipts < ipts_min) {
1828 if(input_sync ) file_index = ist->file_index;
1830 if(opts < opts_min) {
1832 if(!input_sync) file_index = ist->file_index;
1836 /* if none, if is finished */
1837 if (file_index < 0) {
1841 /* finish if recording time exhausted */
1842 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1845 /* read a frame from it and output it in the fifo */
1846 is = input_files[file_index];
1847 if (av_read_frame(is, &pkt) < 0) {
1848 file_table[file_index].eof_reached = 1;
1853 stream_no_data = is;
1858 av_pkt_dump(stdout, &pkt, do_hex_dump);
1860 /* the following test is needed in case new streams appear
1861 dynamically in stream : we ignore them */
1862 if (pkt.stream_index >= file_table[file_index].nb_streams)
1863 goto discard_packet;
1864 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1865 ist = ist_table[ist_index];
1867 goto discard_packet;
1869 // 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);
1870 if (pkt.dts != AV_NOPTS_VALUE) {
1871 int64_t delta= pkt.dts - ist->next_pts;
1872 if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1873 input_files_ts_offset[ist->file_index]-= delta;
1875 fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1876 for(i=0; i<file_table[file_index].nb_streams; i++){
1877 int index= file_table[file_index].ist_index + i;
1878 ist_table[index]->next_pts += delta;
1879 ist_table[index]->is_start=1;
1884 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1885 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1888 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1889 ist->file_index, ist->index);
1891 av_free_packet(&pkt);
1896 av_free_packet(&pkt);
1898 /* dump report by using the output first video and audio streams */
1899 print_report(output_files, ost_table, nb_ostreams, 0);
1902 /* at the end of stream, we must flush the decoder buffers */
1903 for(i=0;i<nb_istreams;i++) {
1905 if (ist->decoding_needed) {
1906 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1912 /* write the trailer if needed and close file */
1913 for(i=0;i<nb_output_files;i++) {
1914 os = output_files[i];
1915 av_write_trailer(os);
1918 /* dump report by using the first video and audio streams */
1919 print_report(output_files, ost_table, nb_ostreams, 1);
1921 /* close each encoder */
1922 for(i=0;i<nb_ostreams;i++) {
1924 if (ost->encoding_needed) {
1925 av_freep(&ost->st->codec.stats_in);
1926 avcodec_close(&ost->st->codec);
1930 /* close each decoder */
1931 for(i=0;i<nb_istreams;i++) {
1933 if (ist->decoding_needed) {
1934 avcodec_close(&ist->st->codec);
1942 av_free(file_table);
1945 for(i=0;i<nb_istreams;i++) {
1952 for(i=0;i<nb_ostreams;i++) {
1956 fclose(ost->logfile);
1957 ost->logfile = NULL;
1959 fifo_free(&ost->fifo); /* works even if fifo is not
1960 initialized but set to zero */
1961 av_free(ost->pict_tmp.data[0]);
1962 if (ost->video_resample)
1963 img_resample_close(ost->img_resample_ctx);
1964 if (ost->audio_resample)
1965 audio_resample_close(ost->resample);
1978 int file_read(const char *filename)
1981 unsigned char buffer[1024];
1984 if (url_open(&h, filename, O_RDONLY) < 0) {
1985 printf("could not open '%s'\n", filename);
1989 len = url_read(h, buffer, sizeof(buffer));
1992 for(i=0;i<len;i++) putchar(buffer[i]);
1999 static void opt_image_format(const char *arg)
2003 for(f = first_image_format; f != NULL; f = f->next) {
2004 if (!strcmp(arg, f->name))
2008 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2014 static void opt_format(const char *arg)
2016 /* compatibility stuff for pgmyuv */
2017 if (!strcmp(arg, "pgmyuv")) {
2018 opt_image_format(arg);
2022 file_iformat = av_find_input_format(arg);
2023 file_oformat = guess_format(arg, NULL, NULL);
2024 if (!file_iformat && !file_oformat) {
2025 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2030 static void opt_video_bitrate(const char *arg)
2032 video_bit_rate = atoi(arg) * 1000;
2035 static void opt_video_bitrate_tolerance(const char *arg)
2037 video_bit_rate_tolerance = atoi(arg) * 1000;
2040 static void opt_video_bitrate_max(const char *arg)
2042 video_rc_max_rate = atoi(arg) * 1000;
2045 static void opt_video_bitrate_min(const char *arg)
2047 video_rc_min_rate = atoi(arg) * 1000;
2050 static void opt_video_buffer_size(const char *arg)
2052 video_rc_buffer_size = atoi(arg) * 8*1024;
2055 static void opt_video_rc_eq(char *arg)
2060 static void opt_video_rc_override_string(char *arg)
2062 video_rc_override_string = arg;
2066 static void opt_workaround_bugs(const char *arg)
2068 workaround_bugs = atoi(arg);
2071 static void opt_dct_algo(const char *arg)
2073 dct_algo = atoi(arg);
2076 static void opt_idct_algo(const char *arg)
2078 idct_algo = atoi(arg);
2081 static void opt_me_threshold(const char *arg)
2083 me_threshold = atoi(arg);
2086 static void opt_mb_threshold(const char *arg)
2088 mb_threshold = atoi(arg);
2091 static void opt_error_resilience(const char *arg)
2093 error_resilience = atoi(arg);
2096 static void opt_error_concealment(const char *arg)
2098 error_concealment = atoi(arg);
2101 static void opt_debug(const char *arg)
2106 static void opt_vismv(const char *arg)
2108 debug_mv = atoi(arg);
2111 static void opt_verbose(const char *arg)
2113 verbose = atoi(arg);
2114 av_log_set_level(atoi(arg));
2117 static void opt_frame_rate(const char *arg)
2119 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2120 fprintf(stderr, "Incorrect frame rate\n");
2125 static void opt_frame_crop_top(const char *arg)
2127 frame_topBand = atoi(arg);
2128 if (frame_topBand < 0) {
2129 fprintf(stderr, "Incorrect top crop size\n");
2132 if ((frame_topBand % 2) != 0) {
2133 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2136 if ((frame_topBand) >= frame_height){
2137 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2140 frame_height -= frame_topBand;
2143 static void opt_frame_crop_bottom(const char *arg)
2145 frame_bottomBand = atoi(arg);
2146 if (frame_bottomBand < 0) {
2147 fprintf(stderr, "Incorrect bottom crop size\n");
2150 if ((frame_bottomBand % 2) != 0) {
2151 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2154 if ((frame_bottomBand) >= frame_height){
2155 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2158 frame_height -= frame_bottomBand;
2161 static void opt_frame_crop_left(const char *arg)
2163 frame_leftBand = atoi(arg);
2164 if (frame_leftBand < 0) {
2165 fprintf(stderr, "Incorrect left crop size\n");
2168 if ((frame_leftBand % 2) != 0) {
2169 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2172 if ((frame_leftBand) >= frame_width){
2173 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2176 frame_width -= frame_leftBand;
2179 static void opt_frame_crop_right(const char *arg)
2181 frame_rightBand = atoi(arg);
2182 if (frame_rightBand < 0) {
2183 fprintf(stderr, "Incorrect right crop size\n");
2186 if ((frame_rightBand % 2) != 0) {
2187 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2190 if ((frame_rightBand) >= frame_width){
2191 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2194 frame_width -= frame_rightBand;
2197 static void opt_frame_size(const char *arg)
2199 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2200 fprintf(stderr, "Incorrect frame size\n");
2203 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2204 fprintf(stderr, "Frame size must be a multiple of 2\n");
2210 #define SCALEBITS 10
2211 #define ONE_HALF (1 << (SCALEBITS - 1))
2212 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2214 #define RGB_TO_Y(r, g, b) \
2215 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2216 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2218 #define RGB_TO_U(r1, g1, b1, shift)\
2219 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2220 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2222 #define RGB_TO_V(r1, g1, b1, shift)\
2223 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2224 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2226 static void opt_pad_color(const char *arg) {
2227 /* Input is expected to be six hex digits similar to
2228 how colors are expressed in html tags (but without the #) */
2229 int rgb = strtol(arg, NULL, 16);
2233 g = ((rgb >> 8) & 255);
2236 padcolor[0] = RGB_TO_Y(r,g,b);
2237 padcolor[1] = RGB_TO_U(r,g,b,0);
2238 padcolor[2] = RGB_TO_V(r,g,b,0);
2241 static void opt_frame_pad_top(const char *arg)
2243 frame_padtop = atoi(arg);
2244 if (frame_padtop < 0) {
2245 fprintf(stderr, "Incorrect top pad size\n");
2248 if ((frame_padtop % 2) != 0) {
2249 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2254 static void opt_frame_pad_bottom(const char *arg)
2256 frame_padbottom = atoi(arg);
2257 if (frame_padbottom < 0) {
2258 fprintf(stderr, "Incorrect bottom pad size\n");
2261 if ((frame_padbottom % 2) != 0) {
2262 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2268 static void opt_frame_pad_left(const char *arg)
2270 frame_padleft = atoi(arg);
2271 if (frame_padleft < 0) {
2272 fprintf(stderr, "Incorrect left pad size\n");
2275 if ((frame_padleft % 2) != 0) {
2276 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2282 static void opt_frame_pad_right(const char *arg)
2284 frame_padright = atoi(arg);
2285 if (frame_padright < 0) {
2286 fprintf(stderr, "Incorrect right pad size\n");
2289 if ((frame_padright % 2) != 0) {
2290 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2296 static void opt_frame_pix_fmt(const char *arg)
2298 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2301 static void opt_frame_aspect_ratio(const char *arg)
2307 p = strchr(arg, ':');
2309 x = strtol(arg, (char **)&arg, 10);
2311 y = strtol(arg+1, (char **)&arg, 10);
2313 ar = (double)x / (double)y;
2315 ar = strtod(arg, (char **)&arg);
2318 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2321 frame_aspect_ratio = ar;
2324 static void opt_gop_size(const char *arg)
2326 gop_size = atoi(arg);
2329 static void opt_b_frames(const char *arg)
2331 b_frames = atoi(arg);
2332 if (b_frames > FF_MAX_B_FRAMES) {
2333 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2335 } else if (b_frames < 1) {
2336 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2341 static void opt_mb_decision(const char *arg)
2343 mb_decision = atoi(arg);
2346 static void opt_mb_cmp(const char *arg)
2351 static void opt_ildct_cmp(const char *arg)
2353 ildct_cmp = atoi(arg);
2356 static void opt_sub_cmp(const char *arg)
2358 sub_cmp = atoi(arg);
2361 static void opt_cmp(const char *arg)
2366 static void opt_pre_cmp(const char *arg)
2368 pre_cmp = atoi(arg);
2371 static void opt_pre_me(const char *arg)
2376 static void opt_lumi_mask(const char *arg)
2378 lumi_mask = atof(arg);
2381 static void opt_dark_mask(const char *arg)
2383 dark_mask = atof(arg);
2386 static void opt_scplx_mask(const char *arg)
2388 scplx_mask = atof(arg);
2391 static void opt_tcplx_mask(const char *arg)
2393 tcplx_mask = atof(arg);
2396 static void opt_p_mask(const char *arg)
2401 static void opt_qscale(const char *arg)
2403 video_qscale = atof(arg);
2404 if (video_qscale < 0.01 ||
2405 video_qscale > 255) {
2406 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2411 static void opt_lmax(const char *arg)
2413 video_lmax = atof(arg)*FF_QP2LAMBDA;
2416 static void opt_lmin(const char *arg)
2418 video_lmin = atof(arg)*FF_QP2LAMBDA;
2421 static void opt_qmin(const char *arg)
2423 video_qmin = atoi(arg);
2424 if (video_qmin < 0 ||
2426 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2431 static void opt_qmax(const char *arg)
2433 video_qmax = atoi(arg);
2434 if (video_qmax < 0 ||
2436 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2441 static void opt_mb_qmin(const char *arg)
2443 video_mb_qmin = atoi(arg);
2444 if (video_mb_qmin < 0 ||
2445 video_mb_qmin > 31) {
2446 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2451 static void opt_mb_qmax(const char *arg)
2453 video_mb_qmax = atoi(arg);
2454 if (video_mb_qmax < 0 ||
2455 video_mb_qmax > 31) {
2456 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2461 static void opt_qdiff(const char *arg)
2463 video_qdiff = atoi(arg);
2464 if (video_qdiff < 0 ||
2466 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2471 static void opt_qblur(const char *arg)
2473 video_qblur = atof(arg);
2476 static void opt_qcomp(const char *arg)
2478 video_qcomp = atof(arg);
2481 static void opt_rc_initial_cplx(const char *arg)
2483 video_rc_initial_cplx = atof(arg);
2485 static void opt_b_qfactor(const char *arg)
2487 video_b_qfactor = atof(arg);
2489 static void opt_i_qfactor(const char *arg)
2491 video_i_qfactor = atof(arg);
2493 static void opt_b_qoffset(const char *arg)
2495 video_b_qoffset = atof(arg);
2497 static void opt_i_qoffset(const char *arg)
2499 video_i_qoffset = atof(arg);
2502 static void opt_ibias(const char *arg)
2504 video_intra_quant_bias = atoi(arg);
2506 static void opt_pbias(const char *arg)
2508 video_inter_quant_bias = atoi(arg);
2511 static void opt_packet_size(const char *arg)
2513 packet_size= atoi(arg);
2516 static void opt_error_rate(const char *arg)
2518 error_rate= atoi(arg);
2521 static void opt_strict(const char *arg)
2526 static void opt_top_field_first(const char *arg)
2528 top_field_first= atoi(arg);
2531 static void opt_noise_reduction(const char *arg)
2533 noise_reduction= atoi(arg);
2536 static void opt_qns(const char *arg)
2541 static void opt_sc_threshold(const char *arg)
2543 sc_threshold= atoi(arg);
2546 static void opt_me_range(const char *arg)
2548 me_range = atoi(arg);
2551 static void opt_thread_count(const char *arg)
2553 thread_count= atoi(arg);
2554 #if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2556 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2560 static void opt_audio_bitrate(const char *arg)
2562 audio_bit_rate = atoi(arg) * 1000;
2565 static void opt_audio_rate(const char *arg)
2567 audio_sample_rate = atoi(arg);
2570 static void opt_audio_channels(const char *arg)
2572 audio_channels = atoi(arg);
2575 static void opt_video_device(const char *arg)
2577 video_device = av_strdup(arg);
2580 static void opt_grab_device(const char *arg)
2582 grab_device = av_strdup(arg);
2585 static void opt_video_channel(const char *arg)
2587 video_channel = strtol(arg, NULL, 0);
2590 static void opt_video_standard(const char *arg)
2592 video_standard = av_strdup(arg);
2595 static void opt_audio_device(const char *arg)
2597 audio_device = av_strdup(arg);
2600 static void opt_audio_codec(const char *arg)
2604 if (!strcmp(arg, "copy")) {
2605 audio_stream_copy = 1;
2609 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2614 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2617 audio_codec_id = p->id;
2622 static void opt_audio_tag(const char *arg)
2625 audio_codec_tag= strtol(arg, &tail, 0);
2628 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2631 static void opt_video_tag(const char *arg)
2634 video_codec_tag= strtol(arg, &tail, 0);
2637 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2640 static void add_frame_hooker(const char *arg)
2645 char *args = av_strdup(arg);
2649 argv[0] = strtok(args, " ");
2650 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2653 i = frame_hook_add(argc, argv);
2656 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2661 const char *motion_str[] = {
2671 static void opt_motion_estimation(const char *arg)
2677 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2680 if (!strcmp(*p, arg))
2684 me_method = (p - motion_str) + 1;
2687 static void opt_video_codec(const char *arg)
2691 if (!strcmp(arg, "copy")) {
2692 video_stream_copy = 1;
2696 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2701 fprintf(stderr, "Unknown video codec '%s'\n", arg);
2704 video_codec_id = p->id;
2709 static void opt_map(const char *arg)
2715 m = &stream_maps[nb_stream_maps++];
2717 m->file_index = strtol(arg, (char **)&p, 0);
2721 m->stream_index = strtol(p, (char **)&p, 0);
2724 static void opt_map_meta_data(const char *arg)
2730 m = &meta_data_maps[nb_meta_data_maps++];
2732 m->out_file = strtol(arg, (char **)&p, 0);
2736 m->in_file = strtol(p, (char **)&p, 0);
2739 static void opt_recording_time(const char *arg)
2741 recording_time = parse_date(arg, 1);
2744 static void opt_start_time(const char *arg)
2746 start_time = parse_date(arg, 1);
2749 static void opt_rec_timestamp(const char *arg)
2751 rec_timestamp = parse_date(arg, 0) / 1000000;
2754 static void opt_input_ts_offset(const char *arg)
2756 input_ts_offset = parse_date(arg, 1);
2759 static void opt_input_file(const char *filename)
2761 AVFormatContext *ic;
2762 AVFormatParameters params, *ap = ¶ms;
2763 int err, i, ret, rfps, rfps_base;
2766 if (!strcmp(filename, "-"))
2769 using_stdin |= !strcmp(filename, "pipe:" ) ||
2770 !strcmp( filename, "/dev/stdin" );
2772 /* get default parameters from command line */
2773 memset(ap, 0, sizeof(*ap));
2774 ap->sample_rate = audio_sample_rate;
2775 ap->channels = audio_channels;
2776 ap->frame_rate = frame_rate;
2777 ap->frame_rate_base = frame_rate_base;
2778 ap->width = frame_width + frame_padleft + frame_padright;
2779 ap->height = frame_height + frame_padtop + frame_padbottom;
2780 ap->image_format = image_format;
2781 ap->pix_fmt = frame_pix_fmt;
2782 ap->device = grab_device;
2783 ap->channel = video_channel;
2784 ap->standard = video_standard;
2786 /* open the input file with generic libav function */
2787 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2789 print_error(filename, err);
2793 /* If not enough info to get the stream parameters, we decode the
2794 first frames to get it. (used in mpeg case for example) */
2795 ret = av_find_stream_info(ic);
2796 if (ret < 0 && verbose >= 0) {
2797 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2801 timestamp = start_time;
2802 /* add the stream start time */
2803 if (ic->start_time != AV_NOPTS_VALUE)
2804 timestamp += ic->start_time;
2806 /* if seeking requested, we execute it */
2807 if (start_time != 0) {
2808 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2810 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2811 filename, (double)timestamp / AV_TIME_BASE);
2813 /* reset seek info */
2817 /* update the current parameters so that they match the one of the input stream */
2818 for(i=0;i<ic->nb_streams;i++) {
2819 AVCodecContext *enc = &ic->streams[i]->codec;
2820 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2822 avcodec_thread_init(enc, thread_count);
2824 enc->thread_count= thread_count;
2825 switch(enc->codec_type) {
2826 case CODEC_TYPE_AUDIO:
2827 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2828 audio_channels = enc->channels;
2829 audio_sample_rate = enc->sample_rate;
2831 case CODEC_TYPE_VIDEO:
2832 frame_height = enc->height;
2833 frame_width = enc->width;
2834 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2835 frame_pix_fmt = enc->pix_fmt;
2836 rfps = ic->streams[i]->r_frame_rate;
2837 rfps_base = ic->streams[i]->r_frame_rate_base;
2838 enc->workaround_bugs = workaround_bugs;
2839 enc->error_resilience = error_resilience;
2840 enc->error_concealment = error_concealment;
2841 enc->idct_algo = idct_algo;
2843 enc->debug_mv = debug_mv;
2844 enc->lowres= lowres;
2846 enc->flags|= CODEC_FLAG_BITEXACT;
2848 enc->debug |= FF_DEBUG_MV;
2850 assert(enc->frame_rate_base == rfps_base); // should be true for now
2851 if (enc->frame_rate != rfps) {
2854 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2855 i, (float)enc->frame_rate / enc->frame_rate_base,
2857 (float)rfps / rfps_base);
2859 /* update the current frame rate to match the stream frame rate */
2861 frame_rate_base = rfps_base;
2863 enc->rate_emu = rate_emu;
2865 case CODEC_TYPE_DATA:
2872 input_files[nb_input_files] = ic;
2873 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2874 /* dump the file content */
2876 dump_format(ic, nb_input_files, filename, 0);
2879 file_iformat = NULL;
2880 file_oformat = NULL;
2881 image_format = NULL;
2889 static void opt_grab(const char *arg)
2891 file_iformat = av_find_input_format(arg);
2895 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2897 int has_video, has_audio, i, j;
2898 AVFormatContext *ic;
2902 for(j=0;j<nb_input_files;j++) {
2903 ic = input_files[j];
2904 for(i=0;i<ic->nb_streams;i++) {
2905 AVCodecContext *enc = &ic->streams[i]->codec;
2906 switch(enc->codec_type) {
2907 case CODEC_TYPE_AUDIO:
2910 case CODEC_TYPE_VIDEO:
2913 case CODEC_TYPE_DATA:
2920 *has_video_ptr = has_video;
2921 *has_audio_ptr = has_audio;
2924 static void opt_output_file(const char *filename)
2927 AVFormatContext *oc;
2928 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2930 AVFormatParameters params, *ap = ¶ms;
2932 if (!strcmp(filename, "-"))
2935 oc = av_alloc_format_context();
2937 if (!file_oformat) {
2938 file_oformat = guess_format(NULL, filename, NULL);
2939 if (!file_oformat) {
2940 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2946 oc->oformat = file_oformat;
2948 if (!strcmp(file_oformat->name, "ffm") &&
2949 strstart(filename, "http:", NULL)) {
2950 /* special case for files sent to ffserver: we get the stream
2951 parameters from ffserver */
2952 if (read_ffserver_streams(oc, filename) < 0) {
2953 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2957 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2958 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2960 /* disable if no corresponding type found and at least one
2962 if (nb_input_files > 0) {
2963 check_audio_video_inputs(&input_has_video, &input_has_audio);
2964 if (!input_has_video)
2966 if (!input_has_audio)
2970 /* manual disable */
2971 if (audio_disable) {
2974 if (video_disable) {
2980 AVCodecContext *video_enc;
2982 st = av_new_stream(oc, nb_streams++);
2984 fprintf(stderr, "Could not alloc stream\n");
2987 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2989 avcodec_thread_init(&st->codec, thread_count);
2992 video_enc = &st->codec;
2995 video_enc->codec_tag= video_codec_tag;
2997 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2998 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2999 if (video_stream_copy) {
3000 st->stream_copy = 1;
3001 video_enc->codec_type = CODEC_TYPE_VIDEO;
3007 codec_id = file_oformat->video_codec;
3008 if (video_codec_id != CODEC_ID_NONE)
3009 codec_id = video_codec_id;
3011 video_enc->codec_id = codec_id;
3012 codec = avcodec_find_encoder(codec_id);
3014 video_enc->bit_rate = video_bit_rate;
3015 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3016 video_enc->frame_rate = frame_rate;
3017 video_enc->frame_rate_base = frame_rate_base;
3018 if(codec && codec->supported_framerates){
3019 const AVRational *p= codec->supported_framerates;
3020 AVRational req= (AVRational){frame_rate, frame_rate_base};
3021 const AVRational *best=NULL;
3022 AVRational best_error= (AVRational){INT_MAX, 1};
3023 for(; p->den!=0; p++){
3024 AVRational error= av_sub_q(req, *p);
3025 if(error.num <0) error.num *= -1;
3026 if(av_cmp_q(error, best_error) < 0){
3031 video_enc->frame_rate = best->num;
3032 video_enc->frame_rate_base= best->den;
3035 video_enc->width = frame_width + frame_padright + frame_padleft;
3036 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3037 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3038 video_enc->pix_fmt = frame_pix_fmt;
3040 if(codec && codec->pix_fmts){
3041 const enum PixelFormat *p= codec->pix_fmts;
3043 if(*p == video_enc->pix_fmt)
3047 video_enc->pix_fmt = codec->pix_fmts[0];
3051 video_enc->gop_size = gop_size;
3053 video_enc->gop_size = 0;
3054 if (video_qscale || same_quality) {
3055 video_enc->flags |= CODEC_FLAG_QSCALE;
3056 st->quality = FF_QP2LAMBDA * video_qscale;
3060 video_enc->intra_matrix = intra_matrix;
3062 video_enc->inter_matrix = inter_matrix;
3065 video_enc->flags |= CODEC_FLAG_BITEXACT;
3067 video_enc->mb_decision = mb_decision;
3068 video_enc->mb_cmp = mb_cmp;
3069 video_enc->ildct_cmp = ildct_cmp;
3070 video_enc->me_sub_cmp = sub_cmp;
3071 video_enc->me_cmp = cmp;
3072 video_enc->me_pre_cmp = pre_cmp;
3073 video_enc->pre_me = pre_me;
3074 video_enc->lumi_masking = lumi_mask;
3075 video_enc->dark_masking = dark_mask;
3076 video_enc->spatial_cplx_masking = scplx_mask;
3077 video_enc->temporal_cplx_masking = tcplx_mask;
3078 video_enc->p_masking = p_mask;
3079 video_enc->quantizer_noise_shaping= qns;
3082 video_enc->flags |= CODEC_FLAG_H263P_UMV;
3085 video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3088 video_enc->flags |= CODEC_FLAG_H263P_AIC;
3091 video_enc->flags |= CODEC_FLAG_H263P_AIV;
3094 video_enc->flags |= CODEC_FLAG_4MV;
3097 video_enc->flags |= CODEC_FLAG_OBMC;
3100 video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3104 video_enc->flags |= CODEC_FLAG_PART;
3107 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3110 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3112 if (use_scan_offset) {
3113 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3116 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3119 video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3122 video_enc->flags |= CODEC_FLAG_QPEL;
3125 video_enc->flags |= CODEC_FLAG_QP_RD;
3128 video_enc->flags |= CODEC_FLAG_CBP_RD;
3131 video_enc->max_b_frames = b_frames;
3132 video_enc->b_frame_strategy = 0;
3133 video_enc->b_quant_factor = 2.0;
3135 if (do_interlace_dct) {
3136 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3138 if (do_interlace_me) {
3139 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3141 video_enc->qmin = video_qmin;
3142 video_enc->qmax = video_qmax;
3143 video_enc->lmin = video_lmin;
3144 video_enc->lmax = video_lmax;
3145 video_enc->mb_qmin = video_mb_qmin;
3146 video_enc->mb_qmax = video_mb_qmax;
3147 video_enc->max_qdiff = video_qdiff;
3148 video_enc->qblur = video_qblur;
3149 video_enc->qcompress = video_qcomp;
3150 video_enc->rc_eq = video_rc_eq;
3151 video_enc->debug = debug;
3152 video_enc->debug_mv = debug_mv;
3153 video_enc->thread_count = thread_count;
3154 p= video_rc_override_string;
3157 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3159 fprintf(stderr, "error parsing rc_override\n");
3162 video_enc->rc_override=
3163 av_realloc(video_enc->rc_override,
3164 sizeof(RcOverride)*(i+1));
3165 video_enc->rc_override[i].start_frame= start;
3166 video_enc->rc_override[i].end_frame = end;
3168 video_enc->rc_override[i].qscale= q;
3169 video_enc->rc_override[i].quality_factor= 1.0;
3172 video_enc->rc_override[i].qscale= 0;
3173 video_enc->rc_override[i].quality_factor= -q/100.0;
3178 video_enc->rc_override_count=i;
3180 video_enc->rc_max_rate = video_rc_max_rate;
3181 video_enc->rc_min_rate = video_rc_min_rate;
3182 video_enc->rc_buffer_size = video_rc_buffer_size;
3183 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3184 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3185 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3186 video_enc->i_quant_factor = video_i_qfactor;
3187 video_enc->b_quant_factor = video_b_qfactor;
3188 video_enc->i_quant_offset = video_i_qoffset;
3189 video_enc->b_quant_offset = video_b_qoffset;
3190 video_enc->intra_quant_bias = video_intra_quant_bias;
3191 video_enc->inter_quant_bias = video_inter_quant_bias;
3192 video_enc->dct_algo = dct_algo;
3193 video_enc->idct_algo = idct_algo;
3194 video_enc->me_threshold= me_threshold;
3195 video_enc->mb_threshold= mb_threshold;
3196 video_enc->intra_dc_precision= intra_dc_precision - 8;
3197 video_enc->strict_std_compliance = strict;
3198 video_enc->error_rate = error_rate;
3199 video_enc->noise_reduction= noise_reduction;
3200 video_enc->scenechange_threshold= sc_threshold;
3201 video_enc->me_range = me_range;
3202 video_enc->coder_type= coder;
3203 video_enc->context_model= context;
3204 video_enc->prediction_method= predictor;
3205 video_enc->profile= video_profile;
3206 video_enc->level= video_level;
3207 video_enc->nsse_weight= nsse_weight;
3208 video_enc->me_subpel_quality= subpel_quality;
3211 video_enc->rtp_mode= 1;
3212 video_enc->rtp_payload_size= packet_size;
3216 video_enc->flags|= CODEC_FLAG_PSNR;
3218 video_enc->me_method = me_method;
3223 video_enc->flags |= CODEC_FLAG_PASS1;
3225 video_enc->flags |= CODEC_FLAG_PASS2;
3232 AVCodecContext *audio_enc;
3234 st = av_new_stream(oc, nb_streams++);
3236 fprintf(stderr, "Could not alloc stream\n");
3239 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
3241 avcodec_thread_init(&st->codec, thread_count);
3244 audio_enc = &st->codec;
3245 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3248 audio_enc->codec_tag= audio_codec_tag;
3250 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3251 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3252 if (audio_stream_copy) {
3253 st->stream_copy = 1;
3254 audio_enc->channels = audio_channels;
3256 codec_id = file_oformat->audio_codec;
3257 if (audio_codec_id != CODEC_ID_NONE)
3258 codec_id = audio_codec_id;
3259 audio_enc->codec_id = codec_id;
3261 audio_enc->bit_rate = audio_bit_rate;
3262 audio_enc->strict_std_compliance = strict;
3263 audio_enc->thread_count = thread_count;
3264 /* For audio codecs other than AC3 or DTS we limit */
3265 /* the number of coded channels to stereo */
3266 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3267 && codec_id != CODEC_ID_DTS) {
3268 audio_enc->channels = 2;
3270 audio_enc->channels = audio_channels;
3272 audio_enc->sample_rate = audio_sample_rate;
3275 oc->nb_streams = nb_streams;
3278 fprintf(stderr, "No audio or video streams available\n");
3282 oc->timestamp = rec_timestamp;
3285 pstrcpy(oc->title, sizeof(oc->title), str_title);
3287 pstrcpy(oc->author, sizeof(oc->author), str_author);
3289 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3291 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3294 output_files[nb_output_files++] = oc;
3296 strcpy(oc->filename, filename);
3298 /* check filename in case of an image number is expected */
3299 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3300 if (filename_number_test(oc->filename) < 0) {
3301 print_error(oc->filename, AVERROR_NUMEXPECTED);
3306 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3307 /* test if it already exists to avoid loosing precious files */
3308 if (!file_overwrite &&
3309 (strchr(filename, ':') == NULL ||
3310 strstart(filename, "file:", NULL))) {
3311 if (url_exist(filename)) {
3314 if ( !using_stdin ) {
3315 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3318 if (toupper(c) != 'Y') {
3319 fprintf(stderr, "Not overwriting - exiting\n");
3324 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3331 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3332 fprintf(stderr, "Could not open '%s'\n", filename);
3337 memset(ap, 0, sizeof(*ap));
3338 ap->image_format = image_format;
3339 if (av_set_parameters(oc, ap) < 0) {
3340 fprintf(stderr, "%s: Invalid encoding parameters\n",
3345 oc->packet_size= mux_packet_size;
3346 oc->mux_rate= mux_rate;
3347 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3348 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3350 /* reset some options */
3351 file_oformat = NULL;
3352 file_iformat = NULL;
3353 image_format = NULL;
3356 audio_codec_id = CODEC_ID_NONE;
3357 video_codec_id = CODEC_ID_NONE;
3358 audio_stream_copy = 0;
3359 video_stream_copy = 0;
3362 /* prepare dummy protocols for grab */
3363 static void prepare_grab(void)
3365 int has_video, has_audio, i, j;
3366 AVFormatContext *oc;
3367 AVFormatContext *ic;
3368 AVFormatParameters vp1, *vp = &vp1;
3369 AVFormatParameters ap1, *ap = &ap1;
3371 /* see if audio/video inputs are needed */
3374 memset(ap, 0, sizeof(*ap));
3375 memset(vp, 0, sizeof(*vp));
3376 vp->frame_rate_base= 1;
3377 for(j=0;j<nb_output_files;j++) {
3378 oc = output_files[j];
3379 for(i=0;i<oc->nb_streams;i++) {
3380 AVCodecContext *enc = &oc->streams[i]->codec;
3381 switch(enc->codec_type) {
3382 case CODEC_TYPE_AUDIO:
3383 if (enc->sample_rate > ap->sample_rate)
3384 ap->sample_rate = enc->sample_rate;
3385 if (enc->channels > ap->channels)
3386 ap->channels = enc->channels;
3389 case CODEC_TYPE_VIDEO:
3390 if (enc->width > vp->width)
3391 vp->width = enc->width;
3392 if (enc->height > vp->height)
3393 vp->height = enc->height;
3395 if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3396 vp->frame_rate = enc->frame_rate;
3397 vp->frame_rate_base = enc->frame_rate_base;
3407 if (has_video == 0 && has_audio == 0) {
3408 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3413 AVInputFormat *fmt1;
3414 fmt1 = av_find_input_format(video_grab_format);
3415 vp->device = video_device;
3416 vp->channel = video_channel;
3417 vp->standard = video_standard;
3418 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3419 fprintf(stderr, "Could not find video grab device\n");
3422 /* If not enough info to get the stream parameters, we decode the
3423 first frames to get it. */
3424 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3425 fprintf(stderr, "Could not find video grab parameters\n");
3428 /* by now video grab has one stream */
3429 ic->streams[0]->r_frame_rate = vp->frame_rate;
3430 ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3431 input_files[nb_input_files] = ic;
3434 dump_format(ic, nb_input_files, "", 0);
3438 if (has_audio && audio_grab_format) {
3439 AVInputFormat *fmt1;
3440 fmt1 = av_find_input_format(audio_grab_format);
3441 ap->device = audio_device;
3442 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3443 fprintf(stderr, "Could not find audio grab device\n");
3446 input_files[nb_input_files] = ic;
3449 dump_format(ic, nb_input_files, "", 0);
3455 /* same option as mencoder */
3456 static void opt_pass(const char *pass_str)
3459 pass = atoi(pass_str);
3460 if (pass != 1 && pass != 2) {
3461 fprintf(stderr, "pass number can be only 1 or 2\n");
3467 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3468 static int64_t getutime(void)
3470 return av_gettime();
3473 static int64_t getutime(void)
3475 struct rusage rusage;
3477 getrusage(RUSAGE_SELF, &rusage);
3478 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3482 extern int ffm_nopts;
3484 static void opt_bitexact(void)
3487 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3491 static void show_formats(void)
3493 AVInputFormat *ifmt;
3494 AVOutputFormat *ofmt;
3495 AVImageFormat *image_fmt;
3498 const char **pp, *last_name;
3500 printf("File formats:\n");
3505 const char *name=NULL;
3506 const char *long_name=NULL;
3508 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3509 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3510 strcmp(ofmt->name, last_name)>0){
3512 long_name= ofmt->long_name;
3516 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3517 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3518 strcmp(ifmt->name, last_name)>0){
3520 long_name= ifmt->long_name;
3523 if(name && strcmp(ifmt->name, name)==0)
3535 long_name ? long_name:" ");
3539 printf("Image formats (filename extensions, if any, follow):\n");
3540 for(image_fmt = first_image_format; image_fmt != NULL;
3541 image_fmt = image_fmt->next) {
3544 image_fmt->img_read ? "D":" ",
3545 image_fmt->img_write ? "E":" ",
3547 image_fmt->extensions ? image_fmt->extensions:" ");
3551 printf("Codecs:\n");
3559 for(p = first_avcodec; p != NULL; p = p->next) {
3560 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3561 strcmp(p->name, last_name)>0){
3563 decode= encode= cap=0;
3565 if(p2 && strcmp(p->name, p2->name)==0){
3566 if(p->decode) decode=1;
3567 if(p->encode) encode=1;
3568 cap |= p->capabilities;
3573 last_name= p2->name;
3577 decode ? "D": (/*p2->decoder ? "d":*/" "),
3579 p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3580 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3581 cap & CODEC_CAP_DR1 ? "D":" ",
3582 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3584 /* if(p2->decoder && decode==0)
3585 printf(" use %s for decoding", p2->decoder->name);*/
3590 printf("Supported file protocols:\n");
3591 for(up = first_protocol; up != NULL; up = up->next)
3592 printf(" %s:", up->name);
3595 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3596 printf("Motion estimation methods:\n");
3600 if ((pp - motion_str + 1) == ME_ZERO)
3601 printf("(fastest)");
3602 else if ((pp - motion_str + 1) == ME_FULL)
3603 printf("(slowest)");
3604 else if ((pp - motion_str + 1) == ME_EPZS)
3605 printf("(default)");
3610 "Note, the names of encoders and decoders dont always match, so there are\n"
3611 "several cases where the above table shows encoder only or decoder only entries\n"
3612 "even though both encoding and decoding are supported for example, the h263\n"
3613 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3618 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3621 const char *p = str;
3628 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3635 void opt_inter_matrix(const char *arg)
3637 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3638 parse_matrix_coeffs(inter_matrix, arg);
3641 void opt_intra_matrix(const char *arg)
3643 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3644 parse_matrix_coeffs(intra_matrix, arg);
3647 static void opt_target(const char *arg)
3651 if(!strncmp(arg, "pal-", 4)) {
3654 } else if(!strncmp(arg, "ntsc-", 5)) {
3659 /* Calculate FR via float to avoid int overflow */
3660 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3663 } else if((fr == 29970) || (fr == 23976)) {
3666 /* Try to determine PAL/NTSC by peeking in the input files */
3667 if(nb_input_files) {
3669 for(j = 0; j < nb_input_files; j++) {
3670 for(i = 0; i < input_files[j]->nb_streams; i++) {
3671 AVCodecContext *c = &input_files[j]->streams[i]->codec;
3672 if(c->codec_type != CODEC_TYPE_VIDEO)
3674 fr = c->frame_rate * 1000 / c->frame_rate_base;
3678 } else if((fr == 29970) || (fr == 23976)) {
3688 if(verbose && norm >= 0)
3689 printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3693 fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3694 fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3695 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3699 if(!strcmp(arg, "vcd")) {
3701 opt_video_codec("mpeg1video");
3702 opt_audio_codec("mp2");
3705 opt_frame_size(norm ? "352x240" : "352x288");
3707 video_bit_rate = 1150000;
3708 video_rc_max_rate = 1150000;
3709 video_rc_min_rate = 1150000;
3710 video_rc_buffer_size = 40*1024*8;
3712 audio_bit_rate = 224000;
3713 audio_sample_rate = 44100;
3715 mux_packet_size= 2324;
3716 mux_rate= 2352 * 75 * 8;
3718 /* We have to offset the PTS, so that it is consistent with the SCR.
3719 SCR starts at 36000, but the first two packs contain only padding
3720 and the first pack from the other stream, respectively, may also have
3721 been written before.
3722 So the real data starts at SCR 36000+3*1200. */
3723 mux_preload= (36000+3*1200) / 90000.0; //0.44
3724 } else if(!strcmp(arg, "svcd")) {
3726 opt_video_codec("mpeg2video");
3727 opt_audio_codec("mp2");
3730 opt_frame_size(norm ? "480x480" : "480x576");
3731 opt_gop_size(norm ? "18" : "15");
3733 video_bit_rate = 2040000;
3734 video_rc_max_rate = 2516000;
3735 video_rc_min_rate = 0; //1145000;
3736 video_rc_buffer_size = 224*1024*8;
3737 use_scan_offset = 1;
3739 audio_bit_rate = 224000;
3740 audio_sample_rate = 44100;
3742 mux_packet_size= 2324;
3744 } else if(!strcmp(arg, "dvd")) {
3746 opt_video_codec("mpeg2video");
3747 opt_audio_codec("ac3");
3750 opt_frame_size(norm ? "720x480" : "720x576");
3751 opt_gop_size(norm ? "18" : "15");
3753 video_bit_rate = 6000000;
3754 video_rc_max_rate = 9000000;
3755 video_rc_min_rate = 0; //1500000;
3756 video_rc_buffer_size = 224*1024*8;
3758 audio_bit_rate = 448000;
3759 audio_sample_rate = 48000;
3762 fprintf(stderr, "Unknown target: %s\n", arg);
3767 static void show_version(void)
3769 printf("ffmpeg " FFMPEG_VERSION "\n"
3772 avcodec_build(), LIBAVFORMAT_BUILD);
3776 const OptionDef options[] = {
3778 { "L", 0, {(void*)show_license}, "show license" },
3779 { "h", 0, {(void*)show_help}, "show help" },
3780 { "version", 0, {(void*)show_version}, "show version" },
3781 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3782 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3783 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3784 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3785 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3786 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3787 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3788 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3789 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3790 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3791 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3792 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3793 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3794 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3795 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3796 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3797 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3798 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3799 "add timings for benchmarking" },
3800 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3801 "dump each input packet" },
3802 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3803 "when dumping packets, also dump the payload" },
3804 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3805 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3806 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3807 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3808 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3809 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3810 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3811 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3812 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3815 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3816 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3817 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3818 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3819 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3820 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3821 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3822 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3823 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3824 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3825 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3826 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3827 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3828 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3829 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3830 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3831 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3832 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3833 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3834 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3835 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3836 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3837 { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3838 { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3839 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3840 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3841 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3842 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3843 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3844 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3845 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3846 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3847 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3848 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3849 // { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3850 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3851 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3852 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3853 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3854 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3855 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3856 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3857 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3859 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
3860 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
3861 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3862 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
3863 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
3864 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
3865 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3866 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3867 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3868 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3869 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3870 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3871 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3872 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3873 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3874 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3875 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3876 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3877 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
3878 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3879 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3880 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3881 { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3882 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3883 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3884 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3885 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3886 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3887 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3888 "use same video quality as source (implies VBR)" },
3889 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3890 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3891 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3892 "deinterlace pictures" },
3893 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
3894 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3895 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
3896 "force interlaced me support in encoder (MPEG2/MPEG4)" },
3897 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3898 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3899 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3900 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3901 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3902 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3903 { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3904 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3905 { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
3906 { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
3907 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3908 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3909 { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
3910 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3911 { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3912 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3913 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3914 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3915 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3916 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3917 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3918 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3919 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3920 { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3921 { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3922 { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3923 { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
3924 { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
3925 { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
3926 { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
3927 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
3928 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3931 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3932 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3933 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3934 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3935 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3936 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3939 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3940 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3941 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3942 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3944 /* G.2 grab options */
3945 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3946 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3949 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
3950 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
3951 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3952 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3956 static void show_banner(void)
3958 printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
3960 printf(" configuration: %s\n", FFMPEG_CONFIGURATION);
3961 printf(" built on " __DATE__ " " __TIME__);
3963 printf(", gcc: %s\n", __VERSION__);
3965 printf(", using a non-gcc compiler\n");
3969 static void show_license(void)
3974 "This program is free software; you can redistribute it and/or modify\n"
3975 "it under the terms of the GNU General Public License as published by\n"
3976 "the Free Software Foundation; either version 2 of the License, or\n"
3977 "(at your option) any later version.\n"
3979 "This program is distributed in the hope that it will be useful,\n"
3980 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3981 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3982 "GNU General Public License for more details.\n"
3984 "You should have received a copy of the GNU General Public License\n"
3985 "along with this program; if not, write to the Free Software\n"
3986 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
3990 "This library is free software; you can redistribute it and/or\n"
3991 "modify it under the terms of the GNU Lesser General Public\n"
3992 "License as published by the Free Software Foundation; either\n"
3993 "version 2 of the License, or (at your option) any later version.\n"
3995 "This library is distributed in the hope that it will be useful,\n"
3996 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3997 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3998 "Lesser General Public License for more details.\n"
4000 "You should have received a copy of the GNU Lesser General Public\n"
4001 "License along with this library; if not, write to the Free Software\n"
4002 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4008 static void show_help(void)
4011 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4012 "Hyper fast Audio and Video encoder\n");
4014 show_help_options(options, "Main options:\n",
4015 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4016 show_help_options(options, "\nVideo options:\n",
4017 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4019 show_help_options(options, "\nAdvanced Video options:\n",
4020 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4021 OPT_VIDEO | OPT_EXPERT);
4022 show_help_options(options, "\nAudio options:\n",
4023 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4025 show_help_options(options, "\nAdvanced Audio options:\n",
4026 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4027 OPT_AUDIO | OPT_EXPERT);
4028 show_help_options(options, "\nAudio/Video grab options:\n",
4031 show_help_options(options, "\nAdvanced options:\n",
4032 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4037 void parse_arg_file(const char *filename)
4039 opt_output_file(filename);
4042 int main(int argc, char **argv)
4055 parse_options(argc, argv, options);
4057 /* file converter / grab */
4058 if (nb_output_files <= 0) {
4059 fprintf(stderr, "Must supply at least one output file\n");
4063 if (nb_input_files == 0) {
4069 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4070 stream_maps, nb_stream_maps);
4071 ti = getutime() - ti;
4073 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4077 for(i=0;i<nb_output_files;i++) {
4078 /* maybe av_close_output_file ??? */
4079 AVFormatContext *s = output_files[i];
4081 if (!(s->oformat->flags & AVFMT_NOFILE))
4083 for(j=0;j<s->nb_streams;j++)
4084 av_free(s->streams[j]);
4087 for(i=0;i<nb_input_files;i++)
4088 av_close_input_file(input_files[i]);
4093 av_free(intra_matrix);
4095 av_free(inter_matrix);
4097 #ifdef POWERPC_PERFORMANCE_REPORT
4098 extern void powerpc_display_perf_report(void);
4099 powerpc_display_perf_report();
4100 #endif /* POWERPC_PERFORMANCE_REPORT */
4102 #ifndef CONFIG_WIN32
4103 if (received_sigterm) {
4105 "Received signal %d: terminating.\n",
4106 (int) received_sigterm);
4110 exit(0); /* not all OS-es handle main() return value */