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_YUV420P;
90 static int frame_padtop = 0;
91 static int frame_padbottom = 0;
92 static int frame_padleft = 0;
93 static int frame_padright = 0;
94 static int padcolor[3] = {16,128,128}; /* default to black */
95 static int frame_topBand = 0;
96 static int frame_bottomBand = 0;
97 static int frame_leftBand = 0;
98 static int frame_rightBand = 0;
99 static int 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_qmin = 2;
110 static int video_mb_qmax = 31;
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_codec_id = CODEC_ID_NONE;
140 static int video_codec_tag = 0;
141 static int same_quality = 0;
142 static int b_frames = 0;
143 static int mb_decision = FF_MB_DECISION_SIMPLE;
144 static int ildct_cmp = FF_CMP_VSAD;
145 static int mb_cmp = FF_CMP_SAD;
146 static int sub_cmp = FF_CMP_SAD;
147 static int cmp = FF_CMP_SAD;
148 static int pre_cmp = FF_CMP_SAD;
149 static int pre_me = 0;
150 static float lumi_mask = 0;
151 static float dark_mask = 0;
152 static float scplx_mask = 0;
153 static float tcplx_mask = 0;
154 static float p_mask = 0;
155 static int use_4mv = 0;
156 static int use_obmc = 0;
157 static int use_loop = 0;
158 static int use_aic = 0;
159 static int use_aiv = 0;
160 static int use_umv = 0;
161 static int use_ss = 0;
162 static int use_alt_scan = 0;
163 static int use_trell = 0;
164 static int use_scan_offset = 0;
165 static int use_qpel = 0;
166 static int use_qprd = 0;
167 static int use_cbprd = 0;
168 static int use_mv0 = 0;
169 static int do_normalize_aqp = 0;
171 static int closed_gop = 0;
172 static int strict_gop = 0;
173 static int do_deinterlace = 0;
174 static int do_interlace_dct = 0;
175 static int do_interlace_me = 0;
176 static int workaround_bugs = FF_BUG_AUTODETECT;
177 static int error_resilience = 2;
178 static int error_concealment = 3;
179 static int dct_algo = 0;
180 static int idct_algo = 0;
181 static int use_part = 0;
182 static int packet_size = 0;
183 static int error_rate = 0;
184 static int strict = 0;
185 static int top_field_first = -1;
186 static int noise_reduction = 0;
187 static int sc_threshold = 0;
188 static int debug = 0;
189 static int debug_mv = 0;
190 static int me_threshold = 0;
191 static int mb_threshold = 0;
192 static int intra_dc_precision = 8;
193 static int coder = 0;
194 static int context = 0;
195 static int predictor = 0;
196 static int video_profile = FF_PROFILE_UNKNOWN;
197 static int video_level = FF_LEVEL_UNKNOWN;
198 static int nsse_weight = 8;
199 static int subpel_quality= 8;
200 static int lowres= 0;
201 static int frame_skip_threshold= 0;
202 static int frame_skip_factor= 0;
203 static int frame_skip_exp= 0;
204 static int frame_skip_cmp= FF_CMP_DCTMAX;
205 extern int loop_input; /* currently a hack */
207 static int gop_size = 12;
208 static int intra_only = 0;
209 static int audio_sample_rate = 44100;
210 static int audio_bit_rate = 64000;
211 static int audio_disable = 0;
212 static int audio_channels = 1;
213 static int audio_codec_id = CODEC_ID_NONE;
214 static int audio_codec_tag = 0;
216 static int mux_rate= 0;
217 static int mux_packet_size= 0;
218 static float mux_preload= 0.5;
219 static float mux_max_delay= 0.7;
221 static int64_t recording_time = 0;
222 static int64_t start_time = 0;
223 static int64_t rec_timestamp = 0;
224 static int64_t input_ts_offset = 0;
225 static int file_overwrite = 0;
226 static char *str_title = NULL;
227 static char *str_author = NULL;
228 static char *str_copyright = NULL;
229 static char *str_comment = NULL;
230 static int do_benchmark = 0;
231 static int do_hex_dump = 0;
232 static int do_pkt_dump = 0;
233 static int do_psnr = 0;
234 static int do_vstats = 0;
235 static int do_pass = 0;
236 static int bitexact = 0;
237 static char *pass_logfilename = NULL;
238 static int audio_stream_copy = 0;
239 static int video_stream_copy = 0;
240 static int video_sync_method= 1;
241 static int audio_sync_method= 0;
242 static int copy_ts= 0;
244 static int rate_emu = 0;
246 static char *video_grab_format = "video4linux";
247 static char *video_device = NULL;
248 static char *grab_device = NULL;
249 static int video_channel = 0;
250 static char *video_standard = "ntsc";
252 static char *audio_grab_format = "audio_device";
253 static char *audio_device = NULL;
255 static int using_stdin = 0;
256 static int using_vhook = 0;
257 static int verbose = 1;
258 static int thread_count= 1;
259 static int q_pressed = 0;
260 static int me_range = 0;
261 static int64_t video_size = 0;
262 static int64_t audio_size = 0;
263 static int64_t extra_size = 0;
264 static int nb_frames_dup = 0;
265 static int nb_frames_drop = 0;
266 static int input_sync;
268 static int pgmyuv_compatibility_hack=0;
271 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
273 typedef struct AVOutputStream {
274 int file_index; /* file index */
275 int index; /* stream index in the output file */
276 int source_index; /* AVInputStream index */
277 AVStream *st; /* stream in the output file */
278 int encoding_needed; /* true if encoding needed for this stream */
280 /* input pts and corresponding output pts
282 double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
283 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
285 int video_resample; /* video_resample and video_crop are mutually exclusive */
286 AVFrame pict_tmp; /* temporary image for resampling */
287 ImgReSampleContext *img_resample_ctx; /* for image resampling */
289 int video_crop; /* video_resample and video_crop are mutually exclusive */
290 int topBand; /* cropping area sizes */
293 int video_pad; /* video_resample and video_pad are mutually exclusive */
294 int padtop; /* padding area sizes */
301 ReSampleContext *resample; /* for audio resampling */
302 FifoBuffer fifo; /* for compression: one audio fifo per codec */
306 typedef struct AVInputStream {
310 int discard; /* true if stream data should be discarded */
311 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
312 int64_t sample_index; /* current sample */
314 int64_t start; /* time when read started */
315 unsigned long frame; /* current frame */
316 int64_t next_pts; /* synthetic pts for cases where pkt.pts
318 int64_t pts; /* current pts */
319 int is_start; /* is 1 at the start and after a discontinuity */
322 typedef struct AVInputFile {
323 int eof_reached; /* true if eof reached */
324 int ist_index; /* index of first stream in ist_table */
325 int buffer_size; /* current total buffer size */
326 int buffer_size_max; /* buffer size at which we consider we can stop
328 int nb_streams; /* nb streams we are aware of */
333 /* init terminal so that we can grab keys */
334 static struct termios oldtty;
336 static void term_exit(void)
338 tcsetattr (0, TCSANOW, &oldtty);
341 static volatile sig_atomic_t received_sigterm = 0;
344 sigterm_handler(int sig)
346 received_sigterm = sig;
350 static void term_init(void)
357 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
358 |INLCR|IGNCR|ICRNL|IXON);
359 tty.c_oflag |= OPOST;
360 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
361 tty.c_cflag &= ~(CSIZE|PARENB);
366 tcsetattr (0, TCSANOW, &tty);
368 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
369 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
370 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
372 register a function to be called at normal program termination
375 #ifdef CONFIG_BEOS_NETSERVER
376 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
380 /* read a key without blocking */
381 static int read_key(void)
385 #ifndef CONFIG_BEOS_NETSERVER
393 n = select(1, &rfds, NULL, NULL, &tv);
405 static int decode_interrupt_cb(void)
407 return q_pressed || (q_pressed = read_key() == 'q');
412 static volatile int received_sigterm = 0;
414 /* no interactive support */
415 static void term_exit(void)
419 static void term_init(void)
423 static int read_key(void)
430 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
435 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
438 /* copy stream format */
439 s->nb_streams = ic->nb_streams;
440 for(i=0;i<ic->nb_streams;i++) {
443 st = av_mallocz(sizeof(AVStream));
444 memcpy(st, ic->streams[i], sizeof(AVStream));
448 av_close_input_file(ic);
452 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
454 static void do_audio_out(AVFormatContext *s,
457 unsigned char *buf, int size)
460 static uint8_t *audio_buf = NULL;
461 static uint8_t *audio_out = NULL;
462 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
464 int size_out, frame_bytes, ret;
465 AVCodecContext *enc= &ost->st->codec;
467 /* SC: dynamic allocation of buffers */
469 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
471 audio_out = av_malloc(audio_out_size);
472 if (!audio_buf || !audio_out)
473 return; /* Should signal an error ! */
475 if(audio_sync_method){
476 double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts
477 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
478 double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
479 int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
481 //FIXME resample delay
482 if(fabs(delta) > 50){
485 byte_delta= FFMAX(byte_delta, -size);
489 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
494 static uint8_t *input_tmp= NULL;
495 input_tmp= av_realloc(input_tmp, byte_delta + size);
497 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
500 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
502 memset(input_tmp, 0, byte_delta);
503 memcpy(input_tmp + byte_delta, buf, size);
507 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
509 }else if(audio_sync_method>1){
510 int comp= clip(delta, -audio_sync_method, audio_sync_method);
511 assert(ost->audio_resample);
513 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
514 // 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));
515 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
519 ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
520 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
522 if (ost->audio_resample) {
524 size_out = audio_resample(ost->resample,
525 (short *)buftmp, (short *)buf,
526 size / (ist->st->codec.channels * 2));
527 size_out = size_out * enc->channels * 2;
533 /* now encode as many frames as possible */
534 if (enc->frame_size > 1) {
535 /* output resampled raw samples */
536 fifo_write(&ost->fifo, buftmp, size_out,
539 frame_bytes = enc->frame_size * 2 * enc->channels;
541 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
542 &ost->fifo.rptr) == 0) {
544 av_init_packet(&pkt);
546 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
549 pkt.stream_index= ost->index;
553 pkt.pts= enc->coded_frame->pts;
554 pkt.flags |= PKT_FLAG_KEY;
555 av_interleaved_write_frame(s, &pkt);
557 ost->sync_opts += enc->frame_size;
561 av_init_packet(&pkt);
563 ost->sync_opts += size_out / (2 * enc->channels);
565 /* output a pcm frame */
566 /* XXX: change encoding codec API to avoid this ? */
567 switch(enc->codec->id) {
568 case CODEC_ID_PCM_S16LE:
569 case CODEC_ID_PCM_S16BE:
570 case CODEC_ID_PCM_U16LE:
571 case CODEC_ID_PCM_U16BE:
574 size_out = size_out >> 1;
577 ret = avcodec_encode_audio(enc, audio_out, size_out,
580 pkt.stream_index= ost->index;
584 pkt.pts= enc->coded_frame->pts;
585 pkt.flags |= PKT_FLAG_KEY;
586 av_interleaved_write_frame(s, &pkt);
590 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
594 AVPicture picture_tmp;
597 dec = &ist->st->codec;
599 /* deinterlace : must be done before any resize */
600 if (do_deinterlace || using_vhook) {
603 /* create temporary picture */
604 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
605 buf = av_malloc(size);
609 picture2 = &picture_tmp;
610 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
613 if(avpicture_deinterlace(picture2, picture,
614 dec->pix_fmt, dec->width, dec->height) < 0) {
615 /* if error, do not deinterlace */
621 if (img_convert(picture2, dec->pix_fmt, picture,
622 dec->pix_fmt, dec->width, dec->height) < 0) {
623 /* if error, do not copy */
633 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
635 if (picture != picture2)
636 *picture = *picture2;
640 /* we begin to correct av delay at this threshold */
641 #define AV_DELAY_MAX 0.100
644 /* Expects img to be yuv420 */
645 static void fill_pad_region(AVPicture* img, int height, int width,
646 int padtop, int padbottom, int padleft, int padright, int *color) {
651 for (i = 0; i < 3; i++) {
652 shift = (i == 0) ? 0 : 1;
654 if (padtop || padleft) {
655 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
659 if (padleft || padright) {
660 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
661 (img->linesize[i] - (padright >> shift));
663 for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
664 memset(optr, color[i], (padleft + padright) >> shift);
665 optr += img->linesize[i];
670 optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
671 memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
676 static int bit_buffer_size= 1024*256;
677 static uint8_t *bit_buffer= NULL;
679 static void do_video_out(AVFormatContext *s,
685 int nb_frames, i, ret;
686 AVFrame *final_picture, *formatted_picture;
687 AVFrame picture_format_temp, picture_crop_temp;
688 uint8_t *buf = NULL, *buf1 = NULL;
689 AVCodecContext *enc, *dec;
690 enum PixelFormat target_pixfmt;
692 avcodec_get_frame_defaults(&picture_format_temp);
693 avcodec_get_frame_defaults(&picture_crop_temp);
695 enc = &ost->st->codec;
696 dec = &ist->st->codec;
698 /* by default, we output a single frame */
703 if(video_sync_method){
705 vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
706 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
709 else if (vdelta > 1.1)
710 nb_frames = lrintf(vdelta);
711 //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);
715 fprintf(stderr, "*** drop!\n");
716 }else if (nb_frames > 1) {
717 nb_frames_dup += nb_frames;
719 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
722 ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
724 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
728 /* convert pixel format if needed */
729 target_pixfmt = ost->video_resample || ost->video_pad
730 ? PIX_FMT_YUV420P : enc->pix_fmt;
731 if (dec->pix_fmt != target_pixfmt) {
734 /* create temporary picture */
735 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
736 buf = av_malloc(size);
739 formatted_picture = &picture_format_temp;
740 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
742 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
743 (AVPicture *)in_picture, dec->pix_fmt,
744 dec->width, dec->height) < 0) {
747 fprintf(stderr, "pixel format conversion not handled\n");
752 formatted_picture = in_picture;
755 /* XXX: resampling could be done before raw format conversion in
756 some cases to go faster */
757 /* XXX: only works for YUV420P */
758 if (ost->video_resample) {
759 final_picture = &ost->pict_tmp;
760 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
762 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
763 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
764 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
768 if (enc->pix_fmt != PIX_FMT_YUV420P) {
772 /* create temporary picture */
773 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
774 buf = av_malloc(size);
777 final_picture = &picture_format_temp;
778 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
780 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
781 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
782 enc->width, enc->height) < 0) {
785 fprintf(stderr, "pixel format conversion not handled\n");
790 } else if (ost->video_crop) {
791 picture_crop_temp.data[0] = formatted_picture->data[0] +
792 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
794 picture_crop_temp.data[1] = formatted_picture->data[1] +
795 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
796 (ost->leftBand >> 1);
798 picture_crop_temp.data[2] = formatted_picture->data[2] +
799 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
800 (ost->leftBand >> 1);
802 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
803 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
804 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
805 final_picture = &picture_crop_temp;
806 } else if (ost->video_pad) {
807 final_picture = &ost->pict_tmp;
809 for (i = 0; i < 3; i++) {
810 uint8_t *optr, *iptr;
811 int shift = (i == 0) ? 0 : 1;
814 /* set offset to start writing image into */
815 optr = final_picture->data[i] + (((final_picture->linesize[i] *
816 ost->padtop) + ost->padleft) >> shift);
817 iptr = formatted_picture->data[i];
819 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
820 for (y = 0; y < yheight; y++) {
821 /* copy unpadded image row into padded image row */
822 memcpy(optr, iptr, formatted_picture->linesize[i]);
823 optr += final_picture->linesize[i];
824 iptr += formatted_picture->linesize[i];
828 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
829 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
832 if (enc->pix_fmt != PIX_FMT_YUV420P) {
836 /* create temporary picture */
837 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
838 buf = av_malloc(size);
841 final_picture = &picture_format_temp;
842 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
844 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
845 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
846 enc->width, enc->height) < 0) {
849 fprintf(stderr, "pixel format conversion not handled\n");
855 final_picture = formatted_picture;
857 /* duplicates frame if needed */
858 for(i=0;i<nb_frames;i++) {
860 av_init_packet(&pkt);
861 pkt.stream_index= ost->index;
863 if (s->oformat->flags & AVFMT_RAWPICTURE) {
864 /* raw pictures are written as AVPicture structure to
865 avoid any copies. We support temorarily the older
867 AVFrame* old_frame = enc->coded_frame;
868 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
869 pkt.data= (uint8_t *)final_picture;
870 pkt.size= sizeof(AVPicture);
872 pkt.pts= dec->coded_frame->pts;
873 if(dec->coded_frame && dec->coded_frame->key_frame)
874 pkt.flags |= PKT_FLAG_KEY;
876 av_interleaved_write_frame(s, &pkt);
877 enc->coded_frame = old_frame;
881 big_picture= *final_picture;
882 /* better than nothing: use input picture interlaced
884 big_picture.interlaced_frame = in_picture->interlaced_frame;
885 if(do_interlace_me || do_interlace_dct){
886 if(top_field_first == -1)
887 big_picture.top_field_first = in_picture->top_field_first;
889 big_picture.top_field_first = top_field_first;
892 /* handles sameq here. This is not correct because it may
893 not be a global option */
895 big_picture.quality = ist->st->quality;
897 big_picture.quality = ost->st->quality;
899 big_picture.pict_type = 0;
900 // big_picture.pts = AV_NOPTS_VALUE;
901 big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
902 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
903 ret = avcodec_encode_video(enc,
904 bit_buffer, bit_buffer_size,
906 //enc->frame_number = enc->real_pict_num;
908 pkt.data= bit_buffer;
911 pkt.pts= enc->coded_frame->pts;
912 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
913 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
914 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
916 if(enc->coded_frame && enc->coded_frame->key_frame)
917 pkt.flags |= PKT_FLAG_KEY;
918 av_interleaved_write_frame(s, &pkt);
920 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
921 // enc->frame_number-1, enc->real_pict_num, ret,
923 /* if two pass, output log */
924 if (ost->logfile && enc->stats_out) {
925 fprintf(ost->logfile, "%s", enc->stats_out);
937 static double psnr(double d){
938 if(d==0) return INFINITY;
939 return -10.0*log(d)/log(10.0);
942 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
945 static FILE *fvstats=NULL;
952 double ti1, bitrate, avg_bitrate;
956 today = localtime(&today2);
957 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
960 fvstats = fopen(filename,"w");
968 enc = &ost->st->codec;
969 if (enc->codec_type == CODEC_TYPE_VIDEO) {
970 frame_number = ost->frame_number;
971 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
972 if (enc->flags&CODEC_FLAG_PSNR)
973 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
975 fprintf(fvstats,"f_size= %6d ", frame_size);
976 /* compute pts value */
977 ti1 = (double)ost->sync_opts *enc->frame_rate_base / enc->frame_rate;
981 bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
982 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
983 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
984 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
985 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
989 static void print_report(AVFormatContext **output_files,
990 AVOutputStream **ost_table, int nb_ostreams,
995 AVFormatContext *oc, *os;
998 int frame_number, vid, i;
999 double bitrate, ti1, pts;
1000 static int64_t last_time = -1;
1002 if (!is_last_report) {
1004 /* display the report every 0.5 seconds */
1005 cur_time = av_gettime();
1006 if (last_time == -1) {
1007 last_time = cur_time;
1010 if ((cur_time - last_time) < 500000)
1012 last_time = cur_time;
1016 oc = output_files[0];
1018 total_size = url_ftell(&oc->pb);
1023 for(i=0;i<nb_ostreams;i++) {
1025 os = output_files[ost->file_index];
1026 enc = &ost->st->codec;
1027 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1028 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1029 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1031 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1032 frame_number = ost->frame_number;
1033 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%2.1f ",
1034 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1036 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1037 if (enc->flags&CODEC_FLAG_PSNR){
1039 double error, error_sum=0;
1040 double scale, scale_sum=0;
1041 char type[3]= {'Y','U','V'};
1042 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1045 error= enc->error[j];
1046 scale= enc->width*enc->height*255.0*255.0*frame_number;
1048 error= enc->coded_frame->error[j];
1049 scale= enc->width*enc->height*255.0*255.0;
1054 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1056 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1060 /* compute min output value */
1061 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1062 if ((pts < ti1) && (pts > 0))
1068 if (verbose || is_last_report) {
1069 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1071 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1072 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1073 (double)total_size / 1024, ti1, bitrate);
1076 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1077 nb_frames_dup, nb_frames_drop);
1080 fprintf(stderr, "%s \r", buf);
1085 if (is_last_report && verbose >= 0){
1086 int64_t raw= audio_size + video_size + extra_size;
1087 fprintf(stderr, "\n");
1088 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1092 100.0*(total_size - raw)/raw
1097 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1098 static int output_packet(AVInputStream *ist, int ist_index,
1099 AVOutputStream **ost_table, int nb_ostreams,
1100 const AVPacket *pkt)
1102 AVFormatContext *os;
1103 AVOutputStream *ost;
1107 int data_size, got_picture;
1109 void *buffer_to_free;
1110 static int samples_size= 0;
1111 static short *samples= NULL;
1114 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1115 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1116 ist->next_pts = ist->pts = pkt->dts;
1118 assert(ist->pts == ist->next_pts);
1132 /* decode the packet if needed */
1133 data_buf = NULL; /* fail safe */
1135 if (ist->decoding_needed) {
1136 switch(ist->st->codec.codec_type) {
1137 case CODEC_TYPE_AUDIO:{
1139 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1140 /* XXX: could avoid copy if PCM 16 bits with same
1141 endianness as CPU */
1142 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1148 /* Some bug in mpeg audio decoder gives */
1149 /* data_size < 0, it seems they are overflows */
1150 if (data_size <= 0) {
1151 /* no audio frame */
1154 data_buf = (uint8_t *)samples;
1155 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1156 (ist->st->codec.sample_rate * ist->st->codec.channels);
1158 case CODEC_TYPE_VIDEO:
1159 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1160 /* XXX: allocate picture correctly */
1161 avcodec_get_frame_defaults(&picture);
1163 ret = avcodec_decode_video(&ist->st->codec,
1164 &picture, &got_picture, ptr, len);
1165 ist->st->quality= picture.quality;
1169 /* no picture yet */
1170 goto discard_packet;
1172 if (ist->st->codec.frame_rate_base != 0) {
1173 ist->next_pts += ((int64_t)AV_TIME_BASE *
1174 ist->st->codec.frame_rate_base) /
1175 ist->st->codec.frame_rate;
1183 switch(ist->st->codec.codec_type) {
1184 case CODEC_TYPE_AUDIO:
1185 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec.frame_size) /
1186 (ist->st->codec.sample_rate * ist->st->codec.channels);
1188 case CODEC_TYPE_VIDEO:
1189 if (ist->st->codec.frame_rate_base != 0) {
1190 ist->next_pts += ((int64_t)AV_TIME_BASE *
1191 ist->st->codec.frame_rate_base) /
1192 ist->st->codec.frame_rate;
1202 buffer_to_free = NULL;
1203 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1204 pre_process_video_frame(ist, (AVPicture *)&picture,
1208 /* frame rate emulation */
1209 if (ist->st->codec.rate_emu) {
1210 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1211 int64_t now = av_gettime() - ist->start;
1219 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1220 is the one of the next displayed one */
1221 /* XXX: add mpeg4 too ? */
1222 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1223 if (ist->st->codec.pict_type != B_TYPE) {
1225 tmp = ist->last_ip_pts;
1226 ist->last_ip_pts = ist->frac_pts.val;
1227 ist->frac_pts.val = tmp;
1231 /* if output time reached then transcode raw format,
1232 encode packets and output them */
1233 if (start_time == 0 || ist->pts >= start_time)
1234 for(i=0;i<nb_ostreams;i++) {
1238 if (ost->source_index == ist_index) {
1239 os = output_files[ost->file_index];
1242 printf("%d: got pts=%0.3f %0.3f\n", i,
1243 (double)pkt->pts / AV_TIME_BASE,
1244 ((double)ist->pts / AV_TIME_BASE) -
1245 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1247 /* set the input output pts pairs */
1248 ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1250 if (ost->encoding_needed) {
1251 switch(ost->st->codec.codec_type) {
1252 case CODEC_TYPE_AUDIO:
1253 do_audio_out(os, ost, ist, data_buf, data_size);
1255 case CODEC_TYPE_VIDEO:
1256 do_video_out(os, ost, ist, &picture, &frame_size);
1257 video_size += frame_size;
1258 if (do_vstats && frame_size)
1259 do_video_stats(os, ost, frame_size);
1265 AVFrame avframe; //FIXME/XXX remove this
1267 av_init_packet(&opkt);
1269 /* no reencoding needed : output the packet directly */
1270 /* force the input stream PTS */
1272 avcodec_get_frame_defaults(&avframe);
1273 ost->st->codec.coded_frame= &avframe;
1274 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1276 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1277 audio_size += data_size;
1278 else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1279 video_size += data_size;
1283 opkt.stream_index= ost->index;
1284 opkt.data= data_buf;
1285 opkt.size= data_size;
1286 if(pkt->pts != AV_NOPTS_VALUE)
1287 opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1289 opkt.pts= AV_NOPTS_VALUE;
1290 opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1291 opkt.flags= pkt->flags;
1293 av_interleaved_write_frame(os, &opkt);
1294 ost->st->codec.frame_number++;
1295 ost->frame_number++;
1299 av_free(buffer_to_free);
1305 for(i=0;i<nb_ostreams;i++) {
1307 if (ost->source_index == ist_index) {
1308 AVCodecContext *enc= &ost->st->codec;
1309 os = output_files[ost->file_index];
1311 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1313 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1316 if (ost->encoding_needed) {
1319 av_init_packet(&pkt);
1320 pkt.stream_index= ost->index;
1322 switch(ost->st->codec.codec_type) {
1323 case CODEC_TYPE_AUDIO:
1324 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1326 pkt.flags |= PKT_FLAG_KEY;
1328 case CODEC_TYPE_VIDEO:
1329 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1331 if(enc->coded_frame && enc->coded_frame->key_frame)
1332 pkt.flags |= PKT_FLAG_KEY;
1333 if (ost->logfile && enc->stats_out) {
1334 fprintf(ost->logfile, "%s", enc->stats_out);
1343 pkt.data= bit_buffer;
1345 if(enc->coded_frame)
1346 pkt.pts= enc->coded_frame->pts;
1347 av_interleaved_write_frame(os, &pkt);
1361 * The following code is the main loop of the file converter
1363 static int av_encode(AVFormatContext **output_files,
1364 int nb_output_files,
1365 AVFormatContext **input_files,
1367 AVStreamMap *stream_maps, int nb_stream_maps)
1369 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1370 AVFormatContext *is, *os;
1371 AVCodecContext *codec, *icodec;
1372 AVOutputStream *ost, **ost_table = NULL;
1373 AVInputStream *ist, **ist_table = NULL;
1374 AVInputFile *file_table;
1375 AVFormatContext *stream_no_data;
1378 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1382 /* input stream init */
1384 for(i=0;i<nb_input_files;i++) {
1385 is = input_files[i];
1386 file_table[i].ist_index = j;
1387 file_table[i].nb_streams = is->nb_streams;
1388 j += is->nb_streams;
1392 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1396 for(i=0;i<nb_istreams;i++) {
1397 ist = av_mallocz(sizeof(AVInputStream));
1403 for(i=0;i<nb_input_files;i++) {
1404 is = input_files[i];
1405 for(k=0;k<is->nb_streams;k++) {
1406 ist = ist_table[j++];
1407 ist->st = is->streams[k];
1408 ist->file_index = i;
1410 ist->discard = 1; /* the stream is discarded by default
1413 if (ist->st->codec.rate_emu) {
1414 ist->start = av_gettime();
1420 /* output stream init */
1422 for(i=0;i<nb_output_files;i++) {
1423 os = output_files[i];
1424 nb_ostreams += os->nb_streams;
1426 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1427 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1431 /* Sanity check the mapping args -- do the input files & streams exist? */
1432 for(i=0;i<nb_stream_maps;i++) {
1433 int fi = stream_maps[i].file_index;
1434 int si = stream_maps[i].stream_index;
1436 if (fi < 0 || fi > nb_input_files - 1 ||
1437 si < 0 || si > file_table[fi].nb_streams - 1) {
1438 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1443 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1446 for(i=0;i<nb_ostreams;i++) {
1447 ost = av_mallocz(sizeof(AVOutputStream));
1454 for(k=0;k<nb_output_files;k++) {
1455 os = output_files[k];
1456 for(i=0;i<os->nb_streams;i++) {
1458 ost = ost_table[n++];
1459 ost->file_index = k;
1461 ost->st = os->streams[i];
1462 if (nb_stream_maps > 0) {
1463 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1464 stream_maps[n-1].stream_index;
1466 /* Sanity check that the stream types match */
1467 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1468 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1469 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1470 ost->file_index, ost->index);
1475 /* get corresponding input stream index : we select the first one with the right type */
1477 for(j=0;j<nb_istreams;j++) {
1480 ist->st->codec.codec_type == ost->st->codec.codec_type) {
1481 ost->source_index = j;
1488 /* try again and reuse existing stream */
1489 for(j=0;j<nb_istreams;j++) {
1491 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1492 ost->source_index = j;
1497 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1498 ost->file_index, ost->index);
1503 ist = ist_table[ost->source_index];
1508 /* for each output stream, we compute the right encoding parameters */
1509 for(i=0;i<nb_ostreams;i++) {
1511 ist = ist_table[ost->source_index];
1513 codec = &ost->st->codec;
1514 icodec = &ist->st->codec;
1516 if (ost->st->stream_copy) {
1517 /* if stream_copy is selected, no need to decode or encode */
1518 codec->codec_id = icodec->codec_id;
1519 codec->codec_type = icodec->codec_type;
1520 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1521 codec->bit_rate = icodec->bit_rate;
1522 switch(codec->codec_type) {
1523 case CODEC_TYPE_AUDIO:
1524 codec->sample_rate = icodec->sample_rate;
1525 codec->channels = icodec->channels;
1526 codec->frame_size = icodec->frame_size;
1527 codec->block_align= icodec->block_align;
1529 case CODEC_TYPE_VIDEO:
1530 codec->frame_rate = icodec->frame_rate;
1531 codec->frame_rate_base = icodec->frame_rate_base;
1532 codec->width = icodec->width;
1533 codec->height = icodec->height;
1539 switch(codec->codec_type) {
1540 case CODEC_TYPE_AUDIO:
1541 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1544 if (codec->channels == icodec->channels &&
1545 codec->sample_rate == icodec->sample_rate) {
1546 ost->audio_resample = 0;
1548 if (codec->channels != icodec->channels &&
1549 (icodec->codec_id == CODEC_ID_AC3 ||
1550 icodec->codec_id == CODEC_ID_DTS)) {
1551 /* Special case for 5:1 AC3 and DTS input */
1552 /* and mono or stereo output */
1553 /* Request specific number of channels */
1554 icodec->channels = codec->channels;
1555 if (codec->sample_rate == icodec->sample_rate)
1556 ost->audio_resample = 0;
1558 ost->audio_resample = 1;
1561 ost->audio_resample = 1;
1564 if(audio_sync_method>1)
1565 ost->audio_resample = 1;
1567 if(ost->audio_resample){
1568 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1569 codec->sample_rate, icodec->sample_rate);
1571 printf("Can't resample. Aborting.\n");
1575 ist->decoding_needed = 1;
1576 ost->encoding_needed = 1;
1578 case CODEC_TYPE_VIDEO:
1579 if (codec->width == icodec->width &&
1580 codec->height == icodec->height &&
1581 frame_topBand == 0 &&
1582 frame_bottomBand == 0 &&
1583 frame_leftBand == 0 &&
1584 frame_rightBand == 0 &&
1585 frame_padtop == 0 &&
1586 frame_padbottom == 0 &&
1587 frame_padleft == 0 &&
1588 frame_padright == 0)
1590 ost->video_resample = 0;
1591 ost->video_crop = 0;
1593 } else if ((codec->width == icodec->width -
1594 (frame_leftBand + frame_rightBand)) &&
1595 (codec->height == icodec->height -
1596 (frame_topBand + frame_bottomBand)))
1598 ost->video_resample = 0;
1599 ost->video_crop = 1;
1600 ost->topBand = frame_topBand;
1601 ost->leftBand = frame_leftBand;
1602 } else if ((codec->width == icodec->width +
1603 (frame_padleft + frame_padright)) &&
1604 (codec->height == icodec->height +
1605 (frame_padtop + frame_padbottom))) {
1606 ost->video_resample = 0;
1607 ost->video_crop = 0;
1609 ost->padtop = frame_padtop;
1610 ost->padleft = frame_padleft;
1611 ost->padbottom = frame_padbottom;
1612 ost->padright = frame_padright;
1613 avcodec_get_frame_defaults(&ost->pict_tmp);
1614 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1615 codec->width, codec->height ) )
1618 ost->video_resample = 1;
1619 ost->video_crop = 0; // cropping is handled as part of resample
1620 avcodec_get_frame_defaults(&ost->pict_tmp);
1621 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1622 codec->width, codec->height ) )
1625 ost->img_resample_ctx = img_resample_full_init(
1626 ost->st->codec.width, ost->st->codec.height,
1627 ist->st->codec.width, ist->st->codec.height,
1628 frame_topBand, frame_bottomBand,
1629 frame_leftBand, frame_rightBand,
1630 frame_padtop, frame_padbottom,
1631 frame_padleft, frame_padright);
1633 ost->padtop = frame_padtop;
1634 ost->padleft = frame_padleft;
1635 ost->padbottom = frame_padbottom;
1636 ost->padright = frame_padright;
1639 ost->encoding_needed = 1;
1640 ist->decoding_needed = 1;
1646 if (ost->encoding_needed &&
1647 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1648 char logfilename[1024];
1653 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1655 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1656 if (codec->flags & CODEC_FLAG_PASS1) {
1657 f = fopen(logfilename, "w");
1659 perror(logfilename);
1664 /* read the log file */
1665 f = fopen(logfilename, "r");
1667 perror(logfilename);
1670 fseek(f, 0, SEEK_END);
1672 fseek(f, 0, SEEK_SET);
1673 logbuffer = av_malloc(size + 1);
1675 fprintf(stderr, "Could not allocate log buffer\n");
1678 size = fread(logbuffer, 1, size, f);
1680 logbuffer[size] = '\0';
1681 codec->stats_in = logbuffer;
1685 if(codec->codec_type == CODEC_TYPE_VIDEO){
1686 int size= codec->width * codec->height;
1687 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1692 bit_buffer = av_malloc(bit_buffer_size);
1696 /* dump the file output parameters - cannot be done before in case
1698 for(i=0;i<nb_output_files;i++) {
1699 dump_format(output_files[i], i, output_files[i]->filename, 1);
1702 /* dump the stream mapping */
1704 fprintf(stderr, "Stream mapping:\n");
1705 for(i=0;i<nb_ostreams;i++) {
1707 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
1708 ist_table[ost->source_index]->file_index,
1709 ist_table[ost->source_index]->index,
1715 /* open each encoder */
1716 for(i=0;i<nb_ostreams;i++) {
1718 if (ost->encoding_needed) {
1720 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1722 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1723 ost->file_index, ost->index);
1726 if (avcodec_open(&ost->st->codec, codec) < 0) {
1727 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1728 ost->file_index, ost->index);
1731 extra_size += ost->st->codec.extradata_size;
1735 /* open each decoder */
1736 for(i=0;i<nb_istreams;i++) {
1738 if (ist->decoding_needed) {
1740 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1742 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1743 ist->st->codec.codec_id, ist->file_index, ist->index);
1746 if (avcodec_open(&ist->st->codec, codec) < 0) {
1747 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1748 ist->file_index, ist->index);
1751 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1752 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1757 for(i=0;i<nb_istreams;i++) {
1759 is = input_files[ist->file_index];
1761 ist->next_pts = ist->st->start_time;
1762 if(ist->next_pts == AV_NOPTS_VALUE)
1764 if(input_files_ts_offset[ist->file_index])
1765 ist->next_pts= AV_NOPTS_VALUE;
1769 /* compute buffer size max (should use a complete heuristic) */
1770 for(i=0;i<nb_input_files;i++) {
1771 file_table[i].buffer_size_max = 2048;
1774 /* set meta data information from input file if required */
1775 for (i=0;i<nb_meta_data_maps;i++) {
1776 AVFormatContext *out_file;
1777 AVFormatContext *in_file;
1779 int out_file_index = meta_data_maps[i].out_file;
1780 int in_file_index = meta_data_maps[i].in_file;
1781 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1782 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1786 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1787 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1792 out_file = output_files[out_file_index];
1793 in_file = input_files[in_file_index];
1795 strcpy(out_file->title, in_file->title);
1796 strcpy(out_file->author, in_file->author);
1797 strcpy(out_file->copyright, in_file->copyright);
1798 strcpy(out_file->comment, in_file->comment);
1799 strcpy(out_file->album, in_file->album);
1800 out_file->year = in_file->year;
1801 out_file->track = in_file->track;
1802 strcpy(out_file->genre, in_file->genre);
1805 /* open files and write file headers */
1806 for(i=0;i<nb_output_files;i++) {
1807 os = output_files[i];
1808 if (av_write_header(os) < 0) {
1809 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1815 #ifndef CONFIG_WIN32
1816 if ( !using_stdin && verbose >= 0) {
1817 fprintf(stderr, "Press [q] to stop encoding\n");
1818 url_set_interrupt_cb(decode_interrupt_cb);
1826 for(; received_sigterm == 0;) {
1827 int file_index, ist_index;
1835 /* if 'q' pressed, exits */
1839 /* read_key() returns 0 on EOF */
1845 /* select the stream that we must read now by looking at the
1846 smallest output pts */
1848 for(i=0;i<nb_ostreams;i++) {
1851 os = output_files[ost->file_index];
1852 ist = ist_table[ost->source_index];
1853 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1854 opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1856 opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1857 ipts = (double)ist->pts;
1858 if (!file_table[ist->file_index].eof_reached){
1859 if(ipts < ipts_min) {
1861 if(input_sync ) file_index = ist->file_index;
1863 if(opts < opts_min) {
1865 if(!input_sync) file_index = ist->file_index;
1868 if(ost->frame_number >= max_frames[ost->st->codec.codec_type]){
1873 /* if none, if is finished */
1874 if (file_index < 0) {
1878 /* finish if recording time exhausted */
1879 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1882 /* read a frame from it and output it in the fifo */
1883 is = input_files[file_index];
1884 if (av_read_frame(is, &pkt) < 0) {
1885 file_table[file_index].eof_reached = 1;
1890 stream_no_data = is;
1895 av_pkt_dump(stdout, &pkt, do_hex_dump);
1897 /* the following test is needed in case new streams appear
1898 dynamically in stream : we ignore them */
1899 if (pkt.stream_index >= file_table[file_index].nb_streams)
1900 goto discard_packet;
1901 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1902 ist = ist_table[ist_index];
1904 goto discard_packet;
1906 // 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);
1907 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1908 int64_t delta= pkt.dts - ist->next_pts;
1909 if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1910 input_files_ts_offset[ist->file_index]-= delta;
1912 fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1913 for(i=0; i<file_table[file_index].nb_streams; i++){
1914 int index= file_table[file_index].ist_index + i;
1915 ist_table[index]->next_pts += delta;
1916 ist_table[index]->is_start=1;
1921 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1922 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1925 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1926 ist->file_index, ist->index);
1928 av_free_packet(&pkt);
1933 av_free_packet(&pkt);
1935 /* dump report by using the output first video and audio streams */
1936 print_report(output_files, ost_table, nb_ostreams, 0);
1939 /* at the end of stream, we must flush the decoder buffers */
1940 for(i=0;i<nb_istreams;i++) {
1942 if (ist->decoding_needed) {
1943 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1949 /* write the trailer if needed and close file */
1950 for(i=0;i<nb_output_files;i++) {
1951 os = output_files[i];
1952 av_write_trailer(os);
1955 /* dump report by using the first video and audio streams */
1956 print_report(output_files, ost_table, nb_ostreams, 1);
1958 /* close each encoder */
1959 for(i=0;i<nb_ostreams;i++) {
1961 if (ost->encoding_needed) {
1962 av_freep(&ost->st->codec.stats_in);
1963 avcodec_close(&ost->st->codec);
1967 /* close each decoder */
1968 for(i=0;i<nb_istreams;i++) {
1970 if (ist->decoding_needed) {
1971 avcodec_close(&ist->st->codec);
1979 av_freep(&bit_buffer);
1980 av_free(file_table);
1983 for(i=0;i<nb_istreams;i++) {
1990 for(i=0;i<nb_ostreams;i++) {
1994 fclose(ost->logfile);
1995 ost->logfile = NULL;
1997 fifo_free(&ost->fifo); /* works even if fifo is not
1998 initialized but set to zero */
1999 av_free(ost->pict_tmp.data[0]);
2000 if (ost->video_resample)
2001 img_resample_close(ost->img_resample_ctx);
2002 if (ost->audio_resample)
2003 audio_resample_close(ost->resample);
2016 int file_read(const char *filename)
2019 unsigned char buffer[1024];
2022 if (url_open(&h, filename, O_RDONLY) < 0) {
2023 printf("could not open '%s'\n", filename);
2027 len = url_read(h, buffer, sizeof(buffer));
2030 for(i=0;i<len;i++) putchar(buffer[i]);
2037 static void opt_image_format(const char *arg)
2041 for(f = first_image_format; f != NULL; f = f->next) {
2042 if (!strcmp(arg, f->name))
2046 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2052 static void opt_format(const char *arg)
2054 /* compatibility stuff for pgmyuv */
2055 if (!strcmp(arg, "pgmyuv")) {
2056 pgmyuv_compatibility_hack=1;
2057 // opt_image_format(arg);
2061 file_iformat = av_find_input_format(arg);
2062 file_oformat = guess_format(arg, NULL, NULL);
2063 if (!file_iformat && !file_oformat) {
2064 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2069 static void opt_video_bitrate(const char *arg)
2071 video_bit_rate = atoi(arg) * 1000;
2074 static void opt_video_bitrate_tolerance(const char *arg)
2076 video_bit_rate_tolerance = atoi(arg) * 1000;
2079 static void opt_video_bitrate_max(const char *arg)
2081 video_rc_max_rate = atoi(arg) * 1000;
2084 static void opt_video_bitrate_min(const char *arg)
2086 video_rc_min_rate = atoi(arg) * 1000;
2089 static void opt_video_buffer_size(const char *arg)
2091 video_rc_buffer_size = atoi(arg) * 8*1024;
2094 static void opt_video_rc_eq(char *arg)
2099 static void opt_video_rc_override_string(char *arg)
2101 video_rc_override_string = arg;
2105 static void opt_workaround_bugs(const char *arg)
2107 workaround_bugs = atoi(arg);
2110 static void opt_dct_algo(const char *arg)
2112 dct_algo = atoi(arg);
2115 static void opt_idct_algo(const char *arg)
2117 idct_algo = atoi(arg);
2120 static void opt_me_threshold(const char *arg)
2122 me_threshold = atoi(arg);
2125 static void opt_mb_threshold(const char *arg)
2127 mb_threshold = atoi(arg);
2130 static void opt_error_resilience(const char *arg)
2132 error_resilience = atoi(arg);
2135 static void opt_error_concealment(const char *arg)
2137 error_concealment = atoi(arg);
2140 static void opt_debug(const char *arg)
2145 static void opt_vismv(const char *arg)
2147 debug_mv = atoi(arg);
2150 static void opt_verbose(const char *arg)
2152 verbose = atoi(arg);
2153 av_log_set_level(atoi(arg));
2156 static void opt_frame_rate(const char *arg)
2158 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2159 fprintf(stderr, "Incorrect frame rate\n");
2164 static void opt_frame_crop_top(const char *arg)
2166 frame_topBand = atoi(arg);
2167 if (frame_topBand < 0) {
2168 fprintf(stderr, "Incorrect top crop size\n");
2171 if ((frame_topBand % 2) != 0) {
2172 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2175 if ((frame_topBand) >= frame_height){
2176 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2179 frame_height -= frame_topBand;
2182 static void opt_frame_crop_bottom(const char *arg)
2184 frame_bottomBand = atoi(arg);
2185 if (frame_bottomBand < 0) {
2186 fprintf(stderr, "Incorrect bottom crop size\n");
2189 if ((frame_bottomBand % 2) != 0) {
2190 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2193 if ((frame_bottomBand) >= frame_height){
2194 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2197 frame_height -= frame_bottomBand;
2200 static void opt_frame_crop_left(const char *arg)
2202 frame_leftBand = atoi(arg);
2203 if (frame_leftBand < 0) {
2204 fprintf(stderr, "Incorrect left crop size\n");
2207 if ((frame_leftBand % 2) != 0) {
2208 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2211 if ((frame_leftBand) >= frame_width){
2212 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2215 frame_width -= frame_leftBand;
2218 static void opt_frame_crop_right(const char *arg)
2220 frame_rightBand = atoi(arg);
2221 if (frame_rightBand < 0) {
2222 fprintf(stderr, "Incorrect right crop size\n");
2225 if ((frame_rightBand % 2) != 0) {
2226 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2229 if ((frame_rightBand) >= frame_width){
2230 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2233 frame_width -= frame_rightBand;
2236 static void opt_frame_size(const char *arg)
2238 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2239 fprintf(stderr, "Incorrect frame size\n");
2242 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2243 fprintf(stderr, "Frame size must be a multiple of 2\n");
2249 #define SCALEBITS 10
2250 #define ONE_HALF (1 << (SCALEBITS - 1))
2251 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2253 #define RGB_TO_Y(r, g, b) \
2254 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2255 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2257 #define RGB_TO_U(r1, g1, b1, shift)\
2258 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2259 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2261 #define RGB_TO_V(r1, g1, b1, shift)\
2262 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2263 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2265 static void opt_pad_color(const char *arg) {
2266 /* Input is expected to be six hex digits similar to
2267 how colors are expressed in html tags (but without the #) */
2268 int rgb = strtol(arg, NULL, 16);
2272 g = ((rgb >> 8) & 255);
2275 padcolor[0] = RGB_TO_Y(r,g,b);
2276 padcolor[1] = RGB_TO_U(r,g,b,0);
2277 padcolor[2] = RGB_TO_V(r,g,b,0);
2280 static void opt_frame_pad_top(const char *arg)
2282 frame_padtop = atoi(arg);
2283 if (frame_padtop < 0) {
2284 fprintf(stderr, "Incorrect top pad size\n");
2287 if ((frame_padtop % 2) != 0) {
2288 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2293 static void opt_frame_pad_bottom(const char *arg)
2295 frame_padbottom = atoi(arg);
2296 if (frame_padbottom < 0) {
2297 fprintf(stderr, "Incorrect bottom pad size\n");
2300 if ((frame_padbottom % 2) != 0) {
2301 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2307 static void opt_frame_pad_left(const char *arg)
2309 frame_padleft = atoi(arg);
2310 if (frame_padleft < 0) {
2311 fprintf(stderr, "Incorrect left pad size\n");
2314 if ((frame_padleft % 2) != 0) {
2315 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2321 static void opt_frame_pad_right(const char *arg)
2323 frame_padright = atoi(arg);
2324 if (frame_padright < 0) {
2325 fprintf(stderr, "Incorrect right pad size\n");
2328 if ((frame_padright % 2) != 0) {
2329 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2335 static void opt_frame_pix_fmt(const char *arg)
2337 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2340 static void opt_frame_aspect_ratio(const char *arg)
2346 p = strchr(arg, ':');
2348 x = strtol(arg, (char **)&arg, 10);
2350 y = strtol(arg+1, (char **)&arg, 10);
2352 ar = (double)x / (double)y;
2354 ar = strtod(arg, (char **)&arg);
2357 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2360 frame_aspect_ratio = ar;
2363 static void opt_gop_size(const char *arg)
2365 gop_size = atoi(arg);
2368 static void opt_b_frames(const char *arg)
2370 b_frames = atoi(arg);
2371 if (b_frames > FF_MAX_B_FRAMES) {
2372 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2374 } else if (b_frames < 1) {
2375 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2380 static void opt_mb_decision(const char *arg)
2382 mb_decision = atoi(arg);
2385 static void opt_mb_cmp(const char *arg)
2390 static void opt_ildct_cmp(const char *arg)
2392 ildct_cmp = atoi(arg);
2395 static void opt_sub_cmp(const char *arg)
2397 sub_cmp = atoi(arg);
2400 static void opt_cmp(const char *arg)
2405 static void opt_pre_cmp(const char *arg)
2407 pre_cmp = atoi(arg);
2410 static void opt_pre_me(const char *arg)
2415 static void opt_lumi_mask(const char *arg)
2417 lumi_mask = atof(arg);
2420 static void opt_dark_mask(const char *arg)
2422 dark_mask = atof(arg);
2425 static void opt_scplx_mask(const char *arg)
2427 scplx_mask = atof(arg);
2430 static void opt_tcplx_mask(const char *arg)
2432 tcplx_mask = atof(arg);
2435 static void opt_p_mask(const char *arg)
2440 static void opt_qscale(const char *arg)
2442 video_qscale = atof(arg);
2443 if (video_qscale < 0.01 ||
2444 video_qscale > 255) {
2445 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2450 static void opt_qsquish(const char *arg)
2452 video_qsquish = atof(arg);
2453 if (video_qsquish < 0.0 ||
2454 video_qsquish > 99.0) {
2455 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2460 static void opt_lelim(const char *arg)
2462 video_lelim = atoi(arg);
2463 if (video_lelim < -99 ||
2465 fprintf(stderr, "lelim must be >= -99 and <= 99\n");
2470 static void opt_celim(const char *arg)
2472 video_celim = atoi(arg);
2473 if (video_celim < -99 ||
2475 fprintf(stderr, "celim must be >= -99 and <= 99\n");
2480 static void opt_lmax(const char *arg)
2482 video_lmax = atof(arg)*FF_QP2LAMBDA;
2485 static void opt_lmin(const char *arg)
2487 video_lmin = atof(arg)*FF_QP2LAMBDA;
2490 static void opt_qmin(const char *arg)
2492 video_qmin = atoi(arg);
2493 if (video_qmin < 0 ||
2495 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2500 static void opt_qmax(const char *arg)
2502 video_qmax = atoi(arg);
2503 if (video_qmax < 0 ||
2505 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2510 static void opt_mb_qmin(const char *arg)
2512 video_mb_qmin = atoi(arg);
2513 if (video_mb_qmin < 0 ||
2514 video_mb_qmin > 31) {
2515 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2520 static void opt_mb_qmax(const char *arg)
2522 video_mb_qmax = atoi(arg);
2523 if (video_mb_qmax < 0 ||
2524 video_mb_qmax > 31) {
2525 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2530 static void opt_qdiff(const char *arg)
2532 video_qdiff = atoi(arg);
2533 if (video_qdiff < 0 ||
2535 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2540 static void opt_qblur(const char *arg)
2542 video_qblur = atof(arg);
2545 static void opt_qcomp(const char *arg)
2547 video_qcomp = atof(arg);
2550 static void opt_rc_initial_cplx(const char *arg)
2552 video_rc_initial_cplx = atof(arg);
2554 static void opt_b_qfactor(const char *arg)
2556 video_b_qfactor = atof(arg);
2558 static void opt_i_qfactor(const char *arg)
2560 video_i_qfactor = atof(arg);
2562 static void opt_b_qoffset(const char *arg)
2564 video_b_qoffset = atof(arg);
2566 static void opt_i_qoffset(const char *arg)
2568 video_i_qoffset = atof(arg);
2571 static void opt_ibias(const char *arg)
2573 video_intra_quant_bias = atoi(arg);
2575 static void opt_pbias(const char *arg)
2577 video_inter_quant_bias = atoi(arg);
2580 static void opt_packet_size(const char *arg)
2582 packet_size= atoi(arg);
2585 static void opt_error_rate(const char *arg)
2587 error_rate= atoi(arg);
2590 static void opt_strict(const char *arg)
2595 static void opt_top_field_first(const char *arg)
2597 top_field_first= atoi(arg);
2600 static void opt_noise_reduction(const char *arg)
2602 noise_reduction= atoi(arg);
2605 static void opt_qns(const char *arg)
2610 static void opt_sc_threshold(const char *arg)
2612 sc_threshold= atoi(arg);
2615 static void opt_me_range(const char *arg)
2617 me_range = atoi(arg);
2620 static void opt_thread_count(const char *arg)
2622 thread_count= atoi(arg);
2623 #if !defined(HAVE_THREADS)
2625 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2629 static void opt_audio_bitrate(const char *arg)
2631 audio_bit_rate = atoi(arg) * 1000;
2634 static void opt_audio_rate(const char *arg)
2636 audio_sample_rate = atoi(arg);
2639 static void opt_audio_channels(const char *arg)
2641 audio_channels = atoi(arg);
2644 static void opt_video_device(const char *arg)
2646 video_device = av_strdup(arg);
2649 static void opt_grab_device(const char *arg)
2651 grab_device = av_strdup(arg);
2654 static void opt_video_channel(const char *arg)
2656 video_channel = strtol(arg, NULL, 0);
2659 static void opt_video_standard(const char *arg)
2661 video_standard = av_strdup(arg);
2664 static void opt_audio_device(const char *arg)
2666 audio_device = av_strdup(arg);
2669 static void opt_audio_codec(const char *arg)
2673 if (!strcmp(arg, "copy")) {
2674 audio_stream_copy = 1;
2678 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2683 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2686 audio_codec_id = p->id;
2691 static void opt_audio_tag(const char *arg)
2694 audio_codec_tag= strtol(arg, &tail, 0);
2697 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2700 static void opt_video_tag(const char *arg)
2703 video_codec_tag= strtol(arg, &tail, 0);
2706 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2709 static void add_frame_hooker(const char *arg)
2714 char *args = av_strdup(arg);
2718 argv[0] = strtok(args, " ");
2719 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2722 i = frame_hook_add(argc, argv);
2725 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2730 const char *motion_str[] = {
2740 static void opt_motion_estimation(const char *arg)
2746 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2749 if (!strcmp(*p, arg))
2753 me_method = (p - motion_str) + 1;
2756 static void opt_video_codec(const char *arg)
2760 if (!strcmp(arg, "copy")) {
2761 video_stream_copy = 1;
2765 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2770 fprintf(stderr, "Unknown video codec '%s'\n", arg);
2773 video_codec_id = p->id;
2778 static void opt_map(const char *arg)
2784 m = &stream_maps[nb_stream_maps++];
2786 m->file_index = strtol(arg, (char **)&p, 0);
2790 m->stream_index = strtol(p, (char **)&p, 0);
2793 static void opt_map_meta_data(const char *arg)
2799 m = &meta_data_maps[nb_meta_data_maps++];
2801 m->out_file = strtol(arg, (char **)&p, 0);
2805 m->in_file = strtol(p, (char **)&p, 0);
2808 static void opt_recording_time(const char *arg)
2810 recording_time = parse_date(arg, 1);
2813 static void opt_start_time(const char *arg)
2815 start_time = parse_date(arg, 1);
2818 static void opt_rec_timestamp(const char *arg)
2820 rec_timestamp = parse_date(arg, 0) / 1000000;
2823 static void opt_input_ts_offset(const char *arg)
2825 input_ts_offset = parse_date(arg, 1);
2828 static void opt_input_file(const char *filename)
2830 AVFormatContext *ic;
2831 AVFormatParameters params, *ap = ¶ms;
2832 int err, i, ret, rfps, rfps_base;
2835 if (!strcmp(filename, "-"))
2838 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2839 !strcmp( filename, "/dev/stdin" );
2841 /* get default parameters from command line */
2842 memset(ap, 0, sizeof(*ap));
2843 ap->sample_rate = audio_sample_rate;
2844 ap->channels = audio_channels;
2845 ap->frame_rate = frame_rate;
2846 ap->frame_rate_base = frame_rate_base;
2847 ap->width = frame_width + frame_padleft + frame_padright;
2848 ap->height = frame_height + frame_padtop + frame_padbottom;
2849 ap->image_format = image_format;
2850 ap->pix_fmt = frame_pix_fmt;
2851 ap->device = grab_device;
2852 ap->channel = video_channel;
2853 ap->standard = video_standard;
2854 ap->video_codec_id = video_codec_id;
2855 ap->audio_codec_id = audio_codec_id;
2856 if(pgmyuv_compatibility_hack)
2857 ap->video_codec_id= CODEC_ID_PGMYUV;
2859 /* open the input file with generic libav function */
2860 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2862 print_error(filename, err);
2866 /* If not enough info to get the stream parameters, we decode the
2867 first frames to get it. (used in mpeg case for example) */
2868 ret = av_find_stream_info(ic);
2869 if (ret < 0 && verbose >= 0) {
2870 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2874 timestamp = start_time;
2875 /* add the stream start time */
2876 if (ic->start_time != AV_NOPTS_VALUE)
2877 timestamp += ic->start_time;
2879 /* if seeking requested, we execute it */
2880 if (start_time != 0) {
2881 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2883 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2884 filename, (double)timestamp / AV_TIME_BASE);
2886 /* reset seek info */
2890 /* update the current parameters so that they match the one of the input stream */
2891 for(i=0;i<ic->nb_streams;i++) {
2892 AVCodecContext *enc = &ic->streams[i]->codec;
2893 #if defined(HAVE_THREADS)
2895 avcodec_thread_init(enc, thread_count);
2897 enc->thread_count= thread_count;
2898 switch(enc->codec_type) {
2899 case CODEC_TYPE_AUDIO:
2900 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2901 audio_channels = enc->channels;
2902 audio_sample_rate = enc->sample_rate;
2904 ic->streams[i]->discard= 1;
2906 case CODEC_TYPE_VIDEO:
2907 frame_height = enc->height;
2908 frame_width = enc->width;
2909 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2910 frame_pix_fmt = enc->pix_fmt;
2911 rfps = ic->streams[i]->r_frame_rate;
2912 rfps_base = ic->streams[i]->r_frame_rate_base;
2913 enc->workaround_bugs = workaround_bugs;
2914 enc->error_resilience = error_resilience;
2915 enc->error_concealment = error_concealment;
2916 enc->idct_algo = idct_algo;
2918 enc->debug_mv = debug_mv;
2919 enc->lowres= lowres;
2921 enc->flags|= CODEC_FLAG_BITEXACT;
2923 enc->debug |= FF_DEBUG_MV;
2925 if (enc->frame_rate != rfps || enc->frame_rate_base != rfps_base) {
2928 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2929 i, (float)enc->frame_rate / enc->frame_rate_base, enc->frame_rate, enc->frame_rate_base,
2931 (float)rfps / rfps_base, rfps, rfps_base);
2933 /* update the current frame rate to match the stream frame rate */
2935 frame_rate_base = rfps_base;
2937 enc->rate_emu = rate_emu;
2939 ic->streams[i]->discard= 1;
2941 case CODEC_TYPE_DATA:
2948 input_files[nb_input_files] = ic;
2949 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2950 /* dump the file content */
2952 dump_format(ic, nb_input_files, filename, 0);
2955 file_iformat = NULL;
2956 file_oformat = NULL;
2957 image_format = NULL;
2965 static void opt_grab(const char *arg)
2967 file_iformat = av_find_input_format(arg);
2971 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2973 int has_video, has_audio, i, j;
2974 AVFormatContext *ic;
2978 for(j=0;j<nb_input_files;j++) {
2979 ic = input_files[j];
2980 for(i=0;i<ic->nb_streams;i++) {
2981 AVCodecContext *enc = &ic->streams[i]->codec;
2982 switch(enc->codec_type) {
2983 case CODEC_TYPE_AUDIO:
2986 case CODEC_TYPE_VIDEO:
2989 case CODEC_TYPE_DATA:
2996 *has_video_ptr = has_video;
2997 *has_audio_ptr = has_audio;
3000 static void opt_output_file(const char *filename)
3003 AVFormatContext *oc;
3004 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
3006 AVFormatParameters params, *ap = ¶ms;
3008 if (!strcmp(filename, "-"))
3011 oc = av_alloc_format_context();
3013 if (!file_oformat) {
3014 file_oformat = guess_format(NULL, filename, NULL);
3015 if (!file_oformat) {
3016 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3022 oc->oformat = file_oformat;
3024 if (!strcmp(file_oformat->name, "ffm") &&
3025 strstart(filename, "http:", NULL)) {
3026 /* special case for files sent to ffserver: we get the stream
3027 parameters from ffserver */
3028 if (read_ffserver_streams(oc, filename) < 0) {
3029 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3033 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
3034 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
3036 /* disable if no corresponding type found and at least one
3038 if (nb_input_files > 0) {
3039 check_audio_video_inputs(&input_has_video, &input_has_audio);
3040 if (!input_has_video)
3042 if (!input_has_audio)
3046 /* manual disable */
3047 if (audio_disable) {
3050 if (video_disable) {
3056 AVCodecContext *video_enc;
3058 st = av_new_stream(oc, nb_streams++);
3060 fprintf(stderr, "Could not alloc stream\n");
3063 #if defined(HAVE_THREADS)
3065 avcodec_thread_init(&st->codec, thread_count);
3068 video_enc = &st->codec;
3071 video_enc->codec_tag= video_codec_tag;
3073 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3074 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3075 if (video_stream_copy) {
3076 st->stream_copy = 1;
3077 video_enc->codec_type = CODEC_TYPE_VIDEO;
3083 codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_VIDEO);
3084 if (video_codec_id != CODEC_ID_NONE)
3085 codec_id = video_codec_id;
3087 video_enc->codec_id = codec_id;
3088 codec = avcodec_find_encoder(codec_id);
3090 video_enc->bit_rate = video_bit_rate;
3091 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3092 video_enc->frame_rate = frame_rate;
3093 video_enc->frame_rate_base = frame_rate_base;
3094 if(codec && codec->supported_framerates){
3095 const AVRational *p= codec->supported_framerates;
3096 AVRational req= (AVRational){frame_rate, frame_rate_base};
3097 const AVRational *best=NULL;
3098 AVRational best_error= (AVRational){INT_MAX, 1};
3099 for(; p->den!=0; p++){
3100 AVRational error= av_sub_q(req, *p);
3101 if(error.num <0) error.num *= -1;
3102 if(av_cmp_q(error, best_error) < 0){
3107 video_enc->frame_rate = best->num;
3108 video_enc->frame_rate_base= best->den;
3111 video_enc->width = frame_width + frame_padright + frame_padleft;
3112 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3113 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3114 video_enc->pix_fmt = frame_pix_fmt;
3116 if(codec && codec->pix_fmts){
3117 const enum PixelFormat *p= codec->pix_fmts;
3119 if(*p == video_enc->pix_fmt)
3123 video_enc->pix_fmt = codec->pix_fmts[0];
3127 video_enc->gop_size = gop_size;
3129 video_enc->gop_size = 0;
3130 if (video_qscale || same_quality) {
3131 video_enc->flags |= CODEC_FLAG_QSCALE;
3132 st->quality = FF_QP2LAMBDA * video_qscale;
3136 video_enc->intra_matrix = intra_matrix;
3138 video_enc->inter_matrix = inter_matrix;
3141 video_enc->flags |= CODEC_FLAG_BITEXACT;
3143 video_enc->mb_decision = mb_decision;
3144 video_enc->mb_cmp = mb_cmp;
3145 video_enc->ildct_cmp = ildct_cmp;
3146 video_enc->me_sub_cmp = sub_cmp;
3147 video_enc->me_cmp = cmp;
3148 video_enc->me_pre_cmp = pre_cmp;
3149 video_enc->pre_me = pre_me;
3150 video_enc->lumi_masking = lumi_mask;
3151 video_enc->dark_masking = dark_mask;
3152 video_enc->spatial_cplx_masking = scplx_mask;
3153 video_enc->temporal_cplx_masking = tcplx_mask;
3154 video_enc->p_masking = p_mask;
3155 video_enc->quantizer_noise_shaping= qns;
3158 video_enc->flags |= CODEC_FLAG_H263P_UMV;
3161 video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3164 video_enc->flags |= CODEC_FLAG_H263P_AIC;
3167 video_enc->flags |= CODEC_FLAG_H263P_AIV;
3170 video_enc->flags |= CODEC_FLAG_4MV;
3173 video_enc->flags |= CODEC_FLAG_OBMC;
3176 video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3180 video_enc->flags |= CODEC_FLAG_PART;
3183 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3186 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3189 video_enc->flags |= CODEC_FLAG_MV0;
3191 if (do_normalize_aqp) {
3192 video_enc->flags |= CODEC_FLAG_NORMALIZE_AQP;
3194 if (use_scan_offset) {
3195 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3198 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3201 video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3204 video_enc->flags |= CODEC_FLAG_QPEL;
3207 video_enc->flags |= CODEC_FLAG_QP_RD;
3210 video_enc->flags |= CODEC_FLAG_CBP_RD;
3213 video_enc->max_b_frames = b_frames;
3214 video_enc->b_frame_strategy = 0;
3215 video_enc->b_quant_factor = 2.0;
3217 if (do_interlace_dct) {
3218 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3220 if (do_interlace_me) {
3221 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3223 video_enc->qmin = video_qmin;
3224 video_enc->qmax = video_qmax;
3225 video_enc->lmin = video_lmin;
3226 video_enc->lmax = video_lmax;
3227 video_enc->rc_qsquish = video_qsquish;
3228 video_enc->luma_elim_threshold = video_lelim;
3229 video_enc->chroma_elim_threshold = video_celim;
3230 video_enc->mb_qmin = video_mb_qmin;
3231 video_enc->mb_qmax = video_mb_qmax;
3232 video_enc->max_qdiff = video_qdiff;
3233 video_enc->qblur = video_qblur;
3234 video_enc->qcompress = video_qcomp;
3235 video_enc->rc_eq = video_rc_eq;
3236 video_enc->debug = debug;
3237 video_enc->debug_mv = debug_mv;
3238 video_enc->thread_count = thread_count;
3239 p= video_rc_override_string;
3242 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3244 fprintf(stderr, "error parsing rc_override\n");
3247 video_enc->rc_override=
3248 av_realloc(video_enc->rc_override,
3249 sizeof(RcOverride)*(i+1));
3250 video_enc->rc_override[i].start_frame= start;
3251 video_enc->rc_override[i].end_frame = end;
3253 video_enc->rc_override[i].qscale= q;
3254 video_enc->rc_override[i].quality_factor= 1.0;
3257 video_enc->rc_override[i].qscale= 0;
3258 video_enc->rc_override[i].quality_factor= -q/100.0;
3263 video_enc->rc_override_count=i;
3265 video_enc->rc_max_rate = video_rc_max_rate;
3266 video_enc->rc_min_rate = video_rc_min_rate;
3267 video_enc->rc_buffer_size = video_rc_buffer_size;
3268 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3269 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3270 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3271 video_enc->i_quant_factor = video_i_qfactor;
3272 video_enc->b_quant_factor = video_b_qfactor;
3273 video_enc->i_quant_offset = video_i_qoffset;
3274 video_enc->b_quant_offset = video_b_qoffset;
3275 video_enc->intra_quant_bias = video_intra_quant_bias;
3276 video_enc->inter_quant_bias = video_inter_quant_bias;
3277 video_enc->dct_algo = dct_algo;
3278 video_enc->idct_algo = idct_algo;
3279 video_enc->me_threshold= me_threshold;
3280 video_enc->mb_threshold= mb_threshold;
3281 video_enc->intra_dc_precision= intra_dc_precision - 8;
3282 video_enc->strict_std_compliance = strict;
3283 video_enc->error_rate = error_rate;
3284 video_enc->noise_reduction= noise_reduction;
3285 video_enc->scenechange_threshold= sc_threshold;
3286 video_enc->me_range = me_range;
3287 video_enc->coder_type= coder;
3288 video_enc->context_model= context;
3289 video_enc->prediction_method= predictor;
3290 video_enc->profile= video_profile;
3291 video_enc->level= video_level;
3292 video_enc->nsse_weight= nsse_weight;
3293 video_enc->me_subpel_quality= subpel_quality;
3294 video_enc->frame_skip_threshold= frame_skip_threshold;
3295 video_enc->frame_skip_factor= frame_skip_factor;
3296 video_enc->frame_skip_exp= frame_skip_exp;
3297 video_enc->frame_skip_cmp= frame_skip_cmp;
3300 video_enc->rtp_mode= 1;
3301 video_enc->rtp_payload_size= packet_size;
3305 video_enc->flags|= CODEC_FLAG_PSNR;
3307 video_enc->me_method = me_method;
3312 video_enc->flags |= CODEC_FLAG_PASS1;
3314 video_enc->flags |= CODEC_FLAG_PASS2;
3321 AVCodecContext *audio_enc;
3323 st = av_new_stream(oc, nb_streams++);
3325 fprintf(stderr, "Could not alloc stream\n");
3328 #if defined(HAVE_THREADS)
3330 avcodec_thread_init(&st->codec, thread_count);
3333 audio_enc = &st->codec;
3334 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3337 audio_enc->codec_tag= audio_codec_tag;
3339 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3340 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3341 if (audio_stream_copy) {
3342 st->stream_copy = 1;
3343 audio_enc->channels = audio_channels;
3345 codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_AUDIO);
3346 if (audio_codec_id != CODEC_ID_NONE)
3347 codec_id = audio_codec_id;
3348 audio_enc->codec_id = codec_id;
3350 audio_enc->bit_rate = audio_bit_rate;
3351 audio_enc->strict_std_compliance = strict;
3352 audio_enc->thread_count = thread_count;
3353 /* For audio codecs other than AC3 or DTS we limit */
3354 /* the number of coded channels to stereo */
3355 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3356 && codec_id != CODEC_ID_DTS) {
3357 audio_enc->channels = 2;
3359 audio_enc->channels = audio_channels;
3361 audio_enc->sample_rate = audio_sample_rate;
3364 oc->nb_streams = nb_streams;
3367 fprintf(stderr, "No audio or video streams available\n");
3371 oc->timestamp = rec_timestamp;
3374 pstrcpy(oc->title, sizeof(oc->title), str_title);
3376 pstrcpy(oc->author, sizeof(oc->author), str_author);
3378 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3380 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3383 output_files[nb_output_files++] = oc;
3385 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3387 /* check filename in case of an image number is expected */
3388 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3389 if (filename_number_test(oc->filename) < 0) {
3390 print_error(oc->filename, AVERROR_NUMEXPECTED);
3395 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3396 /* test if it already exists to avoid loosing precious files */
3397 if (!file_overwrite &&
3398 (strchr(filename, ':') == NULL ||
3399 strstart(filename, "file:", NULL))) {
3400 if (url_exist(filename)) {
3403 if ( !using_stdin ) {
3404 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3407 if (toupper(c) != 'Y') {
3408 fprintf(stderr, "Not overwriting - exiting\n");
3413 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3420 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3421 fprintf(stderr, "Could not open '%s'\n", filename);
3426 memset(ap, 0, sizeof(*ap));
3427 ap->image_format = image_format;
3428 if (av_set_parameters(oc, ap) < 0) {
3429 fprintf(stderr, "%s: Invalid encoding parameters\n",
3434 oc->packet_size= mux_packet_size;
3435 oc->mux_rate= mux_rate;
3436 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3437 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3439 /* reset some options */
3440 file_oformat = NULL;
3441 file_iformat = NULL;
3442 image_format = NULL;
3445 audio_codec_id = CODEC_ID_NONE;
3446 video_codec_id = CODEC_ID_NONE;
3447 audio_stream_copy = 0;
3448 video_stream_copy = 0;
3451 /* prepare dummy protocols for grab */
3452 static void prepare_grab(void)
3454 int has_video, has_audio, i, j;
3455 AVFormatContext *oc;
3456 AVFormatContext *ic;
3457 AVFormatParameters vp1, *vp = &vp1;
3458 AVFormatParameters ap1, *ap = &ap1;
3460 /* see if audio/video inputs are needed */
3463 memset(ap, 0, sizeof(*ap));
3464 memset(vp, 0, sizeof(*vp));
3465 vp->frame_rate_base= 1;
3466 for(j=0;j<nb_output_files;j++) {
3467 oc = output_files[j];
3468 for(i=0;i<oc->nb_streams;i++) {
3469 AVCodecContext *enc = &oc->streams[i]->codec;
3470 switch(enc->codec_type) {
3471 case CODEC_TYPE_AUDIO:
3472 if (enc->sample_rate > ap->sample_rate)
3473 ap->sample_rate = enc->sample_rate;
3474 if (enc->channels > ap->channels)
3475 ap->channels = enc->channels;
3478 case CODEC_TYPE_VIDEO:
3479 if (enc->width > vp->width)
3480 vp->width = enc->width;
3481 if (enc->height > vp->height)
3482 vp->height = enc->height;
3484 if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3485 vp->frame_rate = enc->frame_rate;
3486 vp->frame_rate_base = enc->frame_rate_base;
3496 if (has_video == 0 && has_audio == 0) {
3497 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3502 AVInputFormat *fmt1;
3503 fmt1 = av_find_input_format(video_grab_format);
3504 vp->device = video_device;
3505 vp->channel = video_channel;
3506 vp->standard = video_standard;
3507 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3508 fprintf(stderr, "Could not find video grab device\n");
3511 /* If not enough info to get the stream parameters, we decode the
3512 first frames to get it. */
3513 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3514 fprintf(stderr, "Could not find video grab parameters\n");
3517 /* by now video grab has one stream */
3518 ic->streams[0]->r_frame_rate = vp->frame_rate;
3519 ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3520 input_files[nb_input_files] = ic;
3523 dump_format(ic, nb_input_files, "", 0);
3527 if (has_audio && audio_grab_format) {
3528 AVInputFormat *fmt1;
3529 fmt1 = av_find_input_format(audio_grab_format);
3530 ap->device = audio_device;
3531 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3532 fprintf(stderr, "Could not find audio grab device\n");
3535 input_files[nb_input_files] = ic;
3538 dump_format(ic, nb_input_files, "", 0);
3544 /* same option as mencoder */
3545 static void opt_pass(const char *pass_str)
3548 pass = atoi(pass_str);
3549 if (pass != 1 && pass != 2) {
3550 fprintf(stderr, "pass number can be only 1 or 2\n");
3556 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3557 static int64_t getutime(void)
3559 return av_gettime();
3562 static int64_t getutime(void)
3564 struct rusage rusage;
3566 getrusage(RUSAGE_SELF, &rusage);
3567 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3571 extern int ffm_nopts;
3573 static void opt_bitexact(void)
3576 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3580 static void show_formats(void)
3582 AVInputFormat *ifmt;
3583 AVOutputFormat *ofmt;
3584 AVImageFormat *image_fmt;
3587 const char **pp, *last_name;
3589 printf("File formats:\n");
3594 const char *name=NULL;
3595 const char *long_name=NULL;
3597 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3598 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3599 strcmp(ofmt->name, last_name)>0){
3601 long_name= ofmt->long_name;
3605 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3606 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3607 strcmp(ifmt->name, last_name)>0){
3609 long_name= ifmt->long_name;
3612 if(name && strcmp(ifmt->name, name)==0)
3624 long_name ? long_name:" ");
3628 printf("Image formats (filename extensions, if any, follow):\n");
3629 for(image_fmt = first_image_format; image_fmt != NULL;
3630 image_fmt = image_fmt->next) {
3633 image_fmt->img_read ? "D":" ",
3634 image_fmt->img_write ? "E":" ",
3636 image_fmt->extensions ? image_fmt->extensions:" ");
3640 printf("Codecs:\n");
3648 for(p = first_avcodec; p != NULL; p = p->next) {
3649 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3650 strcmp(p->name, last_name)>0){
3652 decode= encode= cap=0;
3654 if(p2 && strcmp(p->name, p2->name)==0){
3655 if(p->decode) decode=1;
3656 if(p->encode) encode=1;
3657 cap |= p->capabilities;
3662 last_name= p2->name;
3666 decode ? "D": (/*p2->decoder ? "d":*/" "),
3668 p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3669 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3670 cap & CODEC_CAP_DR1 ? "D":" ",
3671 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3673 /* if(p2->decoder && decode==0)
3674 printf(" use %s for decoding", p2->decoder->name);*/
3679 printf("Supported file protocols:\n");
3680 for(up = first_protocol; up != NULL; up = up->next)
3681 printf(" %s:", up->name);
3684 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3685 printf("Motion estimation methods:\n");
3689 if ((pp - motion_str + 1) == ME_ZERO)
3690 printf("(fastest)");
3691 else if ((pp - motion_str + 1) == ME_FULL)
3692 printf("(slowest)");
3693 else if ((pp - motion_str + 1) == ME_EPZS)
3694 printf("(default)");
3699 "Note, the names of encoders and decoders dont always match, so there are\n"
3700 "several cases where the above table shows encoder only or decoder only entries\n"
3701 "even though both encoding and decoding are supported for example, the h263\n"
3702 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3707 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3710 const char *p = str;
3717 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3724 void opt_inter_matrix(const char *arg)
3726 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3727 parse_matrix_coeffs(inter_matrix, arg);
3730 void opt_intra_matrix(const char *arg)
3732 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3733 parse_matrix_coeffs(intra_matrix, arg);
3736 static void opt_target(const char *arg)
3739 static const char const *frame_rates[] = {"25", "30000/1001", "24000/1001"};
3741 if(!strncmp(arg, "pal-", 4)) {
3744 } else if(!strncmp(arg, "ntsc-", 5)) {
3747 } else if(!strncmp(arg, "film-", 5)) {
3752 /* Calculate FR via float to avoid int overflow */
3753 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3756 } else if((fr == 29970) || (fr == 23976)) {
3759 /* Try to determine PAL/NTSC by peeking in the input files */
3760 if(nb_input_files) {
3762 for(j = 0; j < nb_input_files; j++) {
3763 for(i = 0; i < input_files[j]->nb_streams; i++) {
3764 AVCodecContext *c = &input_files[j]->streams[i]->codec;
3765 if(c->codec_type != CODEC_TYPE_VIDEO)
3767 fr = c->frame_rate * 1000 / c->frame_rate_base;
3771 } else if((fr == 29970) || (fr == 23976)) {
3781 if(verbose && norm >= 0)
3782 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3786 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3787 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3788 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3792 if(!strcmp(arg, "vcd")) {
3794 opt_video_codec("mpeg1video");
3795 opt_audio_codec("mp2");
3798 opt_frame_size(norm ? "352x240" : "352x288");
3799 opt_frame_rate(frame_rates[norm]);
3800 opt_gop_size(norm ? "18" : "15");
3802 video_bit_rate = 1150000;
3803 video_rc_max_rate = 1150000;
3804 video_rc_min_rate = 1150000;
3805 video_rc_buffer_size = 40*1024*8;
3807 audio_bit_rate = 224000;
3808 audio_sample_rate = 44100;
3810 mux_packet_size= 2324;
3811 mux_rate= 2352 * 75 * 8;
3813 /* We have to offset the PTS, so that it is consistent with the SCR.
3814 SCR starts at 36000, but the first two packs contain only padding
3815 and the first pack from the other stream, respectively, may also have
3816 been written before.
3817 So the real data starts at SCR 36000+3*1200. */
3818 mux_preload= (36000+3*1200) / 90000.0; //0.44
3819 } else if(!strcmp(arg, "svcd")) {
3821 opt_video_codec("mpeg2video");
3822 opt_audio_codec("mp2");
3825 opt_frame_size(norm ? "480x480" : "480x576");
3826 opt_frame_rate(frame_rates[norm]);
3827 opt_gop_size(norm ? "18" : "15");
3829 video_bit_rate = 2040000;
3830 video_rc_max_rate = 2516000;
3831 video_rc_min_rate = 0; //1145000;
3832 video_rc_buffer_size = 224*1024*8;
3833 use_scan_offset = 1;
3835 audio_bit_rate = 224000;
3836 audio_sample_rate = 44100;
3838 mux_packet_size= 2324;
3840 } else if(!strcmp(arg, "dvd")) {
3842 opt_video_codec("mpeg2video");
3843 opt_audio_codec("ac3");
3846 opt_frame_size(norm ? "720x480" : "720x576");
3847 opt_frame_rate(frame_rates[norm]);
3848 opt_gop_size(norm ? "18" : "15");
3850 video_bit_rate = 6000000;
3851 video_rc_max_rate = 9000000;
3852 video_rc_min_rate = 0; //1500000;
3853 video_rc_buffer_size = 224*1024*8;
3855 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3856 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3858 audio_bit_rate = 448000;
3859 audio_sample_rate = 48000;
3861 } else if(!strcmp(arg, "dv")) {
3865 opt_frame_size(norm ? "720x480" : "720x576");
3866 opt_frame_rate(frame_rates[norm]);
3868 audio_sample_rate = 48000;
3872 fprintf(stderr, "Unknown target: %s\n", arg);
3877 static void show_version(void)
3879 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3882 avcodec_build(), LIBAVFORMAT_BUILD);
3886 const OptionDef options[] = {
3888 { "L", 0, {(void*)show_license}, "show license" },
3889 { "h", 0, {(void*)show_help}, "show help" },
3890 { "version", 0, {(void*)show_version}, "show version" },
3891 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3892 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3893 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3894 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3895 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3896 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3897 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3898 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3899 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3900 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3901 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3902 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3903 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3904 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3905 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3906 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3907 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3908 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3909 "add timings for benchmarking" },
3910 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3911 "dump each input packet" },
3912 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3913 "when dumping packets, also dump the payload" },
3914 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3915 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3916 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3917 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3918 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3919 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3920 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3921 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3922 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3925 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3926 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3927 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3928 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3929 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3930 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3931 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3932 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3933 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3934 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3935 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3936 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3937 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3938 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3939 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3940 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3941 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3942 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3943 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3944 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3945 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3946 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3947 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3948 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3949 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3950 { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3951 { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3952 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3953 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3954 { "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" },
3955 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3956 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3957 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3958 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3959 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3960 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3961 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3962 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3963 // { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3964 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3965 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3966 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3967 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3968 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3969 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3970 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3971 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3973 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
3974 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
3975 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3976 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
3977 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
3978 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
3979 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3980 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3981 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3982 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3983 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3984 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3985 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3986 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3987 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3988 { "lelim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lelim}, "single coefficient elimination threshold for luminance (negative values also consider DC coefficient)", "elim" },
3989 { "celim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_celim}, "single coefficient elimination threshold for chrominance (negative values also consider DC coefficient)", "elim" },
3990 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3991 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3992 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3993 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
3994 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3995 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3996 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3997 { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3998 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3999 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4000 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4001 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4002 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4003 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4004 "use same video quality as source (implies VBR)" },
4005 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4006 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4007 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4008 "deinterlace pictures" },
4009 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
4010 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
4011 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
4012 "force interlaced me support in encoder (MPEG2/MPEG4)" },
4013 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4014 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4015 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4016 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
4017 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
4018 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
4019 { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
4020 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
4021 { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
4022 { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
4023 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
4024 { "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)" },
4025 { "naq", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_normalize_aqp}, "normalize adaptive quantization" },
4026 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
4027 { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
4028 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
4029 { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
4030 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4031 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4032 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4033 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
4034 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
4035 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4036 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4037 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4038 { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
4039 { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
4040 { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
4041 { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
4042 { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
4043 { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
4044 { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
4045 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
4046 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4047 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4048 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4049 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4050 { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
4053 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4054 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4055 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4056 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4057 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4058 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4061 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4062 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4063 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4064 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4066 /* G.2 grab options */
4067 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4068 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4071 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4072 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4073 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4074 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4078 static void show_banner(void)
4080 fprintf(stderr, "ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4082 fprintf(stderr, " configuration: %s\n", FFMPEG_CONFIGURATION);
4083 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4085 fprintf(stderr, ", gcc: %s\n", __VERSION__);
4087 fprintf(stderr, ", using a non-gcc compiler\n");
4091 static void show_license(void)
4096 "This program is free software; you can redistribute it and/or modify\n"
4097 "it under the terms of the GNU General Public License as published by\n"
4098 "the Free Software Foundation; either version 2 of the License, or\n"
4099 "(at your option) any later version.\n"
4101 "This program is distributed in the hope that it will be useful,\n"
4102 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4103 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4104 "GNU General Public License for more details.\n"
4106 "You should have received a copy of the GNU General Public License\n"
4107 "along with this program; if not, write to the Free Software\n"
4108 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4112 "This library is free software; you can redistribute it and/or\n"
4113 "modify it under the terms of the GNU Lesser General Public\n"
4114 "License as published by the Free Software Foundation; either\n"
4115 "version 2 of the License, or (at your option) any later version.\n"
4117 "This library is distributed in the hope that it will be useful,\n"
4118 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4119 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4120 "Lesser General Public License for more details.\n"
4122 "You should have received a copy of the GNU Lesser General Public\n"
4123 "License along with this library; if not, write to the Free Software\n"
4124 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4130 static void show_help(void)
4133 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4134 "Hyper fast Audio and Video encoder\n");
4136 show_help_options(options, "Main options:\n",
4137 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4138 show_help_options(options, "\nVideo options:\n",
4139 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4141 show_help_options(options, "\nAdvanced Video options:\n",
4142 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4143 OPT_VIDEO | OPT_EXPERT);
4144 show_help_options(options, "\nAudio options:\n",
4145 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4147 show_help_options(options, "\nAdvanced Audio options:\n",
4148 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4149 OPT_AUDIO | OPT_EXPERT);
4150 show_help_options(options, "\nAudio/Video grab options:\n",
4153 show_help_options(options, "\nAdvanced options:\n",
4154 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4159 void parse_arg_file(const char *filename)
4161 opt_output_file(filename);
4164 int main(int argc, char **argv)
4177 parse_options(argc, argv, options);
4179 /* file converter / grab */
4180 if (nb_output_files <= 0) {
4181 fprintf(stderr, "Must supply at least one output file\n");
4185 if (nb_input_files == 0) {
4191 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4192 stream_maps, nb_stream_maps);
4193 ti = getutime() - ti;
4195 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4199 for(i=0;i<nb_output_files;i++) {
4200 /* maybe av_close_output_file ??? */
4201 AVFormatContext *s = output_files[i];
4203 if (!(s->oformat->flags & AVFMT_NOFILE))
4205 for(j=0;j<s->nb_streams;j++)
4206 av_free(s->streams[j]);
4209 for(i=0;i<nb_input_files;i++)
4210 av_close_input_file(input_files[i]);
4215 av_free(intra_matrix);
4217 av_free(inter_matrix);
4219 #ifdef POWERPC_PERFORMANCE_REPORT
4220 extern void powerpc_display_perf_report(void);
4221 powerpc_display_perf_report();
4222 #endif /* POWERPC_PERFORMANCE_REPORT */
4224 #ifndef CONFIG_WIN32
4225 if (received_sigterm) {
4227 "Received signal %d: terminating.\n",
4228 (int) received_sigterm);
4232 exit(0); /* not all OS-es handle main() return value */