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 same_quality = 0;
137 static int b_frames = 0;
138 static int mb_decision = FF_MB_DECISION_SIMPLE;
139 static int ildct_cmp = FF_CMP_VSAD;
140 static int mb_cmp = FF_CMP_SAD;
141 static int sub_cmp = FF_CMP_SAD;
142 static int cmp = FF_CMP_SAD;
143 static int pre_cmp = FF_CMP_SAD;
144 static int pre_me = 0;
145 static float lumi_mask = 0;
146 static float dark_mask = 0;
147 static float scplx_mask = 0;
148 static float tcplx_mask = 0;
149 static float p_mask = 0;
150 static int use_4mv = 0;
151 static int use_obmc = 0;
152 static int use_loop = 0;
153 static int use_aic = 0;
154 static int use_aiv = 0;
155 static int use_umv = 0;
156 static int use_ss = 0;
157 static int use_alt_scan = 0;
158 static int use_trell = 0;
159 static int use_scan_offset = 0;
160 static int use_qpel = 0;
161 static int use_qprd = 0;
162 static int use_cbprd = 0;
164 static int closed_gop = 0;
165 static int do_deinterlace = 0;
166 static int do_interlace_dct = 0;
167 static int do_interlace_me = 0;
168 static int workaround_bugs = FF_BUG_AUTODETECT;
169 static int error_resilience = 2;
170 static int error_concealment = 3;
171 static int dct_algo = 0;
172 static int idct_algo = 0;
173 static int use_part = 0;
174 static int packet_size = 0;
175 static int error_rate = 0;
176 static int strict = 0;
177 static int top_field_first = -1;
178 static int noise_reduction = 0;
179 static int sc_threshold = 0;
180 static int debug = 0;
181 static int debug_mv = 0;
182 static int me_threshold = 0;
183 static int mb_threshold = 0;
184 static int intra_dc_precision = 8;
185 static int coder = 0;
186 static int context = 0;
187 static int predictor = 0;
188 static int video_profile = FF_PROFILE_UNKNOWN;
189 static int video_level = FF_LEVEL_UNKNOWN;
190 static int nsse_weight = 8;
191 static int subpel_quality= 8;
192 static int lowres= 0;
193 extern int loop_input; /* currently a hack */
195 static int gop_size = 12;
196 static int intra_only = 0;
197 static int audio_sample_rate = 44100;
198 static int audio_bit_rate = 64000;
199 static int audio_disable = 0;
200 static int audio_channels = 1;
201 static int audio_codec_id = CODEC_ID_NONE;
203 static int mux_rate= 0;
204 static int mux_packet_size= 0;
206 static int64_t recording_time = 0;
207 static int64_t start_time = 0;
208 static int64_t rec_timestamp = 0;
209 static int64_t input_ts_offset = 0;
210 static int file_overwrite = 0;
211 static char *str_title = NULL;
212 static char *str_author = NULL;
213 static char *str_copyright = NULL;
214 static char *str_comment = NULL;
215 static int do_benchmark = 0;
216 static int do_hex_dump = 0;
217 static int do_pkt_dump = 0;
218 static int do_psnr = 0;
219 static int do_vstats = 0;
220 static int do_pass = 0;
221 static int bitexact = 0;
222 static char *pass_logfilename = NULL;
223 static int audio_stream_copy = 0;
224 static int video_stream_copy = 0;
225 static int video_sync_method= 1;
226 static int audio_sync_method= 0;
227 static int copy_ts= 0;
229 static int rate_emu = 0;
231 static char *video_grab_format = "video4linux";
232 static char *video_device = NULL;
233 static int video_channel = 0;
234 static char *video_standard = "ntsc";
236 static char *audio_grab_format = "audio_device";
237 static char *audio_device = NULL;
239 static int using_stdin = 0;
240 static int using_vhook = 0;
241 static int verbose = 1;
242 static int thread_count= 1;
243 static int q_pressed = 0;
244 static int me_range = 0;
245 static int64_t video_size = 0;
246 static int64_t audio_size = 0;
247 static int64_t extra_size = 0;
248 static int nb_frames_dup = 0;
249 static int nb_frames_drop = 0;
250 static int input_sync;
252 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
254 typedef struct AVOutputStream {
255 int file_index; /* file index */
256 int index; /* stream index in the output file */
257 int source_index; /* AVInputStream index */
258 AVStream *st; /* stream in the output file */
259 int encoding_needed; /* true if encoding needed for this stream */
261 /* input pts and corresponding output pts
263 double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
264 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
266 int video_resample; /* video_resample and video_crop are mutually exclusive */
267 AVFrame pict_tmp; /* temporary image for resampling */
268 ImgReSampleContext *img_resample_ctx; /* for image resampling */
270 int video_crop; /* video_resample and video_crop are mutually exclusive */
271 int topBand; /* cropping area sizes */
274 int video_pad; /* video_resample and video_pad are mutually exclusive */
275 int padtop; /* padding area sizes */
282 ReSampleContext *resample; /* for audio resampling */
283 FifoBuffer fifo; /* for compression: one audio fifo per codec */
287 typedef struct AVInputStream {
291 int discard; /* true if stream data should be discarded */
292 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
293 int64_t sample_index; /* current sample */
295 int64_t start; /* time when read started */
296 unsigned long frame; /* current frame */
297 int64_t next_pts; /* synthetic pts for cases where pkt.pts
299 int64_t pts; /* current pts */
300 int is_start; /* is 1 at the start and after a discontinuity */
303 typedef struct AVInputFile {
304 int eof_reached; /* true if eof reached */
305 int ist_index; /* index of first stream in ist_table */
306 int buffer_size; /* current total buffer size */
307 int buffer_size_max; /* buffer size at which we consider we can stop
309 int nb_streams; /* nb streams we are aware of */
314 /* init terminal so that we can grab keys */
315 static struct termios oldtty;
317 static void term_exit(void)
319 tcsetattr (0, TCSANOW, &oldtty);
322 static volatile sig_atomic_t received_sigterm = 0;
325 sigterm_handler(int sig)
327 received_sigterm = sig;
331 static void term_init(void)
338 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
339 |INLCR|IGNCR|ICRNL|IXON);
340 tty.c_oflag |= OPOST;
341 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
342 tty.c_cflag &= ~(CSIZE|PARENB);
347 tcsetattr (0, TCSANOW, &tty);
349 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
350 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
351 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
353 register a function to be called at normal program termination
356 #ifdef CONFIG_BEOS_NETSERVER
357 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
361 /* read a key without blocking */
362 static int read_key(void)
366 #ifndef CONFIG_BEOS_NETSERVER
374 n = select(1, &rfds, NULL, NULL, &tv);
386 static int decode_interrupt_cb(void)
388 return q_pressed || (q_pressed = read_key() == 'q');
393 static volatile int received_sigterm = 0;
395 /* no interactive support */
396 static void term_exit(void)
400 static void term_init(void)
404 static int read_key(void)
411 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
416 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
419 /* copy stream format */
420 s->nb_streams = ic->nb_streams;
421 for(i=0;i<ic->nb_streams;i++) {
424 st = av_mallocz(sizeof(AVStream));
425 memcpy(st, ic->streams[i], sizeof(AVStream));
429 av_close_input_file(ic);
433 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
435 static void do_audio_out(AVFormatContext *s,
438 unsigned char *buf, int size)
441 static uint8_t *audio_buf = NULL;
442 static uint8_t *audio_out = NULL;
443 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
445 int size_out, frame_bytes, ret;
446 AVCodecContext *enc= &ost->st->codec;
448 /* SC: dynamic allocation of buffers */
450 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
452 audio_out = av_malloc(audio_out_size);
453 if (!audio_buf || !audio_out)
454 return; /* Should signal an error ! */
456 if(audio_sync_method){
457 double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts
458 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
459 double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
460 int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
462 //FIXME resample delay
463 if(fabs(delta) > 50){
466 byte_delta= FFMAX(byte_delta, -size);
470 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
475 static uint8_t *input_tmp= NULL;
476 input_tmp= av_realloc(input_tmp, byte_delta + size);
478 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
481 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
483 memset(input_tmp, 0, byte_delta);
484 memcpy(input_tmp + byte_delta, buf, size);
488 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
490 }else if(audio_sync_method>1){
491 int comp= clip(delta, -audio_sync_method, audio_sync_method);
492 assert(ost->audio_resample);
494 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
495 // 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));
496 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
500 ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
501 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
503 if (ost->audio_resample) {
505 size_out = audio_resample(ost->resample,
506 (short *)buftmp, (short *)buf,
507 size / (ist->st->codec.channels * 2));
508 size_out = size_out * enc->channels * 2;
514 /* now encode as many frames as possible */
515 if (enc->frame_size > 1) {
516 /* output resampled raw samples */
517 fifo_write(&ost->fifo, buftmp, size_out,
520 frame_bytes = enc->frame_size * 2 * enc->channels;
522 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
523 &ost->fifo.rptr) == 0) {
525 av_init_packet(&pkt);
527 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
530 pkt.stream_index= ost->index;
534 pkt.pts= enc->coded_frame->pts;
535 pkt.flags |= PKT_FLAG_KEY;
536 av_interleaved_write_frame(s, &pkt);
538 ost->sync_opts += enc->frame_size;
542 av_init_packet(&pkt);
544 ost->sync_opts += size_out / (2 * enc->channels);
546 /* output a pcm frame */
547 /* XXX: change encoding codec API to avoid this ? */
548 switch(enc->codec->id) {
549 case CODEC_ID_PCM_S16LE:
550 case CODEC_ID_PCM_S16BE:
551 case CODEC_ID_PCM_U16LE:
552 case CODEC_ID_PCM_U16BE:
555 size_out = size_out >> 1;
558 ret = avcodec_encode_audio(enc, audio_out, size_out,
561 pkt.stream_index= ost->index;
565 pkt.pts= enc->coded_frame->pts;
566 pkt.flags |= PKT_FLAG_KEY;
567 av_interleaved_write_frame(s, &pkt);
571 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
575 AVPicture picture_tmp;
578 dec = &ist->st->codec;
580 /* deinterlace : must be done before any resize */
581 if (do_deinterlace || using_vhook) {
584 /* create temporary picture */
585 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
586 buf = av_malloc(size);
590 picture2 = &picture_tmp;
591 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
594 if(avpicture_deinterlace(picture2, picture,
595 dec->pix_fmt, dec->width, dec->height) < 0) {
596 /* if error, do not deinterlace */
602 if (img_convert(picture2, dec->pix_fmt, picture,
603 dec->pix_fmt, dec->width, dec->height) < 0) {
604 /* if error, do not copy */
614 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
616 if (picture != picture2)
617 *picture = *picture2;
621 /* we begin to correct av delay at this threshold */
622 #define AV_DELAY_MAX 0.100
625 /* Expects img to be yuv420 */
626 static void fill_pad_region(AVPicture* img, int height, int width,
627 int padtop, int padbottom, int padleft, int padright, int *color) {
632 for (i = 0; i < 3; i++) {
633 shift = (i == 0) ? 0 : 1;
635 if (padtop || padleft) {
636 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
640 if (padleft || padright) {
641 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
642 (img->linesize[i] - (padright >> shift));
644 for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
645 memset(optr, color[i], (padleft + padright) >> shift);
646 optr += img->linesize[i];
651 optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
652 memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
657 static uint8_t *bit_buffer= NULL;
659 static void do_video_out(AVFormatContext *s,
665 int nb_frames, i, ret;
666 AVFrame *final_picture, *formatted_picture;
667 AVFrame picture_format_temp, picture_crop_temp;
668 uint8_t *buf = NULL, *buf1 = NULL;
669 AVCodecContext *enc, *dec;
670 enum PixelFormat target_pixfmt;
672 #define VIDEO_BUFFER_SIZE (1024*1024)
674 avcodec_get_frame_defaults(&picture_format_temp);
675 avcodec_get_frame_defaults(&picture_crop_temp);
677 enc = &ost->st->codec;
678 dec = &ist->st->codec;
680 /* by default, we output a single frame */
685 if(video_sync_method){
687 vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
688 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
691 else if (vdelta > 1.1)
692 nb_frames = lrintf(vdelta - 1.1 + 0.5);
693 //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);
697 fprintf(stderr, "*** drop!\n");
698 }else if (nb_frames > 1) {
699 nb_frames_dup += nb_frames;
701 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
704 ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
709 /* convert pixel format if needed */
710 target_pixfmt = ost->video_resample || ost->video_pad
711 ? PIX_FMT_YUV420P : enc->pix_fmt;
712 if (dec->pix_fmt != target_pixfmt) {
715 /* create temporary picture */
716 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
717 buf = av_malloc(size);
720 formatted_picture = &picture_format_temp;
721 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
723 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
724 (AVPicture *)in_picture, dec->pix_fmt,
725 dec->width, dec->height) < 0) {
728 fprintf(stderr, "pixel format conversion not handled\n");
733 formatted_picture = in_picture;
736 /* XXX: resampling could be done before raw format conversion in
737 some cases to go faster */
738 /* XXX: only works for YUV420P */
739 if (ost->video_resample) {
740 final_picture = &ost->pict_tmp;
741 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
743 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
744 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
745 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
749 if (enc->pix_fmt != PIX_FMT_YUV420P) {
753 /* create temporary picture */
754 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
755 buf = av_malloc(size);
758 final_picture = &picture_format_temp;
759 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
761 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
762 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
763 enc->width, enc->height) < 0) {
766 fprintf(stderr, "pixel format conversion not handled\n");
771 } else if (ost->video_crop) {
772 picture_crop_temp.data[0] = formatted_picture->data[0] +
773 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
775 picture_crop_temp.data[1] = formatted_picture->data[1] +
776 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
777 (ost->leftBand >> 1);
779 picture_crop_temp.data[2] = formatted_picture->data[2] +
780 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
781 (ost->leftBand >> 1);
783 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
784 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
785 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
786 final_picture = &picture_crop_temp;
787 } else if (ost->video_pad) {
788 final_picture = &ost->pict_tmp;
790 for (i = 0; i < 3; i++) {
791 uint8_t *optr, *iptr;
792 int shift = (i == 0) ? 0 : 1;
795 /* set offset to start writing image into */
796 optr = final_picture->data[i] + (((final_picture->linesize[i] *
797 ost->padtop) + ost->padleft) >> shift);
798 iptr = formatted_picture->data[i];
800 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
801 for (y = 0; y < yheight; y++) {
802 /* copy unpadded image row into padded image row */
803 memcpy(optr, iptr, formatted_picture->linesize[i]);
804 optr += final_picture->linesize[i];
805 iptr += formatted_picture->linesize[i];
809 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
810 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
813 if (enc->pix_fmt != PIX_FMT_YUV420P) {
817 /* create temporary picture */
818 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
819 buf = av_malloc(size);
822 final_picture = &picture_format_temp;
823 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
825 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
826 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
827 enc->width, enc->height) < 0) {
830 fprintf(stderr, "pixel format conversion not handled\n");
836 final_picture = formatted_picture;
838 /* duplicates frame if needed */
839 for(i=0;i<nb_frames;i++) {
841 av_init_packet(&pkt);
842 pkt.stream_index= ost->index;
844 if (s->oformat->flags & AVFMT_RAWPICTURE) {
845 /* raw pictures are written as AVPicture structure to
846 avoid any copies. We support temorarily the older
848 AVFrame* old_frame = enc->coded_frame;
849 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
850 pkt.data= (uint8_t *)final_picture;
851 pkt.size= sizeof(AVPicture);
853 pkt.pts= dec->coded_frame->pts;
854 if(dec->coded_frame && dec->coded_frame->key_frame)
855 pkt.flags |= PKT_FLAG_KEY;
857 av_interleaved_write_frame(s, &pkt);
858 enc->coded_frame = old_frame;
862 big_picture= *final_picture;
863 /* better than nothing: use input picture interlaced
865 big_picture.interlaced_frame = in_picture->interlaced_frame;
866 if(do_interlace_me || do_interlace_dct){
867 if(top_field_first == -1)
868 big_picture.top_field_first = in_picture->top_field_first;
870 big_picture.top_field_first = top_field_first;
873 /* handles sameq here. This is not correct because it may
874 not be a global option */
876 big_picture.quality = ist->st->quality;
878 big_picture.quality = ost->st->quality;
880 big_picture.pict_type = 0;
881 // big_picture.pts = AV_NOPTS_VALUE;
882 big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
883 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
884 ret = avcodec_encode_video(enc,
885 bit_buffer, VIDEO_BUFFER_SIZE,
887 //enc->frame_number = enc->real_pict_num;
889 pkt.data= bit_buffer;
892 pkt.pts= enc->coded_frame->pts;
893 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
894 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
895 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
897 if(enc->coded_frame && enc->coded_frame->key_frame)
898 pkt.flags |= PKT_FLAG_KEY;
899 av_interleaved_write_frame(s, &pkt);
901 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
902 // enc->frame_number-1, enc->real_pict_num, ret,
904 /* if two pass, output log */
905 if (ost->logfile && enc->stats_out) {
906 fprintf(ost->logfile, "%s", enc->stats_out);
918 static double psnr(double d){
919 if(d==0) return INFINITY;
920 return -10.0*log(d)/log(10.0);
923 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
926 static FILE *fvstats=NULL;
933 double ti1, bitrate, avg_bitrate;
937 today = localtime(&today2);
938 sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
941 fvstats = fopen(filename,"w");
949 enc = &ost->st->codec;
950 if (enc->codec_type == CODEC_TYPE_VIDEO) {
951 frame_number = ost->frame_number;
952 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
953 if (enc->flags&CODEC_FLAG_PSNR)
954 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
956 fprintf(fvstats,"f_size= %6d ", frame_size);
957 /* compute pts value */
958 ti1 = (double)ost->sync_opts *enc->frame_rate_base / enc->frame_rate;
962 bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
963 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
964 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
965 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
966 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
970 static void print_report(AVFormatContext **output_files,
971 AVOutputStream **ost_table, int nb_ostreams,
976 AVFormatContext *oc, *os;
979 int frame_number, vid, i;
980 double bitrate, ti1, pts;
981 static int64_t last_time = -1;
983 if (!is_last_report) {
985 /* display the report every 0.5 seconds */
986 cur_time = av_gettime();
987 if (last_time == -1) {
988 last_time = cur_time;
991 if ((cur_time - last_time) < 500000)
993 last_time = cur_time;
997 oc = output_files[0];
999 total_size = url_ftell(&oc->pb);
1004 for(i=0;i<nb_ostreams;i++) {
1006 os = output_files[ost->file_index];
1007 enc = &ost->st->codec;
1008 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1009 sprintf(buf + strlen(buf), "q=%2.1f ",
1010 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1012 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1013 frame_number = ost->frame_number;
1014 sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
1015 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1017 sprintf(buf + strlen(buf), "L");
1018 if (enc->flags&CODEC_FLAG_PSNR){
1020 double error, error_sum=0;
1021 double scale, scale_sum=0;
1022 char type[3]= {'Y','U','V'};
1023 sprintf(buf + strlen(buf), "PSNR=");
1026 error= enc->error[j];
1027 scale= enc->width*enc->height*255.0*255.0*frame_number;
1029 error= enc->coded_frame->error[j];
1030 scale= enc->width*enc->height*255.0*255.0;
1035 sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1037 sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1041 /* compute min output value */
1042 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1043 if ((pts < ti1) && (pts > 0))
1049 if (verbose || is_last_report) {
1050 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1052 sprintf(buf + strlen(buf),
1053 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1054 (double)total_size / 1024, ti1, bitrate);
1057 sprintf(buf + strlen(buf), " dup=%d drop=%d",
1058 nb_frames_dup, nb_frames_drop);
1061 fprintf(stderr, "%s \r", buf);
1066 if (is_last_report && verbose >= 0){
1067 int64_t raw= audio_size + video_size + extra_size;
1068 fprintf(stderr, "\n");
1069 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1073 100.0*(total_size - raw)/raw
1078 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1079 static int output_packet(AVInputStream *ist, int ist_index,
1080 AVOutputStream **ost_table, int nb_ostreams,
1081 const AVPacket *pkt)
1083 AVFormatContext *os;
1084 AVOutputStream *ost;
1088 int data_size, got_picture;
1090 void *buffer_to_free;
1091 static int samples_size= 0;
1092 static short *samples= NULL;
1095 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1096 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1097 ist->next_pts = ist->pts = pkt->dts;
1099 assert(ist->pts == ist->next_pts);
1113 /* decode the packet if needed */
1114 data_buf = NULL; /* fail safe */
1116 if (ist->decoding_needed) {
1117 switch(ist->st->codec.codec_type) {
1118 case CODEC_TYPE_AUDIO:{
1120 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1121 /* XXX: could avoid copy if PCM 16 bits with same
1122 endianness as CPU */
1123 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1129 /* Some bug in mpeg audio decoder gives */
1130 /* data_size < 0, it seems they are overflows */
1131 if (data_size <= 0) {
1132 /* no audio frame */
1135 data_buf = (uint8_t *)samples;
1136 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1137 (ist->st->codec.sample_rate * ist->st->codec.channels);
1139 case CODEC_TYPE_VIDEO:
1140 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1141 /* XXX: allocate picture correctly */
1142 avcodec_get_frame_defaults(&picture);
1144 ret = avcodec_decode_video(&ist->st->codec,
1145 &picture, &got_picture, ptr, len);
1146 ist->st->quality= picture.quality;
1150 /* no picture yet */
1151 goto discard_packet;
1153 if (ist->st->codec.frame_rate_base != 0) {
1154 ist->next_pts += ((int64_t)AV_TIME_BASE *
1155 ist->st->codec.frame_rate_base) /
1156 ist->st->codec.frame_rate;
1170 buffer_to_free = NULL;
1171 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1172 pre_process_video_frame(ist, (AVPicture *)&picture,
1176 /* frame rate emulation */
1177 if (ist->st->codec.rate_emu) {
1178 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1179 int64_t now = av_gettime() - ist->start;
1187 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1188 is the one of the next displayed one */
1189 /* XXX: add mpeg4 too ? */
1190 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1191 if (ist->st->codec.pict_type != B_TYPE) {
1193 tmp = ist->last_ip_pts;
1194 ist->last_ip_pts = ist->frac_pts.val;
1195 ist->frac_pts.val = tmp;
1199 /* if output time reached then transcode raw format,
1200 encode packets and output them */
1201 if (start_time == 0 || ist->pts >= start_time)
1202 for(i=0;i<nb_ostreams;i++) {
1206 if (ost->source_index == ist_index) {
1207 os = output_files[ost->file_index];
1210 printf("%d: got pts=%0.3f %0.3f\n", i,
1211 (double)pkt->pts / AV_TIME_BASE,
1212 ((double)ist->pts / AV_TIME_BASE) -
1213 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1215 /* set the input output pts pairs */
1216 ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1218 if (ost->encoding_needed) {
1219 switch(ost->st->codec.codec_type) {
1220 case CODEC_TYPE_AUDIO:
1221 do_audio_out(os, ost, ist, data_buf, data_size);
1223 case CODEC_TYPE_VIDEO:
1224 do_video_out(os, ost, ist, &picture, &frame_size);
1225 video_size += frame_size;
1226 if (do_vstats && frame_size)
1227 do_video_stats(os, ost, frame_size);
1233 AVFrame avframe; //FIXME/XXX remove this
1235 av_init_packet(&opkt);
1237 /* no reencoding needed : output the packet directly */
1238 /* force the input stream PTS */
1240 avcodec_get_frame_defaults(&avframe);
1241 ost->st->codec.coded_frame= &avframe;
1242 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1244 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1245 audio_size += data_size;
1246 else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1247 video_size += data_size;
1249 opkt.stream_index= ost->index;
1250 opkt.data= data_buf;
1251 opkt.size= data_size;
1252 if(pkt->pts != AV_NOPTS_VALUE)
1253 opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1255 opkt.pts= AV_NOPTS_VALUE;
1256 opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1257 opkt.flags= pkt->flags;
1259 av_interleaved_write_frame(os, &opkt);
1260 ost->st->codec.frame_number++;
1261 ost->frame_number++;
1265 av_free(buffer_to_free);
1271 for(i=0;i<nb_ostreams;i++) {
1273 if (ost->source_index == ist_index) {
1274 AVCodecContext *enc= &ost->st->codec;
1275 os = output_files[ost->file_index];
1277 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1279 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1282 if (ost->encoding_needed) {
1285 av_init_packet(&pkt);
1286 pkt.stream_index= ost->index;
1288 switch(ost->st->codec.codec_type) {
1289 case CODEC_TYPE_AUDIO:
1290 ret = avcodec_encode_audio(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1292 pkt.flags |= PKT_FLAG_KEY;
1294 case CODEC_TYPE_VIDEO:
1295 ret = avcodec_encode_video(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1297 if(enc->coded_frame && enc->coded_frame->key_frame)
1298 pkt.flags |= PKT_FLAG_KEY;
1299 if (ost->logfile && enc->stats_out) {
1300 fprintf(ost->logfile, "%s", enc->stats_out);
1309 pkt.data= bit_buffer;
1311 if(enc->coded_frame)
1312 pkt.pts= enc->coded_frame->pts;
1313 av_interleaved_write_frame(os, &pkt);
1327 * The following code is the main loop of the file converter
1329 static int av_encode(AVFormatContext **output_files,
1330 int nb_output_files,
1331 AVFormatContext **input_files,
1333 AVStreamMap *stream_maps, int nb_stream_maps)
1335 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1336 AVFormatContext *is, *os;
1337 AVCodecContext *codec, *icodec;
1338 AVOutputStream *ost, **ost_table = NULL;
1339 AVInputStream *ist, **ist_table = NULL;
1340 AVInputFile *file_table;
1341 AVFormatContext *stream_no_data;
1344 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1349 bit_buffer = av_malloc(VIDEO_BUFFER_SIZE);
1353 /* input stream init */
1355 for(i=0;i<nb_input_files;i++) {
1356 is = input_files[i];
1357 file_table[i].ist_index = j;
1358 file_table[i].nb_streams = is->nb_streams;
1359 j += is->nb_streams;
1363 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1367 for(i=0;i<nb_istreams;i++) {
1368 ist = av_mallocz(sizeof(AVInputStream));
1374 for(i=0;i<nb_input_files;i++) {
1375 is = input_files[i];
1376 for(k=0;k<is->nb_streams;k++) {
1377 ist = ist_table[j++];
1378 ist->st = is->streams[k];
1379 ist->file_index = i;
1381 ist->discard = 1; /* the stream is discarded by default
1384 if (ist->st->codec.rate_emu) {
1385 ist->start = av_gettime();
1391 /* output stream init */
1393 for(i=0;i<nb_output_files;i++) {
1394 os = output_files[i];
1395 nb_ostreams += os->nb_streams;
1397 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1398 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1402 /* Sanity check the mapping args -- do the input files & streams exist? */
1403 for(i=0;i<nb_stream_maps;i++) {
1404 int fi = stream_maps[i].file_index;
1405 int si = stream_maps[i].stream_index;
1407 if (fi < 0 || fi > nb_input_files - 1 ||
1408 si < 0 || si > file_table[fi].nb_streams - 1) {
1409 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1414 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1417 for(i=0;i<nb_ostreams;i++) {
1418 ost = av_mallocz(sizeof(AVOutputStream));
1425 for(k=0;k<nb_output_files;k++) {
1426 os = output_files[k];
1427 for(i=0;i<os->nb_streams;i++) {
1429 ost = ost_table[n++];
1430 ost->file_index = k;
1432 ost->st = os->streams[i];
1433 if (nb_stream_maps > 0) {
1434 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1435 stream_maps[n-1].stream_index;
1437 /* Sanity check that the stream types match */
1438 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1439 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1440 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1441 ost->file_index, ost->index);
1446 /* get corresponding input stream index : we select the first one with the right type */
1448 for(j=0;j<nb_istreams;j++) {
1451 ist->st->codec.codec_type == ost->st->codec.codec_type) {
1452 ost->source_index = j;
1459 /* try again and reuse existing stream */
1460 for(j=0;j<nb_istreams;j++) {
1462 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1463 ost->source_index = j;
1468 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1469 ost->file_index, ost->index);
1474 ist = ist_table[ost->source_index];
1479 /* for each output stream, we compute the right encoding parameters */
1480 for(i=0;i<nb_ostreams;i++) {
1482 ist = ist_table[ost->source_index];
1484 codec = &ost->st->codec;
1485 icodec = &ist->st->codec;
1487 if (ost->st->stream_copy) {
1488 /* if stream_copy is selected, no need to decode or encode */
1489 codec->codec_id = icodec->codec_id;
1490 codec->codec_type = icodec->codec_type;
1491 codec->codec_tag = icodec->codec_tag;
1492 codec->bit_rate = icodec->bit_rate;
1493 switch(codec->codec_type) {
1494 case CODEC_TYPE_AUDIO:
1495 codec->sample_rate = icodec->sample_rate;
1496 codec->channels = icodec->channels;
1497 codec->frame_size = icodec->frame_size;
1499 case CODEC_TYPE_VIDEO:
1500 codec->frame_rate = icodec->frame_rate;
1501 codec->frame_rate_base = icodec->frame_rate_base;
1502 codec->width = icodec->width;
1503 codec->height = icodec->height;
1509 switch(codec->codec_type) {
1510 case CODEC_TYPE_AUDIO:
1511 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1514 if (codec->channels == icodec->channels &&
1515 codec->sample_rate == icodec->sample_rate) {
1516 ost->audio_resample = 0;
1518 if (codec->channels != icodec->channels &&
1519 (icodec->codec_id == CODEC_ID_AC3 ||
1520 icodec->codec_id == CODEC_ID_DTS)) {
1521 /* Special case for 5:1 AC3 and DTS input */
1522 /* and mono or stereo output */
1523 /* Request specific number of channels */
1524 icodec->channels = codec->channels;
1525 if (codec->sample_rate == icodec->sample_rate)
1526 ost->audio_resample = 0;
1528 ost->audio_resample = 1;
1531 ost->audio_resample = 1;
1534 if(audio_sync_method>1)
1535 ost->audio_resample = 1;
1537 if(ost->audio_resample){
1538 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1539 codec->sample_rate, icodec->sample_rate);
1541 printf("Can't resample. Aborting.\n");
1545 ist->decoding_needed = 1;
1546 ost->encoding_needed = 1;
1548 case CODEC_TYPE_VIDEO:
1549 if (codec->width == icodec->width &&
1550 codec->height == icodec->height &&
1551 frame_topBand == 0 &&
1552 frame_bottomBand == 0 &&
1553 frame_leftBand == 0 &&
1554 frame_rightBand == 0 &&
1555 frame_padtop == 0 &&
1556 frame_padbottom == 0 &&
1557 frame_padleft == 0 &&
1558 frame_padright == 0)
1560 ost->video_resample = 0;
1561 ost->video_crop = 0;
1563 } else if ((codec->width == icodec->width -
1564 (frame_leftBand + frame_rightBand)) &&
1565 (codec->height == icodec->height -
1566 (frame_topBand + frame_bottomBand)))
1568 ost->video_resample = 0;
1569 ost->video_crop = 1;
1570 ost->topBand = frame_topBand;
1571 ost->leftBand = frame_leftBand;
1572 } else if ((codec->width == icodec->width +
1573 (frame_padleft + frame_padright)) &&
1574 (codec->height == icodec->height +
1575 (frame_padtop + frame_padbottom))) {
1576 ost->video_resample = 0;
1577 ost->video_crop = 0;
1579 ost->padtop = frame_padtop;
1580 ost->padleft = frame_padleft;
1581 ost->padbottom = frame_padbottom;
1582 ost->padright = frame_padright;
1583 avcodec_get_frame_defaults(&ost->pict_tmp);
1584 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1585 codec->width, codec->height ) )
1588 ost->video_resample = 1;
1589 ost->video_crop = 0; // cropping is handled as part of resample
1590 avcodec_get_frame_defaults(&ost->pict_tmp);
1591 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1592 codec->width, codec->height ) )
1595 ost->img_resample_ctx = img_resample_full_init(
1596 ost->st->codec.width, ost->st->codec.height,
1597 ist->st->codec.width, ist->st->codec.height,
1598 frame_topBand, frame_bottomBand,
1599 frame_leftBand, frame_rightBand,
1600 frame_padtop, frame_padbottom,
1601 frame_padleft, frame_padright);
1603 ost->padtop = frame_padtop;
1604 ost->padleft = frame_padleft;
1605 ost->padbottom = frame_padbottom;
1606 ost->padright = frame_padright;
1609 ost->encoding_needed = 1;
1610 ist->decoding_needed = 1;
1616 if (ost->encoding_needed &&
1617 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1618 char logfilename[1024];
1623 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1625 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1626 if (codec->flags & CODEC_FLAG_PASS1) {
1627 f = fopen(logfilename, "w");
1629 perror(logfilename);
1634 /* read the log file */
1635 f = fopen(logfilename, "r");
1637 perror(logfilename);
1640 fseek(f, 0, SEEK_END);
1642 fseek(f, 0, SEEK_SET);
1643 logbuffer = av_malloc(size + 1);
1645 fprintf(stderr, "Could not allocate log buffer\n");
1648 size = fread(logbuffer, 1, size, f);
1650 logbuffer[size] = '\0';
1651 codec->stats_in = logbuffer;
1657 /* dump the file output parameters - cannot be done before in case
1659 for(i=0;i<nb_output_files;i++) {
1660 dump_format(output_files[i], i, output_files[i]->filename, 1);
1663 /* dump the stream mapping */
1665 fprintf(stderr, "Stream mapping:\n");
1666 for(i=0;i<nb_ostreams;i++) {
1668 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
1669 ist_table[ost->source_index]->file_index,
1670 ist_table[ost->source_index]->index,
1676 /* open each encoder */
1677 for(i=0;i<nb_ostreams;i++) {
1679 if (ost->encoding_needed) {
1681 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1683 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1684 ost->file_index, ost->index);
1687 if (avcodec_open(&ost->st->codec, codec) < 0) {
1688 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1689 ost->file_index, ost->index);
1692 extra_size += ost->st->codec.extradata_size;
1696 /* open each decoder */
1697 for(i=0;i<nb_istreams;i++) {
1699 if (ist->decoding_needed) {
1701 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1703 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1704 ist->st->codec.codec_id, ist->file_index, ist->index);
1707 if (avcodec_open(&ist->st->codec, codec) < 0) {
1708 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1709 ist->file_index, ist->index);
1712 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1713 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1718 for(i=0;i<nb_istreams;i++) {
1720 is = input_files[ist->file_index];
1722 ist->next_pts = ist->st->start_time;
1723 if(ist->next_pts == AV_NOPTS_VALUE)
1728 /* compute buffer size max (should use a complete heuristic) */
1729 for(i=0;i<nb_input_files;i++) {
1730 file_table[i].buffer_size_max = 2048;
1733 /* set meta data information from input file if required */
1734 for (i=0;i<nb_meta_data_maps;i++) {
1735 AVFormatContext *out_file;
1736 AVFormatContext *in_file;
1738 int out_file_index = meta_data_maps[i].out_file;
1739 int in_file_index = meta_data_maps[i].in_file;
1740 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1741 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1745 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1746 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1751 out_file = output_files[out_file_index];
1752 in_file = input_files[in_file_index];
1754 strcpy(out_file->title, in_file->title);
1755 strcpy(out_file->author, in_file->author);
1756 strcpy(out_file->copyright, in_file->copyright);
1757 strcpy(out_file->comment, in_file->comment);
1758 strcpy(out_file->album, in_file->album);
1759 out_file->year = in_file->year;
1760 out_file->track = in_file->track;
1761 strcpy(out_file->genre, in_file->genre);
1764 /* open files and write file headers */
1765 for(i=0;i<nb_output_files;i++) {
1766 os = output_files[i];
1767 if (av_write_header(os) < 0) {
1768 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1774 #ifndef CONFIG_WIN32
1775 if ( !using_stdin && verbose >= 0) {
1776 fprintf(stderr, "Press [q] to stop encoding\n");
1777 url_set_interrupt_cb(decode_interrupt_cb);
1785 for(; received_sigterm == 0;) {
1786 int file_index, ist_index;
1794 /* if 'q' pressed, exits */
1798 /* read_key() returns 0 on EOF */
1804 /* select the stream that we must read now by looking at the
1805 smallest output pts */
1807 for(i=0;i<nb_ostreams;i++) {
1810 os = output_files[ost->file_index];
1811 ist = ist_table[ost->source_index];
1812 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1813 opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1815 opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1816 ipts = (double)ist->pts;
1817 if (!file_table[ist->file_index].eof_reached){
1818 if(ipts < ipts_min) {
1820 if(input_sync ) file_index = ist->file_index;
1822 if(opts < opts_min) {
1824 if(!input_sync) file_index = ist->file_index;
1828 /* if none, if is finished */
1829 if (file_index < 0) {
1833 /* finish if recording time exhausted */
1834 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1837 /* read a frame from it and output it in the fifo */
1838 is = input_files[file_index];
1839 if (av_read_frame(is, &pkt) < 0) {
1840 file_table[file_index].eof_reached = 1;
1845 stream_no_data = is;
1850 av_pkt_dump(stdout, &pkt, do_hex_dump);
1852 /* the following test is needed in case new streams appear
1853 dynamically in stream : we ignore them */
1854 if (pkt.stream_index >= file_table[file_index].nb_streams)
1855 goto discard_packet;
1856 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1857 ist = ist_table[ist_index];
1859 goto discard_packet;
1861 // 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);
1862 if (pkt.dts != AV_NOPTS_VALUE) {
1863 int64_t delta= pkt.dts - ist->next_pts;
1864 if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1865 input_files_ts_offset[ist->file_index]-= delta;
1867 fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1868 for(i=0; i<file_table[file_index].nb_streams; i++){
1869 int index= file_table[file_index].ist_index + i;
1870 ist_table[index]->next_pts += delta;
1871 ist_table[index]->is_start=1;
1876 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1877 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1880 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1881 ist->file_index, ist->index);
1883 av_free_packet(&pkt);
1888 av_free_packet(&pkt);
1890 /* dump report by using the output first video and audio streams */
1891 print_report(output_files, ost_table, nb_ostreams, 0);
1894 /* at the end of stream, we must flush the decoder buffers */
1895 for(i=0;i<nb_istreams;i++) {
1897 if (ist->decoding_needed) {
1898 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1904 /* write the trailer if needed and close file */
1905 for(i=0;i<nb_output_files;i++) {
1906 os = output_files[i];
1907 av_write_trailer(os);
1910 /* dump report by using the first video and audio streams */
1911 print_report(output_files, ost_table, nb_ostreams, 1);
1913 /* close each encoder */
1914 for(i=0;i<nb_ostreams;i++) {
1916 if (ost->encoding_needed) {
1917 av_freep(&ost->st->codec.stats_in);
1918 avcodec_close(&ost->st->codec);
1922 /* close each decoder */
1923 for(i=0;i<nb_istreams;i++) {
1925 if (ist->decoding_needed) {
1926 avcodec_close(&ist->st->codec);
1934 av_free(file_table);
1937 for(i=0;i<nb_istreams;i++) {
1944 for(i=0;i<nb_ostreams;i++) {
1948 fclose(ost->logfile);
1949 ost->logfile = NULL;
1951 fifo_free(&ost->fifo); /* works even if fifo is not
1952 initialized but set to zero */
1953 av_free(ost->pict_tmp.data[0]);
1954 if (ost->video_resample)
1955 img_resample_close(ost->img_resample_ctx);
1956 if (ost->audio_resample)
1957 audio_resample_close(ost->resample);
1970 int file_read(const char *filename)
1973 unsigned char buffer[1024];
1976 if (url_open(&h, filename, O_RDONLY) < 0) {
1977 printf("could not open '%s'\n", filename);
1981 len = url_read(h, buffer, sizeof(buffer));
1984 for(i=0;i<len;i++) putchar(buffer[i]);
1991 static void opt_image_format(const char *arg)
1995 for(f = first_image_format; f != NULL; f = f->next) {
1996 if (!strcmp(arg, f->name))
2000 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2006 static void opt_format(const char *arg)
2008 /* compatibility stuff for pgmyuv */
2009 if (!strcmp(arg, "pgmyuv")) {
2010 opt_image_format(arg);
2014 file_iformat = av_find_input_format(arg);
2015 file_oformat = guess_format(arg, NULL, NULL);
2016 if (!file_iformat && !file_oformat) {
2017 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2022 static void opt_video_bitrate(const char *arg)
2024 video_bit_rate = atoi(arg) * 1000;
2027 static void opt_video_bitrate_tolerance(const char *arg)
2029 video_bit_rate_tolerance = atoi(arg) * 1000;
2032 static void opt_video_bitrate_max(const char *arg)
2034 video_rc_max_rate = atoi(arg) * 1000;
2037 static void opt_video_bitrate_min(const char *arg)
2039 video_rc_min_rate = atoi(arg) * 1000;
2042 static void opt_video_buffer_size(const char *arg)
2044 video_rc_buffer_size = atoi(arg) * 8*1024;
2047 static void opt_video_rc_eq(char *arg)
2052 static void opt_video_rc_override_string(char *arg)
2054 video_rc_override_string = arg;
2058 static void opt_workaround_bugs(const char *arg)
2060 workaround_bugs = atoi(arg);
2063 static void opt_dct_algo(const char *arg)
2065 dct_algo = atoi(arg);
2068 static void opt_idct_algo(const char *arg)
2070 idct_algo = atoi(arg);
2073 static void opt_me_threshold(const char *arg)
2075 me_threshold = atoi(arg);
2078 static void opt_mb_threshold(const char *arg)
2080 mb_threshold = atoi(arg);
2083 static void opt_error_resilience(const char *arg)
2085 error_resilience = atoi(arg);
2088 static void opt_error_concealment(const char *arg)
2090 error_concealment = atoi(arg);
2093 static void opt_debug(const char *arg)
2098 static void opt_vismv(const char *arg)
2100 debug_mv = atoi(arg);
2103 static void opt_verbose(const char *arg)
2105 verbose = atoi(arg);
2106 av_log_set_level(atoi(arg));
2109 static void opt_frame_rate(const char *arg)
2111 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2112 fprintf(stderr, "Incorrect frame rate\n");
2117 static void opt_frame_crop_top(const char *arg)
2119 frame_topBand = atoi(arg);
2120 if (frame_topBand < 0) {
2121 fprintf(stderr, "Incorrect top crop size\n");
2124 if ((frame_topBand % 2) != 0) {
2125 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2128 if ((frame_topBand) >= frame_height){
2129 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2132 frame_height -= frame_topBand;
2135 static void opt_frame_crop_bottom(const char *arg)
2137 frame_bottomBand = atoi(arg);
2138 if (frame_bottomBand < 0) {
2139 fprintf(stderr, "Incorrect bottom crop size\n");
2142 if ((frame_bottomBand % 2) != 0) {
2143 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2146 if ((frame_bottomBand) >= frame_height){
2147 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2150 frame_height -= frame_bottomBand;
2153 static void opt_frame_crop_left(const char *arg)
2155 frame_leftBand = atoi(arg);
2156 if (frame_leftBand < 0) {
2157 fprintf(stderr, "Incorrect left crop size\n");
2160 if ((frame_leftBand % 2) != 0) {
2161 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2164 if ((frame_leftBand) >= frame_width){
2165 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2168 frame_width -= frame_leftBand;
2171 static void opt_frame_crop_right(const char *arg)
2173 frame_rightBand = atoi(arg);
2174 if (frame_rightBand < 0) {
2175 fprintf(stderr, "Incorrect right crop size\n");
2178 if ((frame_rightBand % 2) != 0) {
2179 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2182 if ((frame_rightBand) >= frame_width){
2183 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2186 frame_width -= frame_rightBand;
2189 static void opt_frame_size(const char *arg)
2191 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2192 fprintf(stderr, "Incorrect frame size\n");
2195 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2196 fprintf(stderr, "Frame size must be a multiple of 2\n");
2202 #define SCALEBITS 10
2203 #define ONE_HALF (1 << (SCALEBITS - 1))
2204 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2206 #define RGB_TO_Y(r, g, b) \
2207 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2208 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2210 #define RGB_TO_U(r1, g1, b1, shift)\
2211 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2212 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2214 #define RGB_TO_V(r1, g1, b1, shift)\
2215 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2216 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2218 static void opt_pad_color(const char *arg) {
2219 /* Input is expected to be six hex digits similar to
2220 how colors are expressed in html tags (but without the #) */
2221 int rgb = strtol(arg, NULL, 16);
2225 g = ((rgb >> 8) & 255);
2228 padcolor[0] = RGB_TO_Y(r,g,b);
2229 padcolor[1] = RGB_TO_U(r,g,b,0);
2230 padcolor[2] = RGB_TO_V(r,g,b,0);
2233 static void opt_frame_pad_top(const char *arg)
2235 frame_padtop = atoi(arg);
2236 if (frame_padtop < 0) {
2237 fprintf(stderr, "Incorrect top pad size\n");
2240 if ((frame_padtop % 2) != 0) {
2241 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2246 static void opt_frame_pad_bottom(const char *arg)
2248 frame_padbottom = atoi(arg);
2249 if (frame_padbottom < 0) {
2250 fprintf(stderr, "Incorrect bottom pad size\n");
2253 if ((frame_padbottom % 2) != 0) {
2254 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2260 static void opt_frame_pad_left(const char *arg)
2262 frame_padleft = atoi(arg);
2263 if (frame_padleft < 0) {
2264 fprintf(stderr, "Incorrect left pad size\n");
2267 if ((frame_padleft % 2) != 0) {
2268 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2274 static void opt_frame_pad_right(const char *arg)
2276 frame_padright = atoi(arg);
2277 if (frame_padright < 0) {
2278 fprintf(stderr, "Incorrect right pad size\n");
2281 if ((frame_padright % 2) != 0) {
2282 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2288 static void opt_frame_pix_fmt(const char *arg)
2290 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2293 static void opt_frame_aspect_ratio(const char *arg)
2299 p = strchr(arg, ':');
2301 x = strtol(arg, (char **)&arg, 10);
2303 y = strtol(arg+1, (char **)&arg, 10);
2305 ar = (double)x / (double)y;
2307 ar = strtod(arg, (char **)&arg);
2310 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2313 frame_aspect_ratio = ar;
2316 static void opt_gop_size(const char *arg)
2318 gop_size = atoi(arg);
2321 static void opt_b_frames(const char *arg)
2323 b_frames = atoi(arg);
2324 if (b_frames > FF_MAX_B_FRAMES) {
2325 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2327 } else if (b_frames < 1) {
2328 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2333 static void opt_mb_decision(const char *arg)
2335 mb_decision = atoi(arg);
2338 static void opt_mb_cmp(const char *arg)
2343 static void opt_ildct_cmp(const char *arg)
2345 ildct_cmp = atoi(arg);
2348 static void opt_sub_cmp(const char *arg)
2350 sub_cmp = atoi(arg);
2353 static void opt_cmp(const char *arg)
2358 static void opt_pre_cmp(const char *arg)
2360 pre_cmp = atoi(arg);
2363 static void opt_pre_me(const char *arg)
2368 static void opt_lumi_mask(const char *arg)
2370 lumi_mask = atof(arg);
2373 static void opt_dark_mask(const char *arg)
2375 dark_mask = atof(arg);
2378 static void opt_scplx_mask(const char *arg)
2380 scplx_mask = atof(arg);
2383 static void opt_tcplx_mask(const char *arg)
2385 tcplx_mask = atof(arg);
2388 static void opt_p_mask(const char *arg)
2393 static void opt_qscale(const char *arg)
2395 video_qscale = atof(arg);
2396 if (video_qscale < 0.01 ||
2397 video_qscale > 255) {
2398 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2403 static void opt_lmax(const char *arg)
2405 video_lmax = atof(arg)*FF_QP2LAMBDA;
2408 static void opt_lmin(const char *arg)
2410 video_lmin = atof(arg)*FF_QP2LAMBDA;
2413 static void opt_qmin(const char *arg)
2415 video_qmin = atoi(arg);
2416 if (video_qmin < 0 ||
2418 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2423 static void opt_qmax(const char *arg)
2425 video_qmax = atoi(arg);
2426 if (video_qmax < 0 ||
2428 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2433 static void opt_mb_qmin(const char *arg)
2435 video_mb_qmin = atoi(arg);
2436 if (video_mb_qmin < 0 ||
2437 video_mb_qmin > 31) {
2438 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2443 static void opt_mb_qmax(const char *arg)
2445 video_mb_qmax = atoi(arg);
2446 if (video_mb_qmax < 0 ||
2447 video_mb_qmax > 31) {
2448 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2453 static void opt_qdiff(const char *arg)
2455 video_qdiff = atoi(arg);
2456 if (video_qdiff < 0 ||
2458 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2463 static void opt_qblur(const char *arg)
2465 video_qblur = atof(arg);
2468 static void opt_qcomp(const char *arg)
2470 video_qcomp = atof(arg);
2473 static void opt_rc_initial_cplx(const char *arg)
2475 video_rc_initial_cplx = atof(arg);
2477 static void opt_b_qfactor(const char *arg)
2479 video_b_qfactor = atof(arg);
2481 static void opt_i_qfactor(const char *arg)
2483 video_i_qfactor = atof(arg);
2485 static void opt_b_qoffset(const char *arg)
2487 video_b_qoffset = atof(arg);
2489 static void opt_i_qoffset(const char *arg)
2491 video_i_qoffset = atof(arg);
2494 static void opt_ibias(const char *arg)
2496 video_intra_quant_bias = atoi(arg);
2498 static void opt_pbias(const char *arg)
2500 video_inter_quant_bias = atoi(arg);
2503 static void opt_packet_size(const char *arg)
2505 packet_size= atoi(arg);
2508 static void opt_error_rate(const char *arg)
2510 error_rate= atoi(arg);
2513 static void opt_strict(const char *arg)
2518 static void opt_top_field_first(const char *arg)
2520 top_field_first= atoi(arg);
2523 static void opt_noise_reduction(const char *arg)
2525 noise_reduction= atoi(arg);
2528 static void opt_qns(const char *arg)
2533 static void opt_sc_threshold(const char *arg)
2535 sc_threshold= atoi(arg);
2538 static void opt_me_range(const char *arg)
2540 me_range = atoi(arg);
2543 static void opt_thread_count(const char *arg)
2545 thread_count= atoi(arg);
2546 #if !defined(HAVE_PTHREADS) && !defined(HAVE_W32THREADS)
2548 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2552 static void opt_audio_bitrate(const char *arg)
2554 audio_bit_rate = atoi(arg) * 1000;
2557 static void opt_audio_rate(const char *arg)
2559 audio_sample_rate = atoi(arg);
2562 static void opt_audio_channels(const char *arg)
2564 audio_channels = atoi(arg);
2567 static void opt_video_device(const char *arg)
2569 video_device = av_strdup(arg);
2572 static void opt_video_channel(const char *arg)
2574 video_channel = strtol(arg, NULL, 0);
2577 static void opt_video_standard(const char *arg)
2579 video_standard = av_strdup(arg);
2582 static void opt_audio_device(const char *arg)
2584 audio_device = av_strdup(arg);
2587 static void opt_dv1394(const char *arg)
2589 video_grab_format = "dv1394";
2590 audio_grab_format = NULL;
2593 static void opt_audio_codec(const char *arg)
2597 if (!strcmp(arg, "copy")) {
2598 audio_stream_copy = 1;
2602 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2607 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2610 audio_codec_id = p->id;
2615 static void add_frame_hooker(const char *arg)
2620 char *args = av_strdup(arg);
2624 argv[0] = strtok(args, " ");
2625 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2628 i = frame_hook_add(argc, argv);
2631 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2636 const char *motion_str[] = {
2646 static void opt_motion_estimation(const char *arg)
2652 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2655 if (!strcmp(*p, arg))
2659 me_method = (p - motion_str) + 1;
2662 static void opt_video_codec(const char *arg)
2666 if (!strcmp(arg, "copy")) {
2667 video_stream_copy = 1;
2671 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2676 fprintf(stderr, "Unknown video codec '%s'\n", arg);
2679 video_codec_id = p->id;
2684 static void opt_map(const char *arg)
2690 m = &stream_maps[nb_stream_maps++];
2692 m->file_index = strtol(arg, (char **)&p, 0);
2696 m->stream_index = strtol(p, (char **)&p, 0);
2699 static void opt_map_meta_data(const char *arg)
2705 m = &meta_data_maps[nb_meta_data_maps++];
2707 m->out_file = strtol(arg, (char **)&p, 0);
2711 m->in_file = strtol(p, (char **)&p, 0);
2714 static void opt_recording_time(const char *arg)
2716 recording_time = parse_date(arg, 1);
2719 static void opt_start_time(const char *arg)
2721 start_time = parse_date(arg, 1);
2724 static void opt_rec_timestamp(const char *arg)
2726 rec_timestamp = parse_date(arg, 0) / 1000000;
2729 static void opt_input_ts_offset(const char *arg)
2731 input_ts_offset = parse_date(arg, 1);
2734 static void opt_input_file(const char *filename)
2736 AVFormatContext *ic;
2737 AVFormatParameters params, *ap = ¶ms;
2738 int err, i, ret, rfps, rfps_base;
2741 if (!strcmp(filename, "-"))
2744 using_stdin |= !strcmp(filename, "pipe:" ) ||
2745 !strcmp( filename, "/dev/stdin" );
2747 /* get default parameters from command line */
2748 memset(ap, 0, sizeof(*ap));
2749 ap->sample_rate = audio_sample_rate;
2750 ap->channels = audio_channels;
2751 ap->frame_rate = frame_rate;
2752 ap->frame_rate_base = frame_rate_base;
2753 ap->width = frame_width + frame_padleft + frame_padright;
2754 ap->height = frame_height + frame_padtop + frame_padbottom;
2755 ap->image_format = image_format;
2756 ap->pix_fmt = frame_pix_fmt;
2758 /* open the input file with generic libav function */
2759 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2761 print_error(filename, err);
2765 /* If not enough info to get the stream parameters, we decode the
2766 first frames to get it. (used in mpeg case for example) */
2767 ret = av_find_stream_info(ic);
2768 if (ret < 0 && verbose >= 0) {
2769 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2773 timestamp = start_time;
2774 /* add the stream start time */
2775 if (ic->start_time != AV_NOPTS_VALUE)
2776 timestamp += ic->start_time;
2778 /* if seeking requested, we execute it */
2779 if (start_time != 0) {
2780 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2782 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2783 filename, (double)timestamp / AV_TIME_BASE);
2785 /* reset seek info */
2789 /* update the current parameters so that they match the one of the input stream */
2790 for(i=0;i<ic->nb_streams;i++) {
2791 AVCodecContext *enc = &ic->streams[i]->codec;
2792 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2794 avcodec_thread_init(enc, thread_count);
2796 enc->thread_count= thread_count;
2797 switch(enc->codec_type) {
2798 case CODEC_TYPE_AUDIO:
2799 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2800 audio_channels = enc->channels;
2801 audio_sample_rate = enc->sample_rate;
2803 case CODEC_TYPE_VIDEO:
2804 frame_height = enc->height;
2805 frame_width = enc->width;
2806 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2807 frame_pix_fmt = enc->pix_fmt;
2808 rfps = ic->streams[i]->r_frame_rate;
2809 rfps_base = ic->streams[i]->r_frame_rate_base;
2810 enc->workaround_bugs = workaround_bugs;
2811 enc->error_resilience = error_resilience;
2812 enc->error_concealment = error_concealment;
2813 enc->idct_algo = idct_algo;
2815 enc->debug_mv = debug_mv;
2816 enc->lowres= lowres;
2818 enc->flags|= CODEC_FLAG_BITEXACT;
2820 enc->debug |= FF_DEBUG_MV;
2822 assert(enc->frame_rate_base == rfps_base); // should be true for now
2823 if (enc->frame_rate != rfps) {
2826 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2827 i, (float)enc->frame_rate / enc->frame_rate_base,
2829 (float)rfps / rfps_base);
2831 /* update the current frame rate to match the stream frame rate */
2833 frame_rate_base = rfps_base;
2835 enc->rate_emu = rate_emu;
2837 case CODEC_TYPE_DATA:
2844 input_files[nb_input_files] = ic;
2845 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2846 /* dump the file content */
2848 dump_format(ic, nb_input_files, filename, 0);
2851 file_iformat = NULL;
2852 file_oformat = NULL;
2853 image_format = NULL;
2858 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2860 int has_video, has_audio, i, j;
2861 AVFormatContext *ic;
2865 for(j=0;j<nb_input_files;j++) {
2866 ic = input_files[j];
2867 for(i=0;i<ic->nb_streams;i++) {
2868 AVCodecContext *enc = &ic->streams[i]->codec;
2869 switch(enc->codec_type) {
2870 case CODEC_TYPE_AUDIO:
2873 case CODEC_TYPE_VIDEO:
2876 case CODEC_TYPE_DATA:
2883 *has_video_ptr = has_video;
2884 *has_audio_ptr = has_audio;
2887 static void opt_output_file(const char *filename)
2890 AVFormatContext *oc;
2891 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2893 AVFormatParameters params, *ap = ¶ms;
2895 if (!strcmp(filename, "-"))
2898 oc = av_alloc_format_context();
2900 if (!file_oformat) {
2901 file_oformat = guess_format(NULL, filename, NULL);
2902 if (!file_oformat) {
2903 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2909 oc->oformat = file_oformat;
2911 if (!strcmp(file_oformat->name, "ffm") &&
2912 strstart(filename, "http:", NULL)) {
2913 /* special case for files sent to ffserver: we get the stream
2914 parameters from ffserver */
2915 if (read_ffserver_streams(oc, filename) < 0) {
2916 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2920 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2921 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2923 /* disable if no corresponding type found and at least one
2925 if (nb_input_files > 0) {
2926 check_audio_video_inputs(&input_has_video, &input_has_audio);
2927 if (!input_has_video)
2929 if (!input_has_audio)
2933 /* manual disable */
2934 if (audio_disable) {
2937 if (video_disable) {
2943 AVCodecContext *video_enc;
2945 st = av_new_stream(oc, nb_streams++);
2947 fprintf(stderr, "Could not alloc stream\n");
2950 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
2952 avcodec_thread_init(&st->codec, thread_count);
2955 video_enc = &st->codec;
2957 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
2958 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2959 if (video_stream_copy) {
2960 st->stream_copy = 1;
2961 video_enc->codec_type = CODEC_TYPE_VIDEO;
2967 codec_id = file_oformat->video_codec;
2968 if (video_codec_id != CODEC_ID_NONE)
2969 codec_id = video_codec_id;
2971 video_enc->codec_id = codec_id;
2972 codec = avcodec_find_encoder(codec_id);
2974 video_enc->bit_rate = video_bit_rate;
2975 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
2976 video_enc->frame_rate = frame_rate;
2977 video_enc->frame_rate_base = frame_rate_base;
2978 if(codec && codec->supported_framerates){
2979 const AVRational *p= codec->supported_framerates;
2980 AVRational req= (AVRational){frame_rate, frame_rate_base};
2981 const AVRational *best=NULL;
2982 AVRational best_error= (AVRational){INT_MAX, 1};
2983 for(; p->den!=0; p++){
2984 AVRational error= av_sub_q(req, *p);
2985 if(error.num <0) error.num *= -1;
2986 if(av_cmp_q(error, best_error) < 0){
2991 video_enc->frame_rate = best->num;
2992 video_enc->frame_rate_base= best->den;
2995 video_enc->width = frame_width + frame_padright + frame_padleft;
2996 video_enc->height = frame_height + frame_padtop + frame_padbottom;
2997 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
2998 video_enc->pix_fmt = frame_pix_fmt;
3000 if(codec && codec->pix_fmts){
3001 const enum PixelFormat *p= codec->pix_fmts;
3003 if(*p == video_enc->pix_fmt)
3007 video_enc->pix_fmt = codec->pix_fmts[0];
3011 video_enc->gop_size = gop_size;
3013 video_enc->gop_size = 0;
3014 if (video_qscale || same_quality) {
3015 video_enc->flags |= CODEC_FLAG_QSCALE;
3016 st->quality = FF_QP2LAMBDA * video_qscale;
3020 video_enc->intra_matrix = intra_matrix;
3022 video_enc->inter_matrix = inter_matrix;
3025 video_enc->flags |= CODEC_FLAG_BITEXACT;
3027 video_enc->mb_decision = mb_decision;
3028 video_enc->mb_cmp = mb_cmp;
3029 video_enc->ildct_cmp = ildct_cmp;
3030 video_enc->me_sub_cmp = sub_cmp;
3031 video_enc->me_cmp = cmp;
3032 video_enc->me_pre_cmp = pre_cmp;
3033 video_enc->pre_me = pre_me;
3034 video_enc->lumi_masking = lumi_mask;
3035 video_enc->dark_masking = dark_mask;
3036 video_enc->spatial_cplx_masking = scplx_mask;
3037 video_enc->temporal_cplx_masking = tcplx_mask;
3038 video_enc->p_masking = p_mask;
3039 video_enc->quantizer_noise_shaping= qns;
3042 video_enc->flags |= CODEC_FLAG_H263P_UMV;
3045 video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3048 video_enc->flags |= CODEC_FLAG_H263P_AIC;
3051 video_enc->flags |= CODEC_FLAG_H263P_AIV;
3054 video_enc->flags |= CODEC_FLAG_4MV;
3057 video_enc->flags |= CODEC_FLAG_OBMC;
3060 video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3064 video_enc->flags |= CODEC_FLAG_PART;
3067 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3070 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3072 if (use_scan_offset) {
3073 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3076 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3079 video_enc->flags |= CODEC_FLAG_QPEL;
3082 video_enc->flags |= CODEC_FLAG_QP_RD;
3085 video_enc->flags |= CODEC_FLAG_CBP_RD;
3088 video_enc->max_b_frames = b_frames;
3089 video_enc->b_frame_strategy = 0;
3090 video_enc->b_quant_factor = 2.0;
3092 if (do_interlace_dct) {
3093 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3095 if (do_interlace_me) {
3096 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3098 video_enc->qmin = video_qmin;
3099 video_enc->qmax = video_qmax;
3100 video_enc->lmin = video_lmin;
3101 video_enc->lmax = video_lmax;
3102 video_enc->mb_qmin = video_mb_qmin;
3103 video_enc->mb_qmax = video_mb_qmax;
3104 video_enc->max_qdiff = video_qdiff;
3105 video_enc->qblur = video_qblur;
3106 video_enc->qcompress = video_qcomp;
3107 video_enc->rc_eq = video_rc_eq;
3108 video_enc->debug = debug;
3109 video_enc->debug_mv = debug_mv;
3110 video_enc->thread_count = thread_count;
3111 p= video_rc_override_string;
3114 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3116 fprintf(stderr, "error parsing rc_override\n");
3119 video_enc->rc_override=
3120 av_realloc(video_enc->rc_override,
3121 sizeof(RcOverride)*(i+1));
3122 video_enc->rc_override[i].start_frame= start;
3123 video_enc->rc_override[i].end_frame = end;
3125 video_enc->rc_override[i].qscale= q;
3126 video_enc->rc_override[i].quality_factor= 1.0;
3129 video_enc->rc_override[i].qscale= 0;
3130 video_enc->rc_override[i].quality_factor= -q/100.0;
3135 video_enc->rc_override_count=i;
3137 video_enc->rc_max_rate = video_rc_max_rate;
3138 video_enc->rc_min_rate = video_rc_min_rate;
3139 video_enc->rc_buffer_size = video_rc_buffer_size;
3140 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3141 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3142 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3143 video_enc->i_quant_factor = video_i_qfactor;
3144 video_enc->b_quant_factor = video_b_qfactor;
3145 video_enc->i_quant_offset = video_i_qoffset;
3146 video_enc->b_quant_offset = video_b_qoffset;
3147 video_enc->intra_quant_bias = video_intra_quant_bias;
3148 video_enc->inter_quant_bias = video_inter_quant_bias;
3149 video_enc->dct_algo = dct_algo;
3150 video_enc->idct_algo = idct_algo;
3151 video_enc->me_threshold= me_threshold;
3152 video_enc->mb_threshold= mb_threshold;
3153 video_enc->intra_dc_precision= intra_dc_precision - 8;
3154 video_enc->strict_std_compliance = strict;
3155 video_enc->error_rate = error_rate;
3156 video_enc->noise_reduction= noise_reduction;
3157 video_enc->scenechange_threshold= sc_threshold;
3158 video_enc->me_range = me_range;
3159 video_enc->coder_type= coder;
3160 video_enc->context_model= context;
3161 video_enc->prediction_method= predictor;
3162 video_enc->profile= video_profile;
3163 video_enc->level= video_level;
3164 video_enc->nsse_weight= nsse_weight;
3165 video_enc->me_subpel_quality= subpel_quality;
3168 video_enc->rtp_mode= 1;
3169 video_enc->rtp_payload_size= packet_size;
3173 video_enc->flags|= CODEC_FLAG_PSNR;
3175 video_enc->me_method = me_method;
3180 video_enc->flags |= CODEC_FLAG_PASS1;
3182 video_enc->flags |= CODEC_FLAG_PASS2;
3189 AVCodecContext *audio_enc;
3191 st = av_new_stream(oc, nb_streams++);
3193 fprintf(stderr, "Could not alloc stream\n");
3196 #if defined(HAVE_PTHREADS) || defined(HAVE_W32THREADS)
3198 avcodec_thread_init(&st->codec, thread_count);
3201 audio_enc = &st->codec;
3202 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3204 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3205 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3206 if (audio_stream_copy) {
3207 st->stream_copy = 1;
3208 audio_enc->channels = audio_channels;
3210 codec_id = file_oformat->audio_codec;
3211 if (audio_codec_id != CODEC_ID_NONE)
3212 codec_id = audio_codec_id;
3213 audio_enc->codec_id = codec_id;
3215 audio_enc->bit_rate = audio_bit_rate;
3216 audio_enc->strict_std_compliance = strict;
3217 audio_enc->thread_count = thread_count;
3218 /* For audio codecs other than AC3 or DTS we limit */
3219 /* the number of coded channels to stereo */
3220 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3221 && codec_id != CODEC_ID_DTS) {
3222 audio_enc->channels = 2;
3224 audio_enc->channels = audio_channels;
3226 audio_enc->sample_rate = audio_sample_rate;
3229 oc->nb_streams = nb_streams;
3232 fprintf(stderr, "No audio or video streams available\n");
3236 oc->timestamp = rec_timestamp;
3239 pstrcpy(oc->title, sizeof(oc->title), str_title);
3241 pstrcpy(oc->author, sizeof(oc->author), str_author);
3243 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3245 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3248 output_files[nb_output_files++] = oc;
3250 strcpy(oc->filename, filename);
3252 /* check filename in case of an image number is expected */
3253 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3254 if (filename_number_test(oc->filename) < 0) {
3255 print_error(oc->filename, AVERROR_NUMEXPECTED);
3260 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3261 /* test if it already exists to avoid loosing precious files */
3262 if (!file_overwrite &&
3263 (strchr(filename, ':') == NULL ||
3264 strstart(filename, "file:", NULL))) {
3265 if (url_exist(filename)) {
3268 if ( !using_stdin ) {
3269 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3272 if (toupper(c) != 'Y') {
3273 fprintf(stderr, "Not overwriting - exiting\n");
3278 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3285 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3286 fprintf(stderr, "Could not open '%s'\n", filename);
3291 memset(ap, 0, sizeof(*ap));
3292 ap->image_format = image_format;
3293 if (av_set_parameters(oc, ap) < 0) {
3294 fprintf(stderr, "%s: Invalid encoding parameters\n",
3299 oc->packet_size= mux_packet_size;
3300 oc->mux_rate= mux_rate;
3302 /* reset some options */
3303 file_oformat = NULL;
3304 file_iformat = NULL;
3305 image_format = NULL;
3308 audio_codec_id = CODEC_ID_NONE;
3309 video_codec_id = CODEC_ID_NONE;
3310 audio_stream_copy = 0;
3311 video_stream_copy = 0;
3314 /* prepare dummy protocols for grab */
3315 static void prepare_grab(void)
3317 int has_video, has_audio, i, j;
3318 AVFormatContext *oc;
3319 AVFormatContext *ic;
3320 AVFormatParameters vp1, *vp = &vp1;
3321 AVFormatParameters ap1, *ap = &ap1;
3323 /* see if audio/video inputs are needed */
3326 memset(ap, 0, sizeof(*ap));
3327 memset(vp, 0, sizeof(*vp));
3328 vp->frame_rate_base= 1;
3329 for(j=0;j<nb_output_files;j++) {
3330 oc = output_files[j];
3331 for(i=0;i<oc->nb_streams;i++) {
3332 AVCodecContext *enc = &oc->streams[i]->codec;
3333 switch(enc->codec_type) {
3334 case CODEC_TYPE_AUDIO:
3335 if (enc->sample_rate > ap->sample_rate)
3336 ap->sample_rate = enc->sample_rate;
3337 if (enc->channels > ap->channels)
3338 ap->channels = enc->channels;
3341 case CODEC_TYPE_VIDEO:
3342 if (enc->width > vp->width)
3343 vp->width = enc->width;
3344 if (enc->height > vp->height)
3345 vp->height = enc->height;
3347 if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3348 vp->frame_rate = enc->frame_rate;
3349 vp->frame_rate_base = enc->frame_rate_base;
3359 if (has_video == 0 && has_audio == 0) {
3360 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3365 AVInputFormat *fmt1;
3366 fmt1 = av_find_input_format(video_grab_format);
3367 vp->device = video_device;
3368 vp->channel = video_channel;
3369 vp->standard = video_standard;
3370 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3371 fprintf(stderr, "Could not find video grab device\n");
3374 /* If not enough info to get the stream parameters, we decode the
3375 first frames to get it. */
3376 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3377 fprintf(stderr, "Could not find video grab parameters\n");
3380 /* by now video grab has one stream */
3381 ic->streams[0]->r_frame_rate = vp->frame_rate;
3382 ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3383 input_files[nb_input_files] = ic;
3386 dump_format(ic, nb_input_files, "", 0);
3390 if (has_audio && audio_grab_format) {
3391 AVInputFormat *fmt1;
3392 fmt1 = av_find_input_format(audio_grab_format);
3393 ap->device = audio_device;
3394 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3395 fprintf(stderr, "Could not find audio grab device\n");
3398 input_files[nb_input_files] = ic;
3401 dump_format(ic, nb_input_files, "", 0);
3407 /* same option as mencoder */
3408 static void opt_pass(const char *pass_str)
3411 pass = atoi(pass_str);
3412 if (pass != 1 && pass != 2) {
3413 fprintf(stderr, "pass number can be only 1 or 2\n");
3419 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3420 static int64_t getutime(void)
3422 return av_gettime();
3425 static int64_t getutime(void)
3427 struct rusage rusage;
3429 getrusage(RUSAGE_SELF, &rusage);
3430 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3434 extern int ffm_nopts;
3436 static void opt_bitexact(void)
3439 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3443 static void show_formats(void)
3445 AVInputFormat *ifmt;
3446 AVOutputFormat *ofmt;
3447 AVImageFormat *image_fmt;
3450 const char **pp, *last_name;
3452 printf("File formats:\n");
3457 const char *name=NULL;
3459 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3460 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3461 strcmp(ofmt->name, last_name)>0){
3466 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3467 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3468 strcmp(ifmt->name, last_name)>0){
3472 if(name && strcmp(ifmt->name, name)==0)
3487 printf("Image formats:\n");
3488 for(image_fmt = first_image_format; image_fmt != NULL;
3489 image_fmt = image_fmt->next) {
3492 image_fmt->img_read ? "D":" ",
3493 image_fmt->img_write ? "E":" ",
3498 printf("Codecs:\n");
3506 for(p = first_avcodec; p != NULL; p = p->next) {
3507 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3508 strcmp(p->name, last_name)>0){
3510 decode= encode= cap=0;
3512 if(p2 && strcmp(p->name, p2->name)==0){
3513 if(p->decode) decode=1;
3514 if(p->encode) encode=1;
3515 cap |= p->capabilities;
3520 last_name= p2->name;
3524 decode ? "D": (/*p2->decoder ? "d":*/" "),
3526 p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3527 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3528 cap & CODEC_CAP_DR1 ? "D":" ",
3529 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3531 /* if(p2->decoder && decode==0)
3532 printf(" use %s for decoding", p2->decoder->name);*/
3537 printf("Supported file protocols:\n");
3538 for(up = first_protocol; up != NULL; up = up->next)
3539 printf(" %s:", up->name);
3542 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3543 printf("Motion estimation methods:\n");
3547 if ((pp - motion_str + 1) == ME_ZERO)
3548 printf("(fastest)");
3549 else if ((pp - motion_str + 1) == ME_FULL)
3550 printf("(slowest)");
3551 else if ((pp - motion_str + 1) == ME_EPZS)
3552 printf("(default)");
3557 "Note, the names of encoders and decoders dont always match, so there are\n"
3558 "several cases where the above table shows encoder only or decoder only entries\n"
3559 "even though both encoding and decoding are supported for example, the h263\n"
3560 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3565 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3568 const char *p = str;
3575 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3582 void opt_inter_matrix(const char *arg)
3584 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3585 parse_matrix_coeffs(inter_matrix, arg);
3588 void opt_intra_matrix(const char *arg)
3590 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3591 parse_matrix_coeffs(intra_matrix, arg);
3594 static void opt_target(const char *arg)
3598 if(!strncmp(arg, "pal-", 4)) {
3601 } else if(!strncmp(arg, "ntsc-", 5)) {
3606 /* Calculate FR via float to avoid int overflow */
3607 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3610 } else if((fr == 29970) || (fr == 23976)) {
3613 /* Try to determine PAL/NTSC by peeking in the input files */
3614 if(nb_input_files) {
3616 for(j = 0; j < nb_input_files; j++) {
3617 for(i = 0; i < input_files[j]->nb_streams; i++) {
3618 AVCodecContext *c = &input_files[j]->streams[i]->codec;
3619 if(c->codec_type != CODEC_TYPE_VIDEO)
3621 fr = c->frame_rate * 1000 / c->frame_rate_base;
3625 } else if((fr == 29970) || (fr == 23976)) {
3635 if(verbose && norm >= 0)
3636 printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3640 fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3641 fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3642 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3646 if(!strcmp(arg, "vcd")) {
3648 opt_video_codec("mpeg1video");
3649 opt_audio_codec("mp2");
3652 opt_frame_size(norm ? "352x240" : "352x288");
3654 video_bit_rate = 1150000;
3655 video_rc_max_rate = 1150000;
3656 video_rc_min_rate = 1150000;
3657 video_rc_buffer_size = 40*1024*8;
3659 audio_bit_rate = 224000;
3660 audio_sample_rate = 44100;
3662 mux_packet_size= 2324;
3663 mux_rate= 2352 * 75 * 8;
3665 } else if(!strcmp(arg, "svcd")) {
3667 opt_video_codec("mpeg2video");
3668 opt_audio_codec("mp2");
3671 opt_frame_size(norm ? "480x480" : "480x576");
3672 opt_gop_size(norm ? "18" : "15");
3674 video_bit_rate = 2040000;
3675 video_rc_max_rate = 2516000;
3676 video_rc_min_rate = 0; //1145000;
3677 video_rc_buffer_size = 224*1024*8;
3678 use_scan_offset = 1;
3680 audio_bit_rate = 224000;
3681 audio_sample_rate = 44100;
3683 mux_packet_size= 2324;
3685 } else if(!strcmp(arg, "dvd")) {
3687 opt_video_codec("mpeg2video");
3688 opt_audio_codec("ac3");
3691 opt_frame_size(norm ? "720x480" : "720x576");
3692 opt_gop_size(norm ? "18" : "15");
3694 video_bit_rate = 6000000;
3695 video_rc_max_rate = 9000000;
3696 video_rc_min_rate = 0; //1500000;
3697 video_rc_buffer_size = 224*1024*8;
3699 audio_bit_rate = 448000;
3700 audio_sample_rate = 48000;
3703 fprintf(stderr, "Unknown target: %s\n", arg);
3708 static void show_version(void)
3710 printf("ffmpeg " FFMPEG_VERSION "\n"
3713 avcodec_build(), LIBAVFORMAT_BUILD);
3717 const OptionDef options[] = {
3719 { "L", 0, {(void*)show_license}, "show license" },
3720 { "h", 0, {(void*)show_help}, "show help" },
3721 { "version", 0, {(void*)show_version}, "show version" },
3722 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3723 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3724 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3725 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3726 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3727 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3728 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3729 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3730 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3731 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3732 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3733 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3734 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3735 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3736 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3737 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3738 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3739 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3740 "add timings for benchmarking" },
3741 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3742 "dump each input packet" },
3743 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3744 "when dumping packets, also dump the payload" },
3745 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3746 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3747 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3748 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3749 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3750 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3751 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3752 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3753 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3756 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3757 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3758 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3759 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3760 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3761 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3762 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3763 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3764 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3765 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3766 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3767 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3768 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3769 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3770 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3771 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3772 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3773 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3774 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3775 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3776 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3777 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3778 { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3779 { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3780 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3781 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3782 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3783 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3784 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3785 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3786 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3787 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3788 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3789 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3790 // { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3791 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3792 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3793 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3794 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3795 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3796 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3797 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3798 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3800 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
3801 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
3802 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3803 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
3804 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
3805 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
3806 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3807 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3808 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3809 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3810 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3811 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3812 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3813 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3814 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3815 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3816 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3817 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3818 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
3819 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3820 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3821 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3822 { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3823 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3824 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3825 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3826 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3827 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3828 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3829 "use same video quality as source (implies VBR)" },
3830 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3831 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3832 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3833 "deinterlace pictures" },
3834 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
3835 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3836 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
3837 "force interlaced me support in encoder (MPEG2/MPEG4)" },
3838 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3839 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3840 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3841 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3842 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3843 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3844 { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3845 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3846 { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
3847 { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
3848 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3849 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3850 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3851 { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3852 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3853 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3854 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3855 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3856 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3857 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3858 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3859 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3860 { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3861 { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3862 { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3863 { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
3864 { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
3865 { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
3866 { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
3867 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
3870 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3871 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3872 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3873 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3874 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3877 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3878 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3879 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3880 { "dv1394", OPT_EXPERT | OPT_GRAB, {(void*)opt_dv1394}, "set DV1394 grab", "" },
3881 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3884 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
3885 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
3889 static void show_banner(void)
3891 printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
3893 printf(" configuration: %s\n", FFMPEG_CONFIGURATION);
3894 printf(" built on " __DATE__ " " __TIME__);
3896 printf(", gcc: %s\n", __VERSION__);
3898 printf(", using a non-gcc compiler\n");
3902 static void show_license(void)
3907 "This program is free software; you can redistribute it and/or modify\n"
3908 "it under the terms of the GNU General Public License as published by\n"
3909 "the Free Software Foundation; either version 2 of the License, or\n"
3910 "(at your option) any later version.\n"
3912 "This program is distributed in the hope that it will be useful,\n"
3913 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3914 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3915 "GNU General Public License for more details.\n"
3917 "You should have received a copy of the GNU General Public License\n"
3918 "along with this program; if not, write to the Free Software\n"
3919 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
3923 "This library is free software; you can redistribute it and/or\n"
3924 "modify it under the terms of the GNU Lesser General Public\n"
3925 "License as published by the Free Software Foundation; either\n"
3926 "version 2 of the License, or (at your option) any later version.\n"
3928 "This library is distributed in the hope that it will be useful,\n"
3929 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3930 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
3931 "Lesser General Public License for more details.\n"
3933 "You should have received a copy of the GNU Lesser General Public\n"
3934 "License along with this library; if not, write to the Free Software\n"
3935 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
3941 static void show_help(void)
3944 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
3945 "Hyper fast Audio and Video encoder\n");
3947 show_help_options(options, "Main options:\n",
3948 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
3949 show_help_options(options, "\nVideo options:\n",
3950 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3952 show_help_options(options, "\nAdvanced Video options:\n",
3953 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3954 OPT_VIDEO | OPT_EXPERT);
3955 show_help_options(options, "\nAudio options:\n",
3956 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3958 show_help_options(options, "\nAdvanced Audio options:\n",
3959 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3960 OPT_AUDIO | OPT_EXPERT);
3961 show_help_options(options, "\nAudio/Video grab options:\n",
3964 show_help_options(options, "\nAdvanced options:\n",
3965 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3970 void parse_arg_file(const char *filename)
3972 opt_output_file(filename);
3975 int main(int argc, char **argv)
3988 parse_options(argc, argv, options);
3990 /* file converter / grab */
3991 if (nb_output_files <= 0) {
3992 fprintf(stderr, "Must supply at least one output file\n");
3996 if (nb_input_files == 0) {
4002 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4003 stream_maps, nb_stream_maps);
4004 ti = getutime() - ti;
4006 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4010 for(i=0;i<nb_output_files;i++) {
4011 /* maybe av_close_output_file ??? */
4012 AVFormatContext *s = output_files[i];
4014 if (!(s->oformat->flags & AVFMT_NOFILE))
4016 for(j=0;j<s->nb_streams;j++)
4017 av_free(s->streams[j]);
4020 for(i=0;i<nb_input_files;i++)
4021 av_close_input_file(input_files[i]);
4026 av_free(intra_matrix);
4028 av_free(inter_matrix);
4030 #ifdef POWERPC_PERFORMANCE_REPORT
4031 extern void powerpc_display_perf_report(void);
4032 powerpc_display_perf_report();
4033 #endif /* POWERPC_PERFORMANCE_REPORT */
4035 #ifndef CONFIG_WIN32
4036 if (received_sigterm) {
4038 "Received signal %d: terminating.\n",
4039 (int) received_sigterm);
4043 exit(0); /* not all OS-es handle main() return value */