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 = 0;
87 static int frame_height = 0;
88 static float frame_aspect_ratio = 0;
89 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
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 max_frames[3] = {INT_MAX, INT_MAX, INT_MAX};
100 static int frame_rate = 25;
101 static int frame_rate_base = 1;
102 static int video_bit_rate = 200*1000;
103 static int video_bit_rate_tolerance = 4000*1000;
104 static float video_qscale = 0;
105 static int video_qmin = 2;
106 static int video_qmax = 31;
107 static int video_lmin = 2*FF_QP2LAMBDA;
108 static int video_lmax = 31*FF_QP2LAMBDA;
109 static int video_mb_lmin = 2*FF_QP2LAMBDA;
110 static int video_mb_lmax = 31*FF_QP2LAMBDA;
111 static int video_qdiff = 3;
112 static int video_lelim = 0;
113 static int video_celim = 0;
114 static float video_qblur = 0.5;
115 static float video_qsquish = 0.0;
116 static float video_qcomp = 0.5;
117 static uint16_t *intra_matrix = NULL;
118 static uint16_t *inter_matrix = NULL;
119 #if 0 //experimental, (can be removed)
120 static float video_rc_qsquish=1.0;
121 static float video_rc_qmod_amp=0;
122 static int video_rc_qmod_freq=0;
124 static char *video_rc_override_string=NULL;
125 static char *video_rc_eq="tex^qComp";
126 static int video_rc_buffer_size=0;
127 static float video_rc_buffer_aggressivity=1.0;
128 static int video_rc_max_rate=0;
129 static int video_rc_min_rate=0;
130 static float video_rc_initial_cplx=0;
131 static float video_b_qfactor = 1.25;
132 static float video_b_qoffset = 1.25;
133 static float video_i_qfactor = -0.8;
134 static float video_i_qoffset = 0.0;
135 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
136 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
137 static int me_method = ME_EPZS;
138 static int video_disable = 0;
139 static int video_discard = 0;
140 static int video_codec_id = CODEC_ID_NONE;
141 static int video_codec_tag = 0;
142 static int same_quality = 0;
143 static int b_frames = 0;
144 static int mb_decision = FF_MB_DECISION_SIMPLE;
145 static int ildct_cmp = FF_CMP_VSAD;
146 static int mb_cmp = FF_CMP_SAD;
147 static int sub_cmp = FF_CMP_SAD;
148 static int cmp = FF_CMP_SAD;
149 static int pre_cmp = FF_CMP_SAD;
150 static int pre_me = 0;
151 static float lumi_mask = 0;
152 static float dark_mask = 0;
153 static float scplx_mask = 0;
154 static float tcplx_mask = 0;
155 static float p_mask = 0;
156 static int use_4mv = 0;
157 static int use_obmc = 0;
158 static int use_loop = 0;
159 static int use_aic = 0;
160 static int use_aiv = 0;
161 static int use_umv = 0;
162 static int use_ss = 0;
163 static int use_alt_scan = 0;
164 static int use_trell = 0;
165 static int use_scan_offset = 0;
166 static int use_qpel = 0;
167 static int use_qprd = 0;
168 static int use_cbprd = 0;
169 static int use_mv0 = 0;
170 static int do_normalize_aqp = 0;
172 static int closed_gop = 0;
173 static int strict_gop = 0;
174 static int no_output = 0;
175 static int do_deinterlace = 0;
176 static int do_interlace_dct = 0;
177 static int do_interlace_me = 0;
178 static int workaround_bugs = FF_BUG_AUTODETECT;
179 static int error_resilience = 2;
180 static int error_concealment = 3;
181 static int dct_algo = 0;
182 static int idct_algo = 0;
183 static int use_part = 0;
184 static int packet_size = 0;
185 static int error_rate = 0;
186 static int strict = 0;
187 static int top_field_first = -1;
188 static int noise_reduction = 0;
189 static int sc_threshold = 0;
190 static int debug = 0;
191 static int debug_mv = 0;
192 static int me_threshold = 0;
193 static int mb_threshold = 0;
194 static int intra_dc_precision = 8;
195 static int coder = 0;
196 static int context = 0;
197 static int predictor = 0;
198 static int video_profile = FF_PROFILE_UNKNOWN;
199 static int video_level = FF_LEVEL_UNKNOWN;
200 static int nsse_weight = 8;
201 static int subpel_quality= 8;
202 static int me_penalty_compensation= 256;
203 static int lowres= 0;
204 static int frame_skip_threshold= 0;
205 static int frame_skip_factor= 0;
206 static int frame_skip_exp= 0;
207 static int frame_skip_cmp= FF_CMP_DCTMAX;
208 extern int loop_input; /* currently a hack */
210 static int gop_size = 12;
211 static int intra_only = 0;
212 static int audio_sample_rate = 44100;
213 static int audio_bit_rate = 64000;
214 static int audio_disable = 0;
215 static int audio_channels = 1;
216 static int audio_codec_id = CODEC_ID_NONE;
217 static int audio_codec_tag = 0;
219 static int mux_rate= 0;
220 static int mux_packet_size= 0;
221 static float mux_preload= 0.5;
222 static float mux_max_delay= 0.7;
224 static int64_t recording_time = 0;
225 static int64_t start_time = 0;
226 static int64_t rec_timestamp = 0;
227 static int64_t input_ts_offset = 0;
228 static int file_overwrite = 0;
229 static char *str_title = NULL;
230 static char *str_author = NULL;
231 static char *str_copyright = NULL;
232 static char *str_comment = NULL;
233 static int do_benchmark = 0;
234 static int do_hex_dump = 0;
235 static int do_pkt_dump = 0;
236 static int do_psnr = 0;
237 static int do_vstats = 0;
238 static int do_pass = 0;
239 static int bitexact = 0;
240 static char *pass_logfilename = NULL;
241 static int audio_stream_copy = 0;
242 static int video_stream_copy = 0;
243 static int video_sync_method= 1;
244 static int audio_sync_method= 0;
245 static int copy_ts= 0;
246 static int opt_shortest = 0; //
248 static int rate_emu = 0;
250 static char *video_grab_format = "video4linux";
251 static char *video_device = NULL;
252 static char *grab_device = NULL;
253 static int video_channel = 0;
254 static char *video_standard = "ntsc";
256 static char *audio_grab_format = "audio_device";
257 static char *audio_device = NULL;
258 static int audio_volume = 256;
260 static int using_stdin = 0;
261 static int using_vhook = 0;
262 static int verbose = 1;
263 static int thread_count= 1;
264 static int q_pressed = 0;
265 static int me_range = 0;
266 static int64_t video_size = 0;
267 static int64_t audio_size = 0;
268 static int64_t extra_size = 0;
269 static int nb_frames_dup = 0;
270 static int nb_frames_drop = 0;
271 static int input_sync;
272 static int limit_filesize = 0; //
274 static int pgmyuv_compatibility_hack=0;
277 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
279 typedef struct AVOutputStream {
280 int file_index; /* file index */
281 int index; /* stream index in the output file */
282 int source_index; /* AVInputStream index */
283 AVStream *st; /* stream in the output file */
284 int encoding_needed; /* true if encoding needed for this stream */
286 /* input pts and corresponding output pts
288 double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
289 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
291 int video_resample; /* video_resample and video_crop are mutually exclusive */
292 AVFrame pict_tmp; /* temporary image for resampling */
293 ImgReSampleContext *img_resample_ctx; /* for image resampling */
295 int video_crop; /* video_resample and video_crop are mutually exclusive */
296 int topBand; /* cropping area sizes */
299 int video_pad; /* video_resample and video_pad are mutually exclusive */
300 int padtop; /* padding area sizes */
307 ReSampleContext *resample; /* for audio resampling */
308 FifoBuffer fifo; /* for compression: one audio fifo per codec */
312 typedef struct AVInputStream {
316 int discard; /* true if stream data should be discarded */
317 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
318 int64_t sample_index; /* current sample */
320 int64_t start; /* time when read started */
321 unsigned long frame; /* current frame */
322 int64_t next_pts; /* synthetic pts for cases where pkt.pts
324 int64_t pts; /* current pts */
325 int is_start; /* is 1 at the start and after a discontinuity */
328 typedef struct AVInputFile {
329 int eof_reached; /* true if eof reached */
330 int ist_index; /* index of first stream in ist_table */
331 int buffer_size; /* current total buffer size */
332 int buffer_size_max; /* buffer size at which we consider we can stop
334 int nb_streams; /* nb streams we are aware of */
339 /* init terminal so that we can grab keys */
340 static struct termios oldtty;
342 static void term_exit(void)
344 tcsetattr (0, TCSANOW, &oldtty);
347 static volatile sig_atomic_t received_sigterm = 0;
350 sigterm_handler(int sig)
352 received_sigterm = sig;
356 static void term_init(void)
363 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
364 |INLCR|IGNCR|ICRNL|IXON);
365 tty.c_oflag |= OPOST;
366 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
367 tty.c_cflag &= ~(CSIZE|PARENB);
372 tcsetattr (0, TCSANOW, &tty);
374 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
375 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
376 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
378 register a function to be called at normal program termination
381 #ifdef CONFIG_BEOS_NETSERVER
382 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
386 /* read a key without blocking */
387 static int read_key(void)
391 #ifndef CONFIG_BEOS_NETSERVER
399 n = select(1, &rfds, NULL, NULL, &tv);
411 static int decode_interrupt_cb(void)
413 return q_pressed || (q_pressed = read_key() == 'q');
418 static volatile int received_sigterm = 0;
420 /* no interactive support */
421 static void term_exit(void)
425 static void term_init(void)
429 static int read_key(void)
436 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
441 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
444 /* copy stream format */
445 s->nb_streams = ic->nb_streams;
446 for(i=0;i<ic->nb_streams;i++) {
449 st = av_mallocz(sizeof(AVStream));
450 memcpy(st, ic->streams[i], sizeof(AVStream));
454 av_close_input_file(ic);
458 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
460 static void do_audio_out(AVFormatContext *s,
463 unsigned char *buf, int size)
466 static uint8_t *audio_buf = NULL;
467 static uint8_t *audio_out = NULL;
468 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
470 int size_out, frame_bytes, ret;
471 AVCodecContext *enc= &ost->st->codec;
473 /* SC: dynamic allocation of buffers */
475 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
477 audio_out = av_malloc(audio_out_size);
478 if (!audio_buf || !audio_out)
479 return; /* Should signal an error ! */
481 if(audio_sync_method){
482 double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts
483 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
484 double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
485 int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
487 //FIXME resample delay
488 if(fabs(delta) > 50){
491 byte_delta= FFMAX(byte_delta, -size);
495 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
500 static uint8_t *input_tmp= NULL;
501 input_tmp= av_realloc(input_tmp, byte_delta + size);
503 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
506 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
508 memset(input_tmp, 0, byte_delta);
509 memcpy(input_tmp + byte_delta, buf, size);
513 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
515 }else if(audio_sync_method>1){
516 int comp= clip(delta, -audio_sync_method, audio_sync_method);
517 assert(ost->audio_resample);
519 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
520 // 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));
521 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
525 ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
526 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
528 if (ost->audio_resample) {
530 size_out = audio_resample(ost->resample,
531 (short *)buftmp, (short *)buf,
532 size / (ist->st->codec.channels * 2));
533 size_out = size_out * enc->channels * 2;
539 /* now encode as many frames as possible */
540 if (enc->frame_size > 1) {
541 /* output resampled raw samples */
542 fifo_write(&ost->fifo, buftmp, size_out,
545 frame_bytes = enc->frame_size * 2 * enc->channels;
547 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
548 &ost->fifo.rptr) == 0) {
550 av_init_packet(&pkt);
552 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
555 pkt.stream_index= ost->index;
559 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
560 pkt.flags |= PKT_FLAG_KEY;
561 av_interleaved_write_frame(s, &pkt);
563 ost->sync_opts += enc->frame_size;
567 av_init_packet(&pkt);
569 ost->sync_opts += size_out / (2 * enc->channels);
571 /* output a pcm frame */
572 /* XXX: change encoding codec API to avoid this ? */
573 switch(enc->codec->id) {
574 case CODEC_ID_PCM_S16LE:
575 case CODEC_ID_PCM_S16BE:
576 case CODEC_ID_PCM_U16LE:
577 case CODEC_ID_PCM_U16BE:
580 size_out = size_out >> 1;
583 ret = avcodec_encode_audio(enc, audio_out, size_out,
586 pkt.stream_index= ost->index;
590 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
591 pkt.flags |= PKT_FLAG_KEY;
592 av_interleaved_write_frame(s, &pkt);
596 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
600 AVPicture picture_tmp;
603 dec = &ist->st->codec;
605 /* deinterlace : must be done before any resize */
606 if (do_deinterlace || using_vhook) {
609 /* create temporary picture */
610 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
611 buf = av_malloc(size);
615 picture2 = &picture_tmp;
616 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
619 if(avpicture_deinterlace(picture2, picture,
620 dec->pix_fmt, dec->width, dec->height) < 0) {
621 /* if error, do not deinterlace */
627 if (img_convert(picture2, dec->pix_fmt, picture,
628 dec->pix_fmt, dec->width, dec->height) < 0) {
629 /* if error, do not copy */
639 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
641 if (picture != picture2)
642 *picture = *picture2;
646 /* we begin to correct av delay at this threshold */
647 #define AV_DELAY_MAX 0.100
650 /* Expects img to be yuv420 */
651 static void fill_pad_region(AVPicture* img, int height, int width,
652 int padtop, int padbottom, int padleft, int padright, int *color) {
657 for (i = 0; i < 3; i++) {
658 shift = (i == 0) ? 0 : 1;
660 if (padtop || padleft) {
661 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
665 if (padleft || padright) {
666 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
667 (img->linesize[i] - (padright >> shift));
669 for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
670 memset(optr, color[i], (padleft + padright) >> shift);
671 optr += img->linesize[i];
675 if (padbottom || padright) {
676 optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
677 memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
682 static int bit_buffer_size= 1024*256;
683 static uint8_t *bit_buffer= NULL;
685 static void do_video_out(AVFormatContext *s,
691 int nb_frames, i, ret;
692 AVFrame *final_picture, *formatted_picture;
693 AVFrame picture_format_temp, picture_crop_temp;
694 uint8_t *buf = NULL, *buf1 = NULL;
695 AVCodecContext *enc, *dec;
696 enum PixelFormat target_pixfmt;
698 avcodec_get_frame_defaults(&picture_format_temp);
699 avcodec_get_frame_defaults(&picture_crop_temp);
701 enc = &ost->st->codec;
702 dec = &ist->st->codec;
704 /* by default, we output a single frame */
709 if(video_sync_method){
711 vdelta = ost->sync_ipts / av_q2d(enc->time_base) - ost->sync_opts;
712 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
715 else if (vdelta > 1.1)
716 nb_frames = lrintf(vdelta);
717 //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);
721 fprintf(stderr, "*** drop!\n");
722 }else if (nb_frames > 1) {
723 nb_frames_dup += nb_frames;
725 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
728 ost->sync_opts= lrintf(ost->sync_ipts / av_q2d(enc->time_base));
730 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
734 /* convert pixel format if needed */
735 target_pixfmt = ost->video_resample || ost->video_pad
736 ? PIX_FMT_YUV420P : enc->pix_fmt;
737 if (dec->pix_fmt != target_pixfmt) {
740 /* create temporary picture */
741 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
742 buf = av_malloc(size);
745 formatted_picture = &picture_format_temp;
746 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
748 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
749 (AVPicture *)in_picture, dec->pix_fmt,
750 dec->width, dec->height) < 0) {
753 fprintf(stderr, "pixel format conversion not handled\n");
758 formatted_picture = in_picture;
761 /* XXX: resampling could be done before raw format conversion in
762 some cases to go faster */
763 /* XXX: only works for YUV420P */
764 if (ost->video_resample) {
765 final_picture = &ost->pict_tmp;
766 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
768 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
769 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
770 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
774 if (enc->pix_fmt != PIX_FMT_YUV420P) {
778 /* create temporary picture */
779 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
780 buf = av_malloc(size);
783 final_picture = &picture_format_temp;
784 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
786 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
787 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
788 enc->width, enc->height) < 0) {
791 fprintf(stderr, "pixel format conversion not handled\n");
796 } else if (ost->video_crop) {
797 picture_crop_temp.data[0] = formatted_picture->data[0] +
798 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
800 picture_crop_temp.data[1] = formatted_picture->data[1] +
801 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
802 (ost->leftBand >> 1);
804 picture_crop_temp.data[2] = formatted_picture->data[2] +
805 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
806 (ost->leftBand >> 1);
808 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
809 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
810 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
811 final_picture = &picture_crop_temp;
812 } else if (ost->video_pad) {
813 final_picture = &ost->pict_tmp;
815 for (i = 0; i < 3; i++) {
816 uint8_t *optr, *iptr;
817 int shift = (i == 0) ? 0 : 1;
820 /* set offset to start writing image into */
821 optr = final_picture->data[i] + (((final_picture->linesize[i] *
822 ost->padtop) + ost->padleft) >> shift);
823 iptr = formatted_picture->data[i];
825 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
826 for (y = 0; y < yheight; y++) {
827 /* copy unpadded image row into padded image row */
828 memcpy(optr, iptr, formatted_picture->linesize[i]);
829 optr += final_picture->linesize[i];
830 iptr += formatted_picture->linesize[i];
834 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
835 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
838 if (enc->pix_fmt != PIX_FMT_YUV420P) {
842 /* create temporary picture */
843 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
844 buf = av_malloc(size);
847 final_picture = &picture_format_temp;
848 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
850 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
851 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
852 enc->width, enc->height) < 0) {
855 fprintf(stderr, "pixel format conversion not handled\n");
861 final_picture = formatted_picture;
863 /* duplicates frame if needed */
864 for(i=0;i<nb_frames;i++) {
866 av_init_packet(&pkt);
867 pkt.stream_index= ost->index;
869 if (s->oformat->flags & AVFMT_RAWPICTURE) {
870 /* raw pictures are written as AVPicture structure to
871 avoid any copies. We support temorarily the older
873 AVFrame* old_frame = enc->coded_frame;
874 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
875 pkt.data= (uint8_t *)final_picture;
876 pkt.size= sizeof(AVPicture);
878 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
879 if(dec->coded_frame && dec->coded_frame->key_frame)
880 pkt.flags |= PKT_FLAG_KEY;
882 av_interleaved_write_frame(s, &pkt);
883 enc->coded_frame = old_frame;
887 big_picture= *final_picture;
888 /* better than nothing: use input picture interlaced
890 big_picture.interlaced_frame = in_picture->interlaced_frame;
891 if(do_interlace_me || do_interlace_dct){
892 if(top_field_first == -1)
893 big_picture.top_field_first = in_picture->top_field_first;
895 big_picture.top_field_first = top_field_first;
898 /* handles sameq here. This is not correct because it may
899 not be a global option */
901 big_picture.quality = ist->st->quality;
903 big_picture.quality = ost->st->quality;
905 big_picture.pict_type = 0;
906 // big_picture.pts = AV_NOPTS_VALUE;
907 big_picture.pts= ost->sync_opts;
908 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
909 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
910 ret = avcodec_encode_video(enc,
911 bit_buffer, bit_buffer_size,
913 //enc->frame_number = enc->real_pict_num;
915 pkt.data= bit_buffer;
918 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
919 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
920 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
921 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
923 if(enc->coded_frame && enc->coded_frame->key_frame)
924 pkt.flags |= PKT_FLAG_KEY;
925 av_interleaved_write_frame(s, &pkt);
927 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
928 // enc->frame_number-1, enc->real_pict_num, ret,
930 /* if two pass, output log */
931 if (ost->logfile && enc->stats_out) {
932 fprintf(ost->logfile, "%s", enc->stats_out);
944 static double psnr(double d){
945 if(d==0) return INFINITY;
946 return -10.0*log(d)/log(10.0);
949 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
952 static FILE *fvstats=NULL;
959 double ti1, bitrate, avg_bitrate;
963 today = localtime(&today2);
964 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
967 fvstats = fopen(filename,"w");
975 enc = &ost->st->codec;
976 if (enc->codec_type == CODEC_TYPE_VIDEO) {
977 frame_number = ost->frame_number;
978 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
979 if (enc->flags&CODEC_FLAG_PSNR)
980 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
982 fprintf(fvstats,"f_size= %6d ", frame_size);
983 /* compute pts value */
984 ti1 = ost->sync_opts * av_q2d(enc->time_base);
988 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
989 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
990 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
991 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
992 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
996 static void print_report(AVFormatContext **output_files,
997 AVOutputStream **ost_table, int nb_ostreams,
1001 AVOutputStream *ost;
1002 AVFormatContext *oc, *os;
1004 AVCodecContext *enc;
1005 int frame_number, vid, i;
1006 double bitrate, ti1, pts;
1007 static int64_t last_time = -1;
1009 if (!is_last_report) {
1011 /* display the report every 0.5 seconds */
1012 cur_time = av_gettime();
1013 if (last_time == -1) {
1014 last_time = cur_time;
1017 if ((cur_time - last_time) < 500000)
1019 last_time = cur_time;
1023 oc = output_files[0];
1025 total_size = url_ftell(&oc->pb);
1030 for(i=0;i<nb_ostreams;i++) {
1032 os = output_files[ost->file_index];
1033 enc = &ost->st->codec;
1034 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1035 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1036 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1038 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1039 frame_number = ost->frame_number;
1040 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%2.1f ",
1041 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1043 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1044 if (enc->flags&CODEC_FLAG_PSNR){
1046 double error, error_sum=0;
1047 double scale, scale_sum=0;
1048 char type[3]= {'Y','U','V'};
1049 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1052 error= enc->error[j];
1053 scale= enc->width*enc->height*255.0*255.0*frame_number;
1055 error= enc->coded_frame->error[j];
1056 scale= enc->width*enc->height*255.0*255.0;
1061 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1063 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1067 /* compute min output value */
1068 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1069 if ((pts < ti1) && (pts > 0))
1075 if (verbose || is_last_report) {
1076 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1078 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1079 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1080 (double)total_size / 1024, ti1, bitrate);
1083 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1084 nb_frames_dup, nb_frames_drop);
1087 fprintf(stderr, "%s \r", buf);
1092 if (is_last_report && verbose >= 0){
1093 int64_t raw= audio_size + video_size + extra_size;
1094 fprintf(stderr, "\n");
1095 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1099 100.0*(total_size - raw)/raw
1104 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1105 static int output_packet(AVInputStream *ist, int ist_index,
1106 AVOutputStream **ost_table, int nb_ostreams,
1107 const AVPacket *pkt)
1109 AVFormatContext *os;
1110 AVOutputStream *ost;
1114 int data_size, got_picture;
1116 void *buffer_to_free;
1117 static int samples_size= 0;
1118 static short *samples= NULL;
1121 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1122 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1123 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1125 // assert(ist->pts == ist->next_pts);
1139 /* decode the packet if needed */
1140 data_buf = NULL; /* fail safe */
1142 if (ist->decoding_needed) {
1143 switch(ist->st->codec.codec_type) {
1144 case CODEC_TYPE_AUDIO:{
1146 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1147 /* XXX: could avoid copy if PCM 16 bits with same
1148 endianness as CPU */
1149 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1155 /* Some bug in mpeg audio decoder gives */
1156 /* data_size < 0, it seems they are overflows */
1157 if (data_size <= 0) {
1158 /* no audio frame */
1161 data_buf = (uint8_t *)samples;
1162 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1163 (ist->st->codec.sample_rate * ist->st->codec.channels);
1165 case CODEC_TYPE_VIDEO:
1166 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1167 /* XXX: allocate picture correctly */
1168 avcodec_get_frame_defaults(&picture);
1170 ret = avcodec_decode_video(&ist->st->codec,
1171 &picture, &got_picture, ptr, len);
1172 ist->st->quality= picture.quality;
1176 /* no picture yet */
1177 goto discard_packet;
1179 if (ist->st->codec.time_base.num != 0) {
1180 ist->next_pts += ((int64_t)AV_TIME_BASE *
1181 ist->st->codec.time_base.num) /
1182 ist->st->codec.time_base.den;
1190 switch(ist->st->codec.codec_type) {
1191 case CODEC_TYPE_AUDIO:
1192 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec.frame_size) /
1193 (ist->st->codec.sample_rate * ist->st->codec.channels);
1195 case CODEC_TYPE_VIDEO:
1196 if (ist->st->codec.time_base.num != 0) {
1197 ist->next_pts += ((int64_t)AV_TIME_BASE *
1198 ist->st->codec.time_base.num) /
1199 ist->st->codec.time_base.den;
1209 buffer_to_free = NULL;
1210 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1211 pre_process_video_frame(ist, (AVPicture *)&picture,
1215 // preprocess audio (volume)
1216 if (ist->st->codec.codec_type == CODEC_TYPE_AUDIO) {
1217 if (audio_volume != 256) {
1220 for(i=0;i<(data_size / sizeof(short));i++) {
1221 int v = ((*volp) * audio_volume + 128) >> 8;
1222 if (v < -32768) v = -32768;
1223 if (v > 32767) v = 32767;
1229 /* frame rate emulation */
1230 if (ist->st->codec.rate_emu) {
1231 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.time_base.num, 1000000, ist->st->codec.time_base.den);
1232 int64_t now = av_gettime() - ist->start;
1240 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1241 is the one of the next displayed one */
1242 /* XXX: add mpeg4 too ? */
1243 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1244 if (ist->st->codec.pict_type != B_TYPE) {
1246 tmp = ist->last_ip_pts;
1247 ist->last_ip_pts = ist->frac_pts.val;
1248 ist->frac_pts.val = tmp;
1252 /* if output time reached then transcode raw format,
1253 encode packets and output them */
1254 if (start_time == 0 || ist->pts >= start_time)
1255 for(i=0;i<nb_ostreams;i++) {
1259 if (ost->source_index == ist_index) {
1260 os = output_files[ost->file_index];
1263 printf("%d: got pts=%0.3f %0.3f\n", i,
1264 (double)pkt->pts / AV_TIME_BASE,
1265 ((double)ist->pts / AV_TIME_BASE) -
1266 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1268 /* set the input output pts pairs */
1269 ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1271 if (ost->encoding_needed) {
1272 switch(ost->st->codec.codec_type) {
1273 case CODEC_TYPE_AUDIO:
1274 do_audio_out(os, ost, ist, data_buf, data_size);
1276 case CODEC_TYPE_VIDEO:
1277 do_video_out(os, ost, ist, &picture, &frame_size);
1278 video_size += frame_size;
1279 if (do_vstats && frame_size)
1280 do_video_stats(os, ost, frame_size);
1286 AVFrame avframe; //FIXME/XXX remove this
1288 av_init_packet(&opkt);
1290 /* no reencoding needed : output the packet directly */
1291 /* force the input stream PTS */
1293 avcodec_get_frame_defaults(&avframe);
1294 ost->st->codec.coded_frame= &avframe;
1295 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1297 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1298 audio_size += data_size;
1299 else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1300 video_size += data_size;
1304 opkt.stream_index= ost->index;
1305 opkt.data= data_buf;
1306 opkt.size= data_size;
1307 if(pkt->pts != AV_NOPTS_VALUE)
1308 opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1310 opkt.pts= AV_NOPTS_VALUE;
1311 opkt.dts= av_rescale_q(av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1312 opkt.flags= pkt->flags;
1314 av_interleaved_write_frame(os, &opkt);
1315 ost->st->codec.frame_number++;
1316 ost->frame_number++;
1320 av_free(buffer_to_free);
1326 for(i=0;i<nb_ostreams;i++) {
1328 if (ost->source_index == ist_index) {
1329 AVCodecContext *enc= &ost->st->codec;
1330 os = output_files[ost->file_index];
1332 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1334 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1337 if (ost->encoding_needed) {
1340 av_init_packet(&pkt);
1341 pkt.stream_index= ost->index;
1343 switch(ost->st->codec.codec_type) {
1344 case CODEC_TYPE_AUDIO:
1345 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1347 pkt.flags |= PKT_FLAG_KEY;
1349 case CODEC_TYPE_VIDEO:
1350 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1352 if(enc->coded_frame && enc->coded_frame->key_frame)
1353 pkt.flags |= PKT_FLAG_KEY;
1354 if (ost->logfile && enc->stats_out) {
1355 fprintf(ost->logfile, "%s", enc->stats_out);
1364 pkt.data= bit_buffer;
1366 if(enc->coded_frame)
1367 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1368 av_interleaved_write_frame(os, &pkt);
1382 * The following code is the main loop of the file converter
1384 static int av_encode(AVFormatContext **output_files,
1385 int nb_output_files,
1386 AVFormatContext **input_files,
1388 AVStreamMap *stream_maps, int nb_stream_maps)
1390 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1391 AVFormatContext *is, *os;
1392 AVCodecContext *codec, *icodec;
1393 AVOutputStream *ost, **ost_table = NULL;
1394 AVInputStream *ist, **ist_table = NULL;
1395 AVInputFile *file_table;
1396 AVFormatContext *stream_no_data;
1399 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1403 /* input stream init */
1405 for(i=0;i<nb_input_files;i++) {
1406 is = input_files[i];
1407 file_table[i].ist_index = j;
1408 file_table[i].nb_streams = is->nb_streams;
1409 j += is->nb_streams;
1413 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1417 for(i=0;i<nb_istreams;i++) {
1418 ist = av_mallocz(sizeof(AVInputStream));
1424 for(i=0;i<nb_input_files;i++) {
1425 is = input_files[i];
1426 for(k=0;k<is->nb_streams;k++) {
1427 ist = ist_table[j++];
1428 ist->st = is->streams[k];
1429 ist->file_index = i;
1431 ist->discard = 1; /* the stream is discarded by default
1434 if (ist->st->codec.rate_emu) {
1435 ist->start = av_gettime();
1441 /* output stream init */
1443 for(i=0;i<nb_output_files;i++) {
1444 os = output_files[i];
1445 nb_ostreams += os->nb_streams;
1447 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1448 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1452 /* Sanity check the mapping args -- do the input files & streams exist? */
1453 for(i=0;i<nb_stream_maps;i++) {
1454 int fi = stream_maps[i].file_index;
1455 int si = stream_maps[i].stream_index;
1457 if (fi < 0 || fi > nb_input_files - 1 ||
1458 si < 0 || si > file_table[fi].nb_streams - 1) {
1459 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1464 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1467 for(i=0;i<nb_ostreams;i++) {
1468 ost = av_mallocz(sizeof(AVOutputStream));
1475 for(k=0;k<nb_output_files;k++) {
1476 os = output_files[k];
1477 for(i=0;i<os->nb_streams;i++) {
1479 ost = ost_table[n++];
1480 ost->file_index = k;
1482 ost->st = os->streams[i];
1483 if (nb_stream_maps > 0) {
1484 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1485 stream_maps[n-1].stream_index;
1487 /* Sanity check that the stream types match */
1488 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1489 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1490 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1491 ost->file_index, ost->index);
1496 /* get corresponding input stream index : we select the first one with the right type */
1498 for(j=0;j<nb_istreams;j++) {
1501 ist->st->codec.codec_type == ost->st->codec.codec_type) {
1502 ost->source_index = j;
1509 /* try again and reuse existing stream */
1510 for(j=0;j<nb_istreams;j++) {
1512 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1513 ost->source_index = j;
1518 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1519 ost->file_index, ost->index);
1524 ist = ist_table[ost->source_index];
1529 /* for each output stream, we compute the right encoding parameters */
1530 for(i=0;i<nb_ostreams;i++) {
1532 ist = ist_table[ost->source_index];
1534 codec = &ost->st->codec;
1535 icodec = &ist->st->codec;
1537 if (ost->st->stream_copy) {
1538 /* if stream_copy is selected, no need to decode or encode */
1539 codec->codec_id = icodec->codec_id;
1540 codec->codec_type = icodec->codec_type;
1541 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1542 codec->bit_rate = icodec->bit_rate;
1543 codec->extradata= icodec->extradata;
1544 codec->extradata_size= icodec->extradata_size;
1545 switch(codec->codec_type) {
1546 case CODEC_TYPE_AUDIO:
1547 codec->sample_rate = icodec->sample_rate;
1548 codec->channels = icodec->channels;
1549 codec->frame_size = icodec->frame_size;
1550 codec->block_align= icodec->block_align;
1552 case CODEC_TYPE_VIDEO:
1553 codec->time_base = icodec->time_base;
1554 codec->width = icodec->width;
1555 codec->height = icodec->height;
1556 codec->has_b_frames = icodec->has_b_frames;
1562 switch(codec->codec_type) {
1563 case CODEC_TYPE_AUDIO:
1564 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1567 if (codec->channels == icodec->channels &&
1568 codec->sample_rate == icodec->sample_rate) {
1569 ost->audio_resample = 0;
1571 if (codec->channels != icodec->channels &&
1572 (icodec->codec_id == CODEC_ID_AC3 ||
1573 icodec->codec_id == CODEC_ID_DTS)) {
1574 /* Special case for 5:1 AC3 and DTS input */
1575 /* and mono or stereo output */
1576 /* Request specific number of channels */
1577 icodec->channels = codec->channels;
1578 if (codec->sample_rate == icodec->sample_rate)
1579 ost->audio_resample = 0;
1581 ost->audio_resample = 1;
1584 ost->audio_resample = 1;
1587 if(audio_sync_method>1)
1588 ost->audio_resample = 1;
1590 if(ost->audio_resample){
1591 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1592 codec->sample_rate, icodec->sample_rate);
1594 printf("Can't resample. Aborting.\n");
1598 ist->decoding_needed = 1;
1599 ost->encoding_needed = 1;
1601 case CODEC_TYPE_VIDEO:
1602 if (codec->width == icodec->width &&
1603 codec->height == icodec->height &&
1604 frame_topBand == 0 &&
1605 frame_bottomBand == 0 &&
1606 frame_leftBand == 0 &&
1607 frame_rightBand == 0 &&
1608 frame_padtop == 0 &&
1609 frame_padbottom == 0 &&
1610 frame_padleft == 0 &&
1611 frame_padright == 0)
1613 ost->video_resample = 0;
1614 ost->video_crop = 0;
1616 } else if ((codec->width == icodec->width -
1617 (frame_leftBand + frame_rightBand)) &&
1618 (codec->height == icodec->height -
1619 (frame_topBand + frame_bottomBand)))
1621 ost->video_resample = 0;
1622 ost->video_crop = 1;
1623 ost->topBand = frame_topBand;
1624 ost->leftBand = frame_leftBand;
1625 } else if ((codec->width == icodec->width +
1626 (frame_padleft + frame_padright)) &&
1627 (codec->height == icodec->height +
1628 (frame_padtop + frame_padbottom))) {
1629 ost->video_resample = 0;
1630 ost->video_crop = 0;
1632 ost->padtop = frame_padtop;
1633 ost->padleft = frame_padleft;
1634 ost->padbottom = frame_padbottom;
1635 ost->padright = frame_padright;
1636 avcodec_get_frame_defaults(&ost->pict_tmp);
1637 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1638 codec->width, codec->height ) )
1641 ost->video_resample = 1;
1642 ost->video_crop = 0; // cropping is handled as part of resample
1643 avcodec_get_frame_defaults(&ost->pict_tmp);
1644 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1645 codec->width, codec->height ) )
1648 ost->img_resample_ctx = img_resample_full_init(
1649 ost->st->codec.width, ost->st->codec.height,
1650 ist->st->codec.width, ist->st->codec.height,
1651 frame_topBand, frame_bottomBand,
1652 frame_leftBand, frame_rightBand,
1653 frame_padtop, frame_padbottom,
1654 frame_padleft, frame_padright);
1656 ost->padtop = frame_padtop;
1657 ost->padleft = frame_padleft;
1658 ost->padbottom = frame_padbottom;
1659 ost->padright = frame_padright;
1662 ost->encoding_needed = 1;
1663 ist->decoding_needed = 1;
1669 if (ost->encoding_needed &&
1670 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1671 char logfilename[1024];
1676 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1678 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1679 if (codec->flags & CODEC_FLAG_PASS1) {
1680 f = fopen(logfilename, "w");
1682 perror(logfilename);
1687 /* read the log file */
1688 f = fopen(logfilename, "r");
1690 perror(logfilename);
1693 fseek(f, 0, SEEK_END);
1695 fseek(f, 0, SEEK_SET);
1696 logbuffer = av_malloc(size + 1);
1698 fprintf(stderr, "Could not allocate log buffer\n");
1701 size = fread(logbuffer, 1, size, f);
1703 logbuffer[size] = '\0';
1704 codec->stats_in = logbuffer;
1708 if(codec->codec_type == CODEC_TYPE_VIDEO){
1709 int size= codec->width * codec->height;
1710 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1715 bit_buffer = av_malloc(bit_buffer_size);
1719 /* dump the file output parameters - cannot be done before in case
1721 for(i=0;i<nb_output_files;i++) {
1722 dump_format(output_files[i], i, output_files[i]->filename, 1);
1725 /* dump the stream mapping */
1727 fprintf(stderr, "Stream mapping:\n");
1728 for(i=0;i<nb_ostreams;i++) {
1730 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
1731 ist_table[ost->source_index]->file_index,
1732 ist_table[ost->source_index]->index,
1738 /* open each encoder */
1739 for(i=0;i<nb_ostreams;i++) {
1741 if (ost->encoding_needed) {
1743 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1745 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1746 ost->file_index, ost->index);
1749 if (avcodec_open(&ost->st->codec, codec) < 0) {
1750 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1751 ost->file_index, ost->index);
1754 extra_size += ost->st->codec.extradata_size;
1758 /* open each decoder */
1759 for(i=0;i<nb_istreams;i++) {
1761 if (ist->decoding_needed) {
1763 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1765 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1766 ist->st->codec.codec_id, ist->file_index, ist->index);
1769 if (avcodec_open(&ist->st->codec, codec) < 0) {
1770 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1771 ist->file_index, ist->index);
1774 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1775 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1780 for(i=0;i<nb_istreams;i++) {
1782 is = input_files[ist->file_index];
1784 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1785 if(ist->st->start_time == AV_NOPTS_VALUE)
1787 if(input_files_ts_offset[ist->file_index])
1788 ist->next_pts= AV_NOPTS_VALUE;
1792 /* compute buffer size max (should use a complete heuristic) */
1793 for(i=0;i<nb_input_files;i++) {
1794 file_table[i].buffer_size_max = 2048;
1797 /* set meta data information from input file if required */
1798 for (i=0;i<nb_meta_data_maps;i++) {
1799 AVFormatContext *out_file;
1800 AVFormatContext *in_file;
1802 int out_file_index = meta_data_maps[i].out_file;
1803 int in_file_index = meta_data_maps[i].in_file;
1804 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1805 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1809 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1810 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1815 out_file = output_files[out_file_index];
1816 in_file = input_files[in_file_index];
1818 strcpy(out_file->title, in_file->title);
1819 strcpy(out_file->author, in_file->author);
1820 strcpy(out_file->copyright, in_file->copyright);
1821 strcpy(out_file->comment, in_file->comment);
1822 strcpy(out_file->album, in_file->album);
1823 out_file->year = in_file->year;
1824 out_file->track = in_file->track;
1825 strcpy(out_file->genre, in_file->genre);
1828 /* open files and write file headers */
1829 for(i=0;i<nb_output_files;i++) {
1830 os = output_files[i];
1831 if (av_write_header(os) < 0) {
1832 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1838 #ifndef CONFIG_WIN32
1839 if ( !using_stdin && verbose >= 0) {
1840 fprintf(stderr, "Press [q] to stop encoding\n");
1841 url_set_interrupt_cb(decode_interrupt_cb);
1849 for(; received_sigterm == 0;) {
1850 int file_index, ist_index;
1858 /* if 'q' pressed, exits */
1862 /* read_key() returns 0 on EOF */
1868 /* select the stream that we must read now by looking at the
1869 smallest output pts */
1871 for(i=0;i<nb_ostreams;i++) {
1874 os = output_files[ost->file_index];
1875 ist = ist_table[ost->source_index];
1876 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1877 opts = ost->sync_opts * av_q2d(ost->st->codec.time_base);
1879 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1880 ipts = (double)ist->pts;
1881 if (!file_table[ist->file_index].eof_reached){
1882 if(ipts < ipts_min) {
1884 if(input_sync ) file_index = ist->file_index;
1886 if(opts < opts_min) {
1888 if(!input_sync) file_index = ist->file_index;
1891 if(ost->frame_number >= max_frames[ost->st->codec.codec_type]){
1896 /* if none, if is finished */
1897 if (file_index < 0) {
1901 /* finish if recording time exhausted */
1902 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1905 /* finish if limit size exhausted */
1906 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1909 /* read a frame from it and output it in the fifo */
1910 is = input_files[file_index];
1911 if (av_read_frame(is, &pkt) < 0) {
1912 file_table[file_index].eof_reached = 1;
1913 if (opt_shortest) break; else continue; //
1917 stream_no_data = is;
1922 av_pkt_dump(stdout, &pkt, do_hex_dump);
1924 /* the following test is needed in case new streams appear
1925 dynamically in stream : we ignore them */
1926 if (pkt.stream_index >= file_table[file_index].nb_streams)
1927 goto discard_packet;
1928 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1929 ist = ist_table[ist_index];
1931 goto discard_packet;
1933 // 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);
1934 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1935 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1936 if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1937 input_files_ts_offset[ist->file_index]-= delta;
1939 fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1940 for(i=0; i<file_table[file_index].nb_streams; i++){
1941 int index= file_table[file_index].ist_index + i;
1942 ist_table[index]->next_pts += delta;
1943 ist_table[index]->is_start=1;
1948 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1949 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1952 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1953 ist->file_index, ist->index);
1955 av_free_packet(&pkt);
1960 av_free_packet(&pkt);
1962 /* dump report by using the output first video and audio streams */
1963 print_report(output_files, ost_table, nb_ostreams, 0);
1966 /* at the end of stream, we must flush the decoder buffers */
1967 for(i=0;i<nb_istreams;i++) {
1969 if (ist->decoding_needed) {
1970 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1976 /* write the trailer if needed and close file */
1977 for(i=0;i<nb_output_files;i++) {
1978 os = output_files[i];
1979 av_write_trailer(os);
1982 /* dump report by using the first video and audio streams */
1983 print_report(output_files, ost_table, nb_ostreams, 1);
1985 /* close each encoder */
1986 for(i=0;i<nb_ostreams;i++) {
1988 if (ost->encoding_needed) {
1989 av_freep(&ost->st->codec.stats_in);
1990 avcodec_close(&ost->st->codec);
1994 /* close each decoder */
1995 for(i=0;i<nb_istreams;i++) {
1997 if (ist->decoding_needed) {
1998 avcodec_close(&ist->st->codec);
2006 av_freep(&bit_buffer);
2007 av_free(file_table);
2010 for(i=0;i<nb_istreams;i++) {
2017 for(i=0;i<nb_ostreams;i++) {
2021 fclose(ost->logfile);
2022 ost->logfile = NULL;
2024 fifo_free(&ost->fifo); /* works even if fifo is not
2025 initialized but set to zero */
2026 av_free(ost->pict_tmp.data[0]);
2027 if (ost->video_resample)
2028 img_resample_close(ost->img_resample_ctx);
2029 if (ost->audio_resample)
2030 audio_resample_close(ost->resample);
2043 int file_read(const char *filename)
2046 unsigned char buffer[1024];
2049 if (url_open(&h, filename, O_RDONLY) < 0) {
2050 printf("could not open '%s'\n", filename);
2054 len = url_read(h, buffer, sizeof(buffer));
2057 for(i=0;i<len;i++) putchar(buffer[i]);
2064 static void opt_image_format(const char *arg)
2068 for(f = first_image_format; f != NULL; f = f->next) {
2069 if (!strcmp(arg, f->name))
2073 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2079 static void opt_format(const char *arg)
2081 /* compatibility stuff for pgmyuv */
2082 if (!strcmp(arg, "pgmyuv")) {
2083 pgmyuv_compatibility_hack=1;
2084 // opt_image_format(arg);
2088 file_iformat = av_find_input_format(arg);
2089 file_oformat = guess_format(arg, NULL, NULL);
2090 if (!file_iformat && !file_oformat) {
2091 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2096 static void opt_video_bitrate(const char *arg)
2098 video_bit_rate = atoi(arg) * 1000;
2101 static void opt_video_bitrate_tolerance(const char *arg)
2103 video_bit_rate_tolerance = atoi(arg) * 1000;
2106 static void opt_video_bitrate_max(const char *arg)
2108 video_rc_max_rate = atoi(arg) * 1000;
2111 static void opt_video_bitrate_min(const char *arg)
2113 video_rc_min_rate = atoi(arg) * 1000;
2116 static void opt_video_buffer_size(const char *arg)
2118 video_rc_buffer_size = atoi(arg) * 8*1024;
2121 static void opt_video_rc_eq(char *arg)
2126 static void opt_video_rc_override_string(char *arg)
2128 video_rc_override_string = arg;
2132 static void opt_workaround_bugs(const char *arg)
2134 workaround_bugs = atoi(arg);
2137 static void opt_dct_algo(const char *arg)
2139 dct_algo = atoi(arg);
2142 static void opt_idct_algo(const char *arg)
2144 idct_algo = atoi(arg);
2147 static void opt_me_threshold(const char *arg)
2149 me_threshold = atoi(arg);
2152 static void opt_mb_threshold(const char *arg)
2154 mb_threshold = atoi(arg);
2157 static void opt_error_resilience(const char *arg)
2159 error_resilience = atoi(arg);
2162 static void opt_error_concealment(const char *arg)
2164 error_concealment = atoi(arg);
2167 static void opt_debug(const char *arg)
2172 static void opt_vismv(const char *arg)
2174 debug_mv = atoi(arg);
2177 static void opt_verbose(const char *arg)
2179 verbose = atoi(arg);
2180 av_log_set_level(atoi(arg));
2183 static void opt_frame_rate(const char *arg)
2185 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2186 fprintf(stderr, "Incorrect frame rate\n");
2191 static void opt_frame_crop_top(const char *arg)
2193 frame_topBand = atoi(arg);
2194 if (frame_topBand < 0) {
2195 fprintf(stderr, "Incorrect top crop size\n");
2198 if ((frame_topBand % 2) != 0) {
2199 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2202 if ((frame_topBand) >= frame_height){
2203 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2206 frame_height -= frame_topBand;
2209 static void opt_frame_crop_bottom(const char *arg)
2211 frame_bottomBand = atoi(arg);
2212 if (frame_bottomBand < 0) {
2213 fprintf(stderr, "Incorrect bottom crop size\n");
2216 if ((frame_bottomBand % 2) != 0) {
2217 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2220 if ((frame_bottomBand) >= frame_height){
2221 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2224 frame_height -= frame_bottomBand;
2227 static void opt_frame_crop_left(const char *arg)
2229 frame_leftBand = atoi(arg);
2230 if (frame_leftBand < 0) {
2231 fprintf(stderr, "Incorrect left crop size\n");
2234 if ((frame_leftBand % 2) != 0) {
2235 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2238 if ((frame_leftBand) >= frame_width){
2239 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2242 frame_width -= frame_leftBand;
2245 static void opt_frame_crop_right(const char *arg)
2247 frame_rightBand = atoi(arg);
2248 if (frame_rightBand < 0) {
2249 fprintf(stderr, "Incorrect right crop size\n");
2252 if ((frame_rightBand % 2) != 0) {
2253 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2256 if ((frame_rightBand) >= frame_width){
2257 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2260 frame_width -= frame_rightBand;
2263 static void opt_frame_size(const char *arg)
2265 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2266 fprintf(stderr, "Incorrect frame size\n");
2269 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2270 fprintf(stderr, "Frame size must be a multiple of 2\n");
2276 #define SCALEBITS 10
2277 #define ONE_HALF (1 << (SCALEBITS - 1))
2278 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2280 #define RGB_TO_Y(r, g, b) \
2281 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2282 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2284 #define RGB_TO_U(r1, g1, b1, shift)\
2285 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2286 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2288 #define RGB_TO_V(r1, g1, b1, shift)\
2289 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2290 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2292 static void opt_pad_color(const char *arg) {
2293 /* Input is expected to be six hex digits similar to
2294 how colors are expressed in html tags (but without the #) */
2295 int rgb = strtol(arg, NULL, 16);
2299 g = ((rgb >> 8) & 255);
2302 padcolor[0] = RGB_TO_Y(r,g,b);
2303 padcolor[1] = RGB_TO_U(r,g,b,0);
2304 padcolor[2] = RGB_TO_V(r,g,b,0);
2307 static void opt_frame_pad_top(const char *arg)
2309 frame_padtop = atoi(arg);
2310 if (frame_padtop < 0) {
2311 fprintf(stderr, "Incorrect top pad size\n");
2314 if ((frame_padtop % 2) != 0) {
2315 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2320 static void opt_frame_pad_bottom(const char *arg)
2322 frame_padbottom = atoi(arg);
2323 if (frame_padbottom < 0) {
2324 fprintf(stderr, "Incorrect bottom pad size\n");
2327 if ((frame_padbottom % 2) != 0) {
2328 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2334 static void opt_frame_pad_left(const char *arg)
2336 frame_padleft = atoi(arg);
2337 if (frame_padleft < 0) {
2338 fprintf(stderr, "Incorrect left pad size\n");
2341 if ((frame_padleft % 2) != 0) {
2342 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2348 static void opt_frame_pad_right(const char *arg)
2350 frame_padright = atoi(arg);
2351 if (frame_padright < 0) {
2352 fprintf(stderr, "Incorrect right pad size\n");
2355 if ((frame_padright % 2) != 0) {
2356 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2362 static void opt_frame_pix_fmt(const char *arg)
2364 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2367 static void opt_frame_aspect_ratio(const char *arg)
2373 p = strchr(arg, ':');
2375 x = strtol(arg, (char **)&arg, 10);
2377 y = strtol(arg+1, (char **)&arg, 10);
2379 ar = (double)x / (double)y;
2381 ar = strtod(arg, (char **)&arg);
2384 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2387 frame_aspect_ratio = ar;
2390 static void opt_gop_size(const char *arg)
2392 gop_size = atoi(arg);
2395 static void opt_b_frames(const char *arg)
2397 b_frames = atoi(arg);
2398 if (b_frames > FF_MAX_B_FRAMES) {
2399 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2401 } else if (b_frames < 1) {
2402 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2407 static void opt_mb_decision(const char *arg)
2409 mb_decision = atoi(arg);
2412 static void opt_mb_cmp(const char *arg)
2417 static void opt_ildct_cmp(const char *arg)
2419 ildct_cmp = atoi(arg);
2422 static void opt_sub_cmp(const char *arg)
2424 sub_cmp = atoi(arg);
2427 static void opt_cmp(const char *arg)
2432 static void opt_pre_cmp(const char *arg)
2434 pre_cmp = atoi(arg);
2437 static void opt_pre_me(const char *arg)
2442 static void opt_lumi_mask(const char *arg)
2444 lumi_mask = atof(arg);
2447 static void opt_dark_mask(const char *arg)
2449 dark_mask = atof(arg);
2452 static void opt_scplx_mask(const char *arg)
2454 scplx_mask = atof(arg);
2457 static void opt_tcplx_mask(const char *arg)
2459 tcplx_mask = atof(arg);
2462 static void opt_p_mask(const char *arg)
2467 static void opt_qscale(const char *arg)
2469 video_qscale = atof(arg);
2470 if (video_qscale < 0.01 ||
2471 video_qscale > 255) {
2472 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2477 static void opt_qsquish(const char *arg)
2479 video_qsquish = atof(arg);
2480 if (video_qsquish < 0.0 ||
2481 video_qsquish > 99.0) {
2482 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2487 static void opt_lelim(const char *arg)
2489 video_lelim = atoi(arg);
2490 if (video_lelim < -99 ||
2492 fprintf(stderr, "lelim must be >= -99 and <= 99\n");
2497 static void opt_celim(const char *arg)
2499 video_celim = atoi(arg);
2500 if (video_celim < -99 ||
2502 fprintf(stderr, "celim must be >= -99 and <= 99\n");
2507 static void opt_lmax(const char *arg)
2509 video_lmax = atof(arg)*FF_QP2LAMBDA;
2512 static void opt_lmin(const char *arg)
2514 video_lmin = atof(arg)*FF_QP2LAMBDA;
2517 static void opt_qmin(const char *arg)
2519 video_qmin = atoi(arg);
2520 if (video_qmin < 1 ||
2522 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2527 static void opt_qmax(const char *arg)
2529 video_qmax = atoi(arg);
2530 if (video_qmax < 1 ||
2532 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2537 static void opt_mb_lmin(const char *arg)
2539 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2540 if (video_mb_lmin < 1 ||
2541 video_mb_lmin > FF_LAMBDA_MAX) {
2542 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2547 static void opt_mb_lmax(const char *arg)
2549 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2550 if (video_mb_lmax < 1 ||
2551 video_mb_lmax > FF_LAMBDA_MAX) {
2552 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2557 static void opt_qdiff(const char *arg)
2559 video_qdiff = atoi(arg);
2560 if (video_qdiff < 0 ||
2562 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2567 static void opt_qblur(const char *arg)
2569 video_qblur = atof(arg);
2572 static void opt_qcomp(const char *arg)
2574 video_qcomp = atof(arg);
2577 static void opt_rc_initial_cplx(const char *arg)
2579 video_rc_initial_cplx = atof(arg);
2581 static void opt_b_qfactor(const char *arg)
2583 video_b_qfactor = atof(arg);
2585 static void opt_i_qfactor(const char *arg)
2587 video_i_qfactor = atof(arg);
2589 static void opt_b_qoffset(const char *arg)
2591 video_b_qoffset = atof(arg);
2593 static void opt_i_qoffset(const char *arg)
2595 video_i_qoffset = atof(arg);
2598 static void opt_ibias(const char *arg)
2600 video_intra_quant_bias = atoi(arg);
2602 static void opt_pbias(const char *arg)
2604 video_inter_quant_bias = atoi(arg);
2607 static void opt_packet_size(const char *arg)
2609 packet_size= atoi(arg);
2612 static void opt_error_rate(const char *arg)
2614 error_rate= atoi(arg);
2617 static void opt_strict(const char *arg)
2622 static void opt_top_field_first(const char *arg)
2624 top_field_first= atoi(arg);
2627 static void opt_noise_reduction(const char *arg)
2629 noise_reduction= atoi(arg);
2632 static void opt_qns(const char *arg)
2637 static void opt_sc_threshold(const char *arg)
2639 sc_threshold= atoi(arg);
2642 static void opt_me_range(const char *arg)
2644 me_range = atoi(arg);
2647 static void opt_thread_count(const char *arg)
2649 thread_count= atoi(arg);
2650 #if !defined(HAVE_THREADS)
2652 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2656 static void opt_audio_bitrate(const char *arg)
2658 audio_bit_rate = atoi(arg) * 1000;
2661 static void opt_audio_rate(const char *arg)
2663 audio_sample_rate = atoi(arg);
2666 static void opt_audio_channels(const char *arg)
2668 audio_channels = atoi(arg);
2671 static void opt_video_device(const char *arg)
2673 video_device = av_strdup(arg);
2676 static void opt_grab_device(const char *arg)
2678 grab_device = av_strdup(arg);
2681 static void opt_video_channel(const char *arg)
2683 video_channel = strtol(arg, NULL, 0);
2686 static void opt_video_standard(const char *arg)
2688 video_standard = av_strdup(arg);
2691 static void opt_audio_device(const char *arg)
2693 audio_device = av_strdup(arg);
2696 static void opt_audio_codec(const char *arg)
2700 if (!strcmp(arg, "copy")) {
2701 audio_stream_copy = 1;
2705 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2710 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2713 audio_codec_id = p->id;
2718 static void opt_audio_tag(const char *arg)
2721 audio_codec_tag= strtol(arg, &tail, 0);
2724 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2727 static void opt_video_tag(const char *arg)
2730 video_codec_tag= strtol(arg, &tail, 0);
2733 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2736 static void add_frame_hooker(const char *arg)
2741 char *args = av_strdup(arg);
2745 argv[0] = strtok(args, " ");
2746 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2749 i = frame_hook_add(argc, argv);
2752 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2757 const char *motion_str[] = {
2767 static void opt_motion_estimation(const char *arg)
2773 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2776 if (!strcmp(*p, arg))
2780 me_method = (p - motion_str) + 1;
2783 static void opt_video_codec(const char *arg)
2787 if (!strcmp(arg, "copy")) {
2788 video_stream_copy = 1;
2792 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2797 fprintf(stderr, "Unknown video codec '%s'\n", arg);
2800 video_codec_id = p->id;
2805 static void opt_map(const char *arg)
2811 m = &stream_maps[nb_stream_maps++];
2813 m->file_index = strtol(arg, (char **)&p, 0);
2817 m->stream_index = strtol(p, (char **)&p, 0);
2820 static void opt_map_meta_data(const char *arg)
2826 m = &meta_data_maps[nb_meta_data_maps++];
2828 m->out_file = strtol(arg, (char **)&p, 0);
2832 m->in_file = strtol(p, (char **)&p, 0);
2835 static void opt_recording_time(const char *arg)
2837 recording_time = parse_date(arg, 1);
2840 static void opt_start_time(const char *arg)
2842 start_time = parse_date(arg, 1);
2845 static void opt_rec_timestamp(const char *arg)
2847 rec_timestamp = parse_date(arg, 0) / 1000000;
2850 static void opt_input_ts_offset(const char *arg)
2852 input_ts_offset = parse_date(arg, 1);
2855 static void opt_input_file(const char *filename)
2857 AVFormatContext *ic;
2858 AVFormatParameters params, *ap = ¶ms;
2859 int err, i, ret, rfps, rfps_base;
2862 if (!strcmp(filename, "-"))
2865 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2866 !strcmp( filename, "/dev/stdin" );
2868 /* get default parameters from command line */
2869 memset(ap, 0, sizeof(*ap));
2870 ap->sample_rate = audio_sample_rate;
2871 ap->channels = audio_channels;
2872 ap->time_base.den = frame_rate;
2873 ap->time_base.num = frame_rate_base;
2874 ap->width = frame_width + frame_padleft + frame_padright;
2875 ap->height = frame_height + frame_padtop + frame_padbottom;
2876 ap->image_format = image_format;
2877 ap->pix_fmt = frame_pix_fmt;
2878 ap->device = grab_device;
2879 ap->channel = video_channel;
2880 ap->standard = video_standard;
2881 ap->video_codec_id = video_codec_id;
2882 ap->audio_codec_id = audio_codec_id;
2883 if(pgmyuv_compatibility_hack)
2884 ap->video_codec_id= CODEC_ID_PGMYUV;
2886 /* open the input file with generic libav function */
2887 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2889 print_error(filename, err);
2893 /* If not enough info to get the stream parameters, we decode the
2894 first frames to get it. (used in mpeg case for example) */
2895 ret = av_find_stream_info(ic);
2896 if (ret < 0 && verbose >= 0) {
2897 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2901 timestamp = start_time;
2902 /* add the stream start time */
2903 if (ic->start_time != AV_NOPTS_VALUE)
2904 timestamp += ic->start_time;
2906 /* if seeking requested, we execute it */
2907 if (start_time != 0) {
2908 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2910 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2911 filename, (double)timestamp / AV_TIME_BASE);
2913 /* reset seek info */
2917 /* update the current parameters so that they match the one of the input stream */
2918 for(i=0;i<ic->nb_streams;i++) {
2919 AVCodecContext *enc = &ic->streams[i]->codec;
2920 #if defined(HAVE_THREADS)
2922 avcodec_thread_init(enc, thread_count);
2924 enc->thread_count= thread_count;
2925 switch(enc->codec_type) {
2926 case CODEC_TYPE_AUDIO:
2927 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2928 audio_channels = enc->channels;
2929 audio_sample_rate = enc->sample_rate;
2931 ic->streams[i]->discard= AVDISCARD_ALL;
2933 case CODEC_TYPE_VIDEO:
2934 frame_height = enc->height;
2935 frame_width = enc->width;
2936 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2937 frame_pix_fmt = enc->pix_fmt;
2938 rfps = ic->streams[i]->r_frame_rate.num;
2939 rfps_base = ic->streams[i]->r_frame_rate.den;
2940 enc->workaround_bugs = workaround_bugs;
2941 enc->error_resilience = error_resilience;
2942 enc->error_concealment = error_concealment;
2943 enc->idct_algo = idct_algo;
2945 enc->debug_mv = debug_mv;
2946 enc->lowres= lowres;
2948 enc->flags|= CODEC_FLAG_BITEXACT;
2950 enc->debug |= FF_DEBUG_MV;
2952 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2955 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2956 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2958 (float)rfps / rfps_base, rfps, rfps_base);
2960 /* update the current frame rate to match the stream frame rate */
2962 frame_rate_base = rfps_base;
2964 enc->rate_emu = rate_emu;
2966 ic->streams[i]->discard= AVDISCARD_ALL;
2967 else if(video_discard)
2968 ic->streams[i]->discard= video_discard;
2970 case CODEC_TYPE_DATA:
2977 input_files[nb_input_files] = ic;
2978 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2979 /* dump the file content */
2981 dump_format(ic, nb_input_files, filename, 0);
2984 file_iformat = NULL;
2985 file_oformat = NULL;
2986 image_format = NULL;
2994 static void opt_grab(const char *arg)
2996 file_iformat = av_find_input_format(arg);
3000 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
3002 int has_video, has_audio, i, j;
3003 AVFormatContext *ic;
3007 for(j=0;j<nb_input_files;j++) {
3008 ic = input_files[j];
3009 for(i=0;i<ic->nb_streams;i++) {
3010 AVCodecContext *enc = &ic->streams[i]->codec;
3011 switch(enc->codec_type) {
3012 case CODEC_TYPE_AUDIO:
3015 case CODEC_TYPE_VIDEO:
3018 case CODEC_TYPE_DATA:
3025 *has_video_ptr = has_video;
3026 *has_audio_ptr = has_audio;
3029 static void opt_output_file(const char *filename)
3032 AVFormatContext *oc;
3033 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
3035 AVFormatParameters params, *ap = ¶ms;
3037 if (!strcmp(filename, "-"))
3040 oc = av_alloc_format_context();
3042 if (!file_oformat) {
3043 file_oformat = guess_format(NULL, filename, NULL);
3044 if (!file_oformat) {
3045 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3051 oc->oformat = file_oformat;
3053 if (!strcmp(file_oformat->name, "ffm") &&
3054 strstart(filename, "http:", NULL)) {
3055 /* special case for files sent to ffserver: we get the stream
3056 parameters from ffserver */
3057 if (read_ffserver_streams(oc, filename) < 0) {
3058 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3062 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
3063 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
3065 /* disable if no corresponding type found and at least one
3067 if (nb_input_files > 0) {
3068 check_audio_video_inputs(&input_has_video, &input_has_audio);
3069 if (!input_has_video)
3071 if (!input_has_audio)
3075 /* manual disable */
3076 if (audio_disable) {
3079 if (video_disable) {
3085 AVCodecContext *video_enc;
3087 st = av_new_stream(oc, nb_streams++);
3089 fprintf(stderr, "Could not alloc stream\n");
3092 #if defined(HAVE_THREADS)
3094 avcodec_thread_init(&st->codec, thread_count);
3097 video_enc = &st->codec;
3100 video_enc->codec_tag= video_codec_tag;
3102 if (file_oformat->flags & AVFMT_GLOBALHEADER)
3103 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3104 if (video_stream_copy) {
3105 st->stream_copy = 1;
3106 video_enc->codec_type = CODEC_TYPE_VIDEO;
3112 codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_VIDEO);
3113 if (video_codec_id != CODEC_ID_NONE)
3114 codec_id = video_codec_id;
3116 video_enc->codec_id = codec_id;
3117 codec = avcodec_find_encoder(codec_id);
3119 video_enc->bit_rate = video_bit_rate;
3120 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3121 video_enc->time_base.den = frame_rate;
3122 video_enc->time_base.num = frame_rate_base;
3123 if(codec && codec->supported_framerates){
3124 const AVRational *p= codec->supported_framerates;
3125 AVRational req= (AVRational){frame_rate, frame_rate_base};
3126 const AVRational *best=NULL;
3127 AVRational best_error= (AVRational){INT_MAX, 1};
3128 for(; p->den!=0; p++){
3129 AVRational error= av_sub_q(req, *p);
3130 if(error.num <0) error.num *= -1;
3131 if(av_cmp_q(error, best_error) < 0){
3136 video_enc->time_base.den= best->num;
3137 video_enc->time_base.num= best->den;
3140 video_enc->width = frame_width + frame_padright + frame_padleft;
3141 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3142 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3143 video_enc->pix_fmt = frame_pix_fmt;
3145 if(codec && codec->pix_fmts){
3146 const enum PixelFormat *p= codec->pix_fmts;
3148 if(*p == video_enc->pix_fmt)
3152 video_enc->pix_fmt = codec->pix_fmts[0];
3156 video_enc->gop_size = gop_size;
3158 video_enc->gop_size = 0;
3159 if (video_qscale || same_quality) {
3160 video_enc->flags |= CODEC_FLAG_QSCALE;
3161 video_enc->global_quality=
3162 st->quality = FF_QP2LAMBDA * video_qscale;
3166 video_enc->intra_matrix = intra_matrix;
3168 video_enc->inter_matrix = inter_matrix;
3171 video_enc->flags |= CODEC_FLAG_BITEXACT;
3173 video_enc->mb_decision = mb_decision;
3174 video_enc->mb_cmp = mb_cmp;
3175 video_enc->ildct_cmp = ildct_cmp;
3176 video_enc->me_sub_cmp = sub_cmp;
3177 video_enc->me_cmp = cmp;
3178 video_enc->me_pre_cmp = pre_cmp;
3179 video_enc->pre_me = pre_me;
3180 video_enc->lumi_masking = lumi_mask;
3181 video_enc->dark_masking = dark_mask;
3182 video_enc->spatial_cplx_masking = scplx_mask;
3183 video_enc->temporal_cplx_masking = tcplx_mask;
3184 video_enc->p_masking = p_mask;
3185 video_enc->quantizer_noise_shaping= qns;
3188 video_enc->flags |= CODEC_FLAG_H263P_UMV;
3191 video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3194 video_enc->flags |= CODEC_FLAG_H263P_AIC;
3197 video_enc->flags |= CODEC_FLAG_H263P_AIV;
3200 video_enc->flags |= CODEC_FLAG_4MV;
3203 video_enc->flags |= CODEC_FLAG_OBMC;
3206 video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3210 video_enc->flags |= CODEC_FLAG_PART;
3213 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3216 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3219 video_enc->flags |= CODEC_FLAG_MV0;
3221 if (do_normalize_aqp) {
3222 video_enc->flags |= CODEC_FLAG_NORMALIZE_AQP;
3224 if (use_scan_offset) {
3225 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3228 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3231 video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3234 video_enc->flags |= CODEC_FLAG_QPEL;
3237 video_enc->flags |= CODEC_FLAG_QP_RD;
3240 video_enc->flags |= CODEC_FLAG_CBP_RD;
3243 video_enc->max_b_frames = b_frames;
3244 video_enc->b_frame_strategy = 0;
3245 video_enc->b_quant_factor = 2.0;
3247 if (do_interlace_dct) {
3248 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3250 if (do_interlace_me) {
3251 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3254 video_enc->flags2 |= CODEC_FLAG2_NO_OUTPUT;
3256 video_enc->qmin = video_qmin;
3257 video_enc->qmax = video_qmax;
3258 video_enc->lmin = video_lmin;
3259 video_enc->lmax = video_lmax;
3260 video_enc->rc_qsquish = video_qsquish;
3261 video_enc->luma_elim_threshold = video_lelim;
3262 video_enc->chroma_elim_threshold = video_celim;
3263 video_enc->mb_lmin = video_mb_lmin;
3264 video_enc->mb_lmax = video_mb_lmax;
3265 video_enc->max_qdiff = video_qdiff;
3266 video_enc->qblur = video_qblur;
3267 video_enc->qcompress = video_qcomp;
3268 video_enc->rc_eq = video_rc_eq;
3269 video_enc->debug = debug;
3270 video_enc->debug_mv = debug_mv;
3271 video_enc->workaround_bugs = workaround_bugs;
3272 video_enc->thread_count = thread_count;
3273 p= video_rc_override_string;
3276 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3278 fprintf(stderr, "error parsing rc_override\n");
3281 video_enc->rc_override=
3282 av_realloc(video_enc->rc_override,
3283 sizeof(RcOverride)*(i+1));
3284 video_enc->rc_override[i].start_frame= start;
3285 video_enc->rc_override[i].end_frame = end;
3287 video_enc->rc_override[i].qscale= q;
3288 video_enc->rc_override[i].quality_factor= 1.0;
3291 video_enc->rc_override[i].qscale= 0;
3292 video_enc->rc_override[i].quality_factor= -q/100.0;
3297 video_enc->rc_override_count=i;
3299 video_enc->rc_max_rate = video_rc_max_rate;
3300 video_enc->rc_min_rate = video_rc_min_rate;
3301 video_enc->rc_buffer_size = video_rc_buffer_size;
3302 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3303 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3304 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3305 video_enc->i_quant_factor = video_i_qfactor;
3306 video_enc->b_quant_factor = video_b_qfactor;
3307 video_enc->i_quant_offset = video_i_qoffset;
3308 video_enc->b_quant_offset = video_b_qoffset;
3309 video_enc->intra_quant_bias = video_intra_quant_bias;
3310 video_enc->inter_quant_bias = video_inter_quant_bias;
3311 video_enc->dct_algo = dct_algo;
3312 video_enc->idct_algo = idct_algo;
3313 video_enc->me_threshold= me_threshold;
3314 video_enc->mb_threshold= mb_threshold;
3315 video_enc->intra_dc_precision= intra_dc_precision - 8;
3316 video_enc->strict_std_compliance = strict;
3317 video_enc->error_rate = error_rate;
3318 video_enc->noise_reduction= noise_reduction;
3319 video_enc->scenechange_threshold= sc_threshold;
3320 video_enc->me_range = me_range;
3321 video_enc->coder_type= coder;
3322 video_enc->context_model= context;
3323 video_enc->prediction_method= predictor;
3324 video_enc->profile= video_profile;
3325 video_enc->level= video_level;
3326 video_enc->nsse_weight= nsse_weight;
3327 video_enc->me_subpel_quality= subpel_quality;
3328 video_enc->me_penalty_compensation= me_penalty_compensation;
3329 video_enc->frame_skip_threshold= frame_skip_threshold;
3330 video_enc->frame_skip_factor= frame_skip_factor;
3331 video_enc->frame_skip_exp= frame_skip_exp;
3332 video_enc->frame_skip_cmp= frame_skip_cmp;
3335 video_enc->rtp_mode= 1;
3336 video_enc->rtp_payload_size= packet_size;
3340 video_enc->flags|= CODEC_FLAG_PSNR;
3342 video_enc->me_method = me_method;
3347 video_enc->flags |= CODEC_FLAG_PASS1;
3349 video_enc->flags |= CODEC_FLAG_PASS2;
3356 AVCodecContext *audio_enc;
3358 st = av_new_stream(oc, nb_streams++);
3360 fprintf(stderr, "Could not alloc stream\n");
3363 #if defined(HAVE_THREADS)
3365 avcodec_thread_init(&st->codec, thread_count);
3368 audio_enc = &st->codec;
3369 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3372 audio_enc->codec_tag= audio_codec_tag;
3374 if (file_oformat->flags & AVFMT_GLOBALHEADER)
3375 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3376 if (audio_stream_copy) {
3377 st->stream_copy = 1;
3378 audio_enc->channels = audio_channels;
3380 codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_AUDIO);
3381 if (audio_codec_id != CODEC_ID_NONE)
3382 codec_id = audio_codec_id;
3383 audio_enc->codec_id = codec_id;
3385 audio_enc->bit_rate = audio_bit_rate;
3386 audio_enc->strict_std_compliance = strict;
3387 audio_enc->thread_count = thread_count;
3388 /* For audio codecs other than AC3 or DTS we limit */
3389 /* the number of coded channels to stereo */
3390 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3391 && codec_id != CODEC_ID_DTS) {
3392 audio_enc->channels = 2;
3394 audio_enc->channels = audio_channels;
3396 audio_enc->sample_rate = audio_sample_rate;
3399 oc->nb_streams = nb_streams;
3402 fprintf(stderr, "No audio or video streams available\n");
3406 oc->timestamp = rec_timestamp;
3409 pstrcpy(oc->title, sizeof(oc->title), str_title);
3411 pstrcpy(oc->author, sizeof(oc->author), str_author);
3413 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3415 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3418 output_files[nb_output_files++] = oc;
3420 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3422 /* check filename in case of an image number is expected */
3423 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3424 if (filename_number_test(oc->filename) < 0) {
3425 print_error(oc->filename, AVERROR_NUMEXPECTED);
3430 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3431 /* test if it already exists to avoid loosing precious files */
3432 if (!file_overwrite &&
3433 (strchr(filename, ':') == NULL ||
3434 strstart(filename, "file:", NULL))) {
3435 if (url_exist(filename)) {
3438 if ( !using_stdin ) {
3439 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3442 if (toupper(c) != 'Y') {
3443 fprintf(stderr, "Not overwriting - exiting\n");
3448 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3455 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3456 fprintf(stderr, "Could not open '%s'\n", filename);
3461 memset(ap, 0, sizeof(*ap));
3462 ap->image_format = image_format;
3463 if (av_set_parameters(oc, ap) < 0) {
3464 fprintf(stderr, "%s: Invalid encoding parameters\n",
3469 oc->packet_size= mux_packet_size;
3470 oc->mux_rate= mux_rate;
3471 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3472 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3474 /* reset some options */
3475 file_oformat = NULL;
3476 file_iformat = NULL;
3477 image_format = NULL;
3480 audio_codec_id = CODEC_ID_NONE;
3481 video_codec_id = CODEC_ID_NONE;
3482 audio_stream_copy = 0;
3483 video_stream_copy = 0;
3486 /* prepare dummy protocols for grab */
3487 static void prepare_grab(void)
3489 int has_video, has_audio, i, j;
3490 AVFormatContext *oc;
3491 AVFormatContext *ic;
3492 AVFormatParameters vp1, *vp = &vp1;
3493 AVFormatParameters ap1, *ap = &ap1;
3495 /* see if audio/video inputs are needed */
3498 memset(ap, 0, sizeof(*ap));
3499 memset(vp, 0, sizeof(*vp));
3500 vp->time_base.num= 1;
3501 for(j=0;j<nb_output_files;j++) {
3502 oc = output_files[j];
3503 for(i=0;i<oc->nb_streams;i++) {
3504 AVCodecContext *enc = &oc->streams[i]->codec;
3505 switch(enc->codec_type) {
3506 case CODEC_TYPE_AUDIO:
3507 if (enc->sample_rate > ap->sample_rate)
3508 ap->sample_rate = enc->sample_rate;
3509 if (enc->channels > ap->channels)
3510 ap->channels = enc->channels;
3513 case CODEC_TYPE_VIDEO:
3514 if (enc->width > vp->width)
3515 vp->width = enc->width;
3516 if (enc->height > vp->height)
3517 vp->height = enc->height;
3519 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3520 vp->time_base = enc->time_base;
3530 if (has_video == 0 && has_audio == 0) {
3531 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3536 AVInputFormat *fmt1;
3537 fmt1 = av_find_input_format(video_grab_format);
3538 vp->device = video_device;
3539 vp->channel = video_channel;
3540 vp->standard = video_standard;
3541 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3542 fprintf(stderr, "Could not find video grab device\n");
3545 /* If not enough info to get the stream parameters, we decode the
3546 first frames to get it. */
3547 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3548 fprintf(stderr, "Could not find video grab parameters\n");
3551 /* by now video grab has one stream */
3552 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3553 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3554 input_files[nb_input_files] = ic;
3557 dump_format(ic, nb_input_files, "", 0);
3561 if (has_audio && audio_grab_format) {
3562 AVInputFormat *fmt1;
3563 fmt1 = av_find_input_format(audio_grab_format);
3564 ap->device = audio_device;
3565 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3566 fprintf(stderr, "Could not find audio grab device\n");
3569 input_files[nb_input_files] = ic;
3572 dump_format(ic, nb_input_files, "", 0);
3578 /* same option as mencoder */
3579 static void opt_pass(const char *pass_str)
3582 pass = atoi(pass_str);
3583 if (pass != 1 && pass != 2) {
3584 fprintf(stderr, "pass number can be only 1 or 2\n");
3590 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3591 static int64_t getutime(void)
3593 return av_gettime();
3596 static int64_t getutime(void)
3598 struct rusage rusage;
3600 getrusage(RUSAGE_SELF, &rusage);
3601 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3605 extern int ffm_nopts;
3607 static void opt_bitexact(void)
3610 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3614 static void show_formats(void)
3616 AVInputFormat *ifmt;
3617 AVOutputFormat *ofmt;
3618 AVImageFormat *image_fmt;
3621 const char **pp, *last_name;
3623 printf("File formats:\n");
3628 const char *name=NULL;
3629 const char *long_name=NULL;
3631 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3632 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3633 strcmp(ofmt->name, last_name)>0){
3635 long_name= ofmt->long_name;
3639 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3640 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3641 strcmp(ifmt->name, last_name)>0){
3643 long_name= ifmt->long_name;
3646 if(name && strcmp(ifmt->name, name)==0)
3658 long_name ? long_name:" ");
3662 printf("Image formats (filename extensions, if any, follow):\n");
3663 for(image_fmt = first_image_format; image_fmt != NULL;
3664 image_fmt = image_fmt->next) {
3667 image_fmt->img_read ? "D":" ",
3668 image_fmt->img_write ? "E":" ",
3670 image_fmt->extensions ? image_fmt->extensions:" ");
3674 printf("Codecs:\n");
3682 for(p = first_avcodec; p != NULL; p = p->next) {
3683 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3684 strcmp(p->name, last_name)>0){
3686 decode= encode= cap=0;
3688 if(p2 && strcmp(p->name, p2->name)==0){
3689 if(p->decode) decode=1;
3690 if(p->encode) encode=1;
3691 cap |= p->capabilities;
3696 last_name= p2->name;
3700 decode ? "D": (/*p2->decoder ? "d":*/" "),
3702 p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3703 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3704 cap & CODEC_CAP_DR1 ? "D":" ",
3705 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3707 /* if(p2->decoder && decode==0)
3708 printf(" use %s for decoding", p2->decoder->name);*/
3713 printf("Supported file protocols:\n");
3714 for(up = first_protocol; up != NULL; up = up->next)
3715 printf(" %s:", up->name);
3718 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3719 printf("Motion estimation methods:\n");
3723 if ((pp - motion_str + 1) == ME_ZERO)
3724 printf("(fastest)");
3725 else if ((pp - motion_str + 1) == ME_FULL)
3726 printf("(slowest)");
3727 else if ((pp - motion_str + 1) == ME_EPZS)
3728 printf("(default)");
3733 "Note, the names of encoders and decoders dont always match, so there are\n"
3734 "several cases where the above table shows encoder only or decoder only entries\n"
3735 "even though both encoding and decoding are supported for example, the h263\n"
3736 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3741 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3744 const char *p = str;
3751 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3758 void opt_inter_matrix(const char *arg)
3760 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3761 parse_matrix_coeffs(inter_matrix, arg);
3764 void opt_intra_matrix(const char *arg)
3766 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3767 parse_matrix_coeffs(intra_matrix, arg);
3770 static void opt_target(const char *arg)
3773 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3775 if(!strncmp(arg, "pal-", 4)) {
3778 } else if(!strncmp(arg, "ntsc-", 5)) {
3781 } else if(!strncmp(arg, "film-", 5)) {
3786 /* Calculate FR via float to avoid int overflow */
3787 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3790 } else if((fr == 29970) || (fr == 23976)) {
3793 /* Try to determine PAL/NTSC by peeking in the input files */
3794 if(nb_input_files) {
3796 for(j = 0; j < nb_input_files; j++) {
3797 for(i = 0; i < input_files[j]->nb_streams; i++) {
3798 AVCodecContext *c = &input_files[j]->streams[i]->codec;
3799 if(c->codec_type != CODEC_TYPE_VIDEO)
3801 fr = c->time_base.den * 1000 / c->time_base.num;
3805 } else if((fr == 29970) || (fr == 23976)) {
3815 if(verbose && norm >= 0)
3816 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3820 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3821 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3822 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3826 if(!strcmp(arg, "vcd")) {
3828 opt_video_codec("mpeg1video");
3829 opt_audio_codec("mp2");
3832 opt_frame_size(norm ? "352x240" : "352x288");
3833 opt_frame_rate(frame_rates[norm]);
3834 opt_gop_size(norm ? "18" : "15");
3836 video_bit_rate = 1150000;
3837 video_rc_max_rate = 1150000;
3838 video_rc_min_rate = 1150000;
3839 video_rc_buffer_size = 40*1024*8;
3841 audio_bit_rate = 224000;
3842 audio_sample_rate = 44100;
3844 mux_packet_size= 2324;
3845 mux_rate= 2352 * 75 * 8;
3847 /* We have to offset the PTS, so that it is consistent with the SCR.
3848 SCR starts at 36000, but the first two packs contain only padding
3849 and the first pack from the other stream, respectively, may also have
3850 been written before.
3851 So the real data starts at SCR 36000+3*1200. */
3852 mux_preload= (36000+3*1200) / 90000.0; //0.44
3853 } else if(!strcmp(arg, "svcd")) {
3855 opt_video_codec("mpeg2video");
3856 opt_audio_codec("mp2");
3859 opt_frame_size(norm ? "480x480" : "480x576");
3860 opt_frame_rate(frame_rates[norm]);
3861 opt_gop_size(norm ? "18" : "15");
3863 video_bit_rate = 2040000;
3864 video_rc_max_rate = 2516000;
3865 video_rc_min_rate = 0; //1145000;
3866 video_rc_buffer_size = 224*1024*8;
3867 use_scan_offset = 1;
3869 audio_bit_rate = 224000;
3870 audio_sample_rate = 44100;
3872 mux_packet_size= 2324;
3874 } else if(!strcmp(arg, "dvd")) {
3876 opt_video_codec("mpeg2video");
3877 opt_audio_codec("ac3");
3880 opt_frame_size(norm ? "720x480" : "720x576");
3881 opt_frame_rate(frame_rates[norm]);
3882 opt_gop_size(norm ? "18" : "15");
3884 video_bit_rate = 6000000;
3885 video_rc_max_rate = 9000000;
3886 video_rc_min_rate = 0; //1500000;
3887 video_rc_buffer_size = 224*1024*8;
3889 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3890 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3892 audio_bit_rate = 448000;
3893 audio_sample_rate = 48000;
3895 } else if(!strcmp(arg, "dv")) {
3899 opt_frame_size(norm ? "720x480" : "720x576");
3900 opt_frame_rate(frame_rates[norm]);
3902 audio_sample_rate = 48000;
3906 fprintf(stderr, "Unknown target: %s\n", arg);
3911 static void show_version(void)
3913 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3916 avcodec_build(), LIBAVFORMAT_BUILD);
3920 const OptionDef options[] = {
3922 { "L", 0, {(void*)show_license}, "show license" },
3923 { "h", 0, {(void*)show_help}, "show help" },
3924 { "version", 0, {(void*)show_version}, "show version" },
3925 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3926 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3927 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3928 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3929 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3930 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3931 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3932 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3933 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3934 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3935 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3936 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3937 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3938 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3939 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3940 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3941 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3942 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3943 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3944 "add timings for benchmarking" },
3945 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3946 "dump each input packet" },
3947 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3948 "when dumping packets, also dump the payload" },
3949 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3950 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3951 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3952 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3953 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3954 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3955 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3956 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3957 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3958 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3961 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3962 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3963 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3964 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3965 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3966 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3967 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3968 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3969 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3970 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3971 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3972 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3973 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3974 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3975 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3976 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3977 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3978 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3979 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3980 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3981 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3982 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3983 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3984 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3985 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3986 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3987 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
3988 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
3989 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3990 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3991 { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
3992 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3993 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3994 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3995 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3996 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3997 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3998 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3999 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4000 // { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
4001 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4002 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4003 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4004 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4005 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4006 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4007 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4008 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4010 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
4011 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
4012 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
4013 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
4014 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
4015 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
4016 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4017 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
4018 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
4019 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
4020 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
4021 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
4022 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
4023 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
4024 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4025 { "lelim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lelim}, "single coefficient elimination threshold for luminance (negative values also consider DC coefficient)", "elim" },
4026 { "celim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_celim}, "single coefficient elimination threshold for chrominance (negative values also consider DC coefficient)", "elim" },
4027 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
4028 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
4029 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
4030 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
4031 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
4032 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
4033 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
4034 { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
4035 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
4036 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4037 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4038 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4039 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4040 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4041 "use same video quality as source (implies VBR)" },
4042 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4043 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4044 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4045 "deinterlace pictures" },
4046 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
4047 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
4048 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
4049 "force interlaced me support in encoder (MPEG2/MPEG4)" },
4050 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4051 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4052 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4053 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
4054 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
4055 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
4056 { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
4057 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
4058 { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
4059 { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
4060 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
4061 { "mv0", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_mv0}, "try to encode each MB with MV=<0,0> and choose the better one (has no effect if mbd=0)" },
4062 { "naq", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_normalize_aqp}, "normalize adaptive quantization" },
4063 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
4064 { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
4065 { "noout", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&no_output}, "skip bitstream encoding" },
4066 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
4067 { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
4068 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4069 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4070 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4071 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
4072 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
4073 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4074 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4075 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4076 { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
4077 { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
4078 { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
4079 { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
4080 { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
4081 { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
4082 { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
4083 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4084 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
4085 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4086 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4087 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4088 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4089 { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
4092 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4093 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4094 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4095 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4096 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4097 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4098 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4101 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4102 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4103 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4104 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4106 /* G.2 grab options */
4107 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4108 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4111 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4112 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4113 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4114 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4118 static void show_banner(void)
4120 fprintf(stderr, "ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4122 fprintf(stderr, " configuration: %s\n", FFMPEG_CONFIGURATION);
4123 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4125 fprintf(stderr, ", gcc: %s\n", __VERSION__);
4127 fprintf(stderr, ", using a non-gcc compiler\n");
4131 static void show_license(void)
4136 "This program is free software; you can redistribute it and/or modify\n"
4137 "it under the terms of the GNU General Public License as published by\n"
4138 "the Free Software Foundation; either version 2 of the License, or\n"
4139 "(at your option) any later version.\n"
4141 "This program is distributed in the hope that it will be useful,\n"
4142 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4143 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4144 "GNU General Public License for more details.\n"
4146 "You should have received a copy of the GNU General Public License\n"
4147 "along with this program; if not, write to the Free Software\n"
4148 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4152 "This library is free software; you can redistribute it and/or\n"
4153 "modify it under the terms of the GNU Lesser General Public\n"
4154 "License as published by the Free Software Foundation; either\n"
4155 "version 2 of the License, or (at your option) any later version.\n"
4157 "This library is distributed in the hope that it will be useful,\n"
4158 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4159 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4160 "Lesser General Public License for more details.\n"
4162 "You should have received a copy of the GNU Lesser General Public\n"
4163 "License along with this library; if not, write to the Free Software\n"
4164 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4170 static void show_help(void)
4173 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4174 "Hyper fast Audio and Video encoder\n");
4176 show_help_options(options, "Main options:\n",
4177 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4178 show_help_options(options, "\nVideo options:\n",
4179 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4181 show_help_options(options, "\nAdvanced Video options:\n",
4182 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4183 OPT_VIDEO | OPT_EXPERT);
4184 show_help_options(options, "\nAudio options:\n",
4185 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4187 show_help_options(options, "\nAdvanced Audio options:\n",
4188 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4189 OPT_AUDIO | OPT_EXPERT);
4190 show_help_options(options, "\nAudio/Video grab options:\n",
4193 show_help_options(options, "\nAdvanced options:\n",
4194 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4199 void parse_arg_file(const char *filename)
4201 opt_output_file(filename);
4204 int main(int argc, char **argv)
4217 parse_options(argc, argv, options);
4219 /* file converter / grab */
4220 if (nb_output_files <= 0) {
4221 fprintf(stderr, "Must supply at least one output file\n");
4225 if (nb_input_files == 0) {
4231 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4232 stream_maps, nb_stream_maps);
4233 ti = getutime() - ti;
4235 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4239 for(i=0;i<nb_output_files;i++) {
4240 /* maybe av_close_output_file ??? */
4241 AVFormatContext *s = output_files[i];
4243 if (!(s->oformat->flags & AVFMT_NOFILE))
4245 for(j=0;j<s->nb_streams;j++)
4246 av_free(s->streams[j]);
4249 for(i=0;i<nb_input_files;i++)
4250 av_close_input_file(input_files[i]);
4255 av_free(intra_matrix);
4257 av_free(inter_matrix);
4259 #ifdef POWERPC_PERFORMANCE_REPORT
4260 extern void powerpc_display_perf_report(void);
4261 powerpc_display_perf_report();
4262 #endif /* POWERPC_PERFORMANCE_REPORT */
4264 #ifndef CONFIG_WIN32
4265 if (received_sigterm) {
4267 "Received signal %d: terminating.\n",
4268 (int) received_sigterm);
4272 exit(0); /* not all OS-es handle main() return value */