3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This library is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2 of the License, or (at your option) any later version.
10 * This library is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this library; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 #define HAVE_AV_CONFIG_H
22 #include "framehook.h"
28 #include <sys/ioctl.h>
31 #include <sys/resource.h>
35 #include <sys/types.h>
36 #include <sys/select.h>
39 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
47 #if !defined(INFINITY) && defined(HUGE_VAL)
48 #define INFINITY HUGE_VAL
51 /* select an input stream for an output stream */
52 typedef struct AVStreamMap {
57 /** select an input file for an output file */
58 typedef struct AVMetaDataMap {
63 extern const OptionDef options[];
65 static void show_help(void);
66 static void show_license(void);
70 static AVFormatContext *input_files[MAX_FILES];
71 static int64_t input_files_ts_offset[MAX_FILES];
72 static int nb_input_files = 0;
74 static AVFormatContext *output_files[MAX_FILES];
75 static int nb_output_files = 0;
77 static AVStreamMap stream_maps[MAX_FILES];
78 static int nb_stream_maps;
80 static AVMetaDataMap meta_data_maps[MAX_FILES];
81 static int nb_meta_data_maps;
83 static AVInputFormat *file_iformat;
84 static AVOutputFormat *file_oformat;
85 static AVImageFormat *image_format;
86 static int frame_width = 160;
87 static int frame_height = 128;
88 static float frame_aspect_ratio = 0;
89 static enum PixelFormat frame_pix_fmt = PIX_FMT_YUV420P;
90 static int frame_padtop = 0;
91 static int frame_padbottom = 0;
92 static int frame_padleft = 0;
93 static int frame_padright = 0;
94 static int padcolor[3] = {16,128,128}; /* default to black */
95 static int frame_topBand = 0;
96 static int frame_bottomBand = 0;
97 static int frame_leftBand = 0;
98 static int frame_rightBand = 0;
99 static int frame_rate = 25;
100 static int frame_rate_base = 1;
101 static int video_bit_rate = 200*1000;
102 static int video_bit_rate_tolerance = 4000*1000;
103 static float video_qscale = 0;
104 static int video_qmin = 2;
105 static int video_qmax = 31;
106 static int video_lmin = 2*FF_QP2LAMBDA;
107 static int video_lmax = 31*FF_QP2LAMBDA;
108 static int video_mb_qmin = 2;
109 static int video_mb_qmax = 31;
110 static int video_qdiff = 3;
111 static float video_qblur = 0.5;
112 static float video_qcomp = 0.5;
113 static uint16_t *intra_matrix = NULL;
114 static uint16_t *inter_matrix = NULL;
115 #if 0 //experimental, (can be removed)
116 static float video_rc_qsquish=1.0;
117 static float video_rc_qmod_amp=0;
118 static int video_rc_qmod_freq=0;
120 static char *video_rc_override_string=NULL;
121 static char *video_rc_eq="tex^qComp";
122 static int video_rc_buffer_size=0;
123 static float video_rc_buffer_aggressivity=1.0;
124 static int video_rc_max_rate=0;
125 static int video_rc_min_rate=0;
126 static float video_rc_initial_cplx=0;
127 static float video_b_qfactor = 1.25;
128 static float video_b_qoffset = 1.25;
129 static float video_i_qfactor = -0.8;
130 static float video_i_qoffset = 0.0;
131 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
132 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
133 static int me_method = ME_EPZS;
134 static int video_disable = 0;
135 static int video_codec_id = CODEC_ID_NONE;
136 static int video_codec_tag = 0;
137 static int same_quality = 0;
138 static int b_frames = 0;
139 static int mb_decision = FF_MB_DECISION_SIMPLE;
140 static int ildct_cmp = FF_CMP_VSAD;
141 static int mb_cmp = FF_CMP_SAD;
142 static int sub_cmp = FF_CMP_SAD;
143 static int cmp = FF_CMP_SAD;
144 static int pre_cmp = FF_CMP_SAD;
145 static int pre_me = 0;
146 static float lumi_mask = 0;
147 static float dark_mask = 0;
148 static float scplx_mask = 0;
149 static float tcplx_mask = 0;
150 static float p_mask = 0;
151 static int use_4mv = 0;
152 static int use_obmc = 0;
153 static int use_loop = 0;
154 static int use_aic = 0;
155 static int use_aiv = 0;
156 static int use_umv = 0;
157 static int use_ss = 0;
158 static int use_alt_scan = 0;
159 static int use_trell = 0;
160 static int use_scan_offset = 0;
161 static int use_qpel = 0;
162 static int use_qprd = 0;
163 static int use_cbprd = 0;
165 static int closed_gop = 0;
166 static int strict_gop = 0;
167 static int do_deinterlace = 0;
168 static int do_interlace_dct = 0;
169 static int do_interlace_me = 0;
170 static int workaround_bugs = FF_BUG_AUTODETECT;
171 static int error_resilience = 2;
172 static int error_concealment = 3;
173 static int dct_algo = 0;
174 static int idct_algo = 0;
175 static int use_part = 0;
176 static int packet_size = 0;
177 static int error_rate = 0;
178 static int strict = 0;
179 static int top_field_first = -1;
180 static int noise_reduction = 0;
181 static int sc_threshold = 0;
182 static int debug = 0;
183 static int debug_mv = 0;
184 static int me_threshold = 0;
185 static int mb_threshold = 0;
186 static int intra_dc_precision = 8;
187 static int coder = 0;
188 static int context = 0;
189 static int predictor = 0;
190 static int video_profile = FF_PROFILE_UNKNOWN;
191 static int video_level = FF_LEVEL_UNKNOWN;
192 static int nsse_weight = 8;
193 static int subpel_quality= 8;
194 static int lowres= 0;
195 extern int loop_input; /* currently a hack */
197 static int gop_size = 12;
198 static int intra_only = 0;
199 static int audio_sample_rate = 44100;
200 static int audio_bit_rate = 64000;
201 static int audio_disable = 0;
202 static int audio_channels = 1;
203 static int audio_codec_id = CODEC_ID_NONE;
204 static int audio_codec_tag = 0;
206 static int mux_rate= 0;
207 static int mux_packet_size= 0;
208 static float mux_preload= 0.5;
209 static float mux_max_delay= 0.7;
211 static int64_t recording_time = 0;
212 static int64_t start_time = 0;
213 static int64_t rec_timestamp = 0;
214 static int64_t input_ts_offset = 0;
215 static int file_overwrite = 0;
216 static char *str_title = NULL;
217 static char *str_author = NULL;
218 static char *str_copyright = NULL;
219 static char *str_comment = NULL;
220 static int do_benchmark = 0;
221 static int do_hex_dump = 0;
222 static int do_pkt_dump = 0;
223 static int do_psnr = 0;
224 static int do_vstats = 0;
225 static int do_pass = 0;
226 static int bitexact = 0;
227 static char *pass_logfilename = NULL;
228 static int audio_stream_copy = 0;
229 static int video_stream_copy = 0;
230 static int video_sync_method= 1;
231 static int audio_sync_method= 0;
232 static int copy_ts= 0;
234 static int rate_emu = 0;
236 static char *video_grab_format = "video4linux";
237 static char *video_device = NULL;
238 static char *grab_device = NULL;
239 static int video_channel = 0;
240 static char *video_standard = "ntsc";
242 static char *audio_grab_format = "audio_device";
243 static char *audio_device = NULL;
245 static int using_stdin = 0;
246 static int using_vhook = 0;
247 static int verbose = 1;
248 static int thread_count= 1;
249 static int q_pressed = 0;
250 static int me_range = 0;
251 static int64_t video_size = 0;
252 static int64_t audio_size = 0;
253 static int64_t extra_size = 0;
254 static int nb_frames_dup = 0;
255 static int nb_frames_drop = 0;
256 static int input_sync;
258 static int pgmyuv_compatibility_hack=0;
261 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
263 typedef struct AVOutputStream {
264 int file_index; /* file index */
265 int index; /* stream index in the output file */
266 int source_index; /* AVInputStream index */
267 AVStream *st; /* stream in the output file */
268 int encoding_needed; /* true if encoding needed for this stream */
270 /* input pts and corresponding output pts
272 double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
273 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
275 int video_resample; /* video_resample and video_crop are mutually exclusive */
276 AVFrame pict_tmp; /* temporary image for resampling */
277 ImgReSampleContext *img_resample_ctx; /* for image resampling */
279 int video_crop; /* video_resample and video_crop are mutually exclusive */
280 int topBand; /* cropping area sizes */
283 int video_pad; /* video_resample and video_pad are mutually exclusive */
284 int padtop; /* padding area sizes */
291 ReSampleContext *resample; /* for audio resampling */
292 FifoBuffer fifo; /* for compression: one audio fifo per codec */
296 typedef struct AVInputStream {
300 int discard; /* true if stream data should be discarded */
301 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
302 int64_t sample_index; /* current sample */
304 int64_t start; /* time when read started */
305 unsigned long frame; /* current frame */
306 int64_t next_pts; /* synthetic pts for cases where pkt.pts
308 int64_t pts; /* current pts */
309 int is_start; /* is 1 at the start and after a discontinuity */
312 typedef struct AVInputFile {
313 int eof_reached; /* true if eof reached */
314 int ist_index; /* index of first stream in ist_table */
315 int buffer_size; /* current total buffer size */
316 int buffer_size_max; /* buffer size at which we consider we can stop
318 int nb_streams; /* nb streams we are aware of */
323 /* init terminal so that we can grab keys */
324 static struct termios oldtty;
326 static void term_exit(void)
328 tcsetattr (0, TCSANOW, &oldtty);
331 static volatile sig_atomic_t received_sigterm = 0;
334 sigterm_handler(int sig)
336 received_sigterm = sig;
340 static void term_init(void)
347 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
348 |INLCR|IGNCR|ICRNL|IXON);
349 tty.c_oflag |= OPOST;
350 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
351 tty.c_cflag &= ~(CSIZE|PARENB);
356 tcsetattr (0, TCSANOW, &tty);
358 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
359 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
360 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
362 register a function to be called at normal program termination
365 #ifdef CONFIG_BEOS_NETSERVER
366 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
370 /* read a key without blocking */
371 static int read_key(void)
375 #ifndef CONFIG_BEOS_NETSERVER
383 n = select(1, &rfds, NULL, NULL, &tv);
395 static int decode_interrupt_cb(void)
397 return q_pressed || (q_pressed = read_key() == 'q');
402 static volatile int received_sigterm = 0;
404 /* no interactive support */
405 static void term_exit(void)
409 static void term_init(void)
413 static int read_key(void)
420 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
425 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
428 /* copy stream format */
429 s->nb_streams = ic->nb_streams;
430 for(i=0;i<ic->nb_streams;i++) {
433 st = av_mallocz(sizeof(AVStream));
434 memcpy(st, ic->streams[i], sizeof(AVStream));
438 av_close_input_file(ic);
442 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
444 static void do_audio_out(AVFormatContext *s,
447 unsigned char *buf, int size)
450 static uint8_t *audio_buf = NULL;
451 static uint8_t *audio_out = NULL;
452 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
454 int size_out, frame_bytes, ret;
455 AVCodecContext *enc= &ost->st->codec;
457 /* SC: dynamic allocation of buffers */
459 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
461 audio_out = av_malloc(audio_out_size);
462 if (!audio_buf || !audio_out)
463 return; /* Should signal an error ! */
465 if(audio_sync_method){
466 double delta = ost->sync_ipts * enc->sample_rate - ost->sync_opts
467 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
468 double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
469 int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
471 //FIXME resample delay
472 if(fabs(delta) > 50){
475 byte_delta= FFMAX(byte_delta, -size);
479 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
484 static uint8_t *input_tmp= NULL;
485 input_tmp= av_realloc(input_tmp, byte_delta + size);
487 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
490 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
492 memset(input_tmp, 0, byte_delta);
493 memcpy(input_tmp + byte_delta, buf, size);
497 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
499 }else if(audio_sync_method>1){
500 int comp= clip(delta, -audio_sync_method, audio_sync_method);
501 assert(ost->audio_resample);
503 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
504 // 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));
505 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
509 ost->sync_opts= lrintf(ost->sync_ipts * enc->sample_rate)
510 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
512 if (ost->audio_resample) {
514 size_out = audio_resample(ost->resample,
515 (short *)buftmp, (short *)buf,
516 size / (ist->st->codec.channels * 2));
517 size_out = size_out * enc->channels * 2;
523 /* now encode as many frames as possible */
524 if (enc->frame_size > 1) {
525 /* output resampled raw samples */
526 fifo_write(&ost->fifo, buftmp, size_out,
529 frame_bytes = enc->frame_size * 2 * enc->channels;
531 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
532 &ost->fifo.rptr) == 0) {
534 av_init_packet(&pkt);
536 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
539 pkt.stream_index= ost->index;
543 pkt.pts= enc->coded_frame->pts;
544 pkt.flags |= PKT_FLAG_KEY;
545 av_interleaved_write_frame(s, &pkt);
547 ost->sync_opts += enc->frame_size;
551 av_init_packet(&pkt);
553 ost->sync_opts += size_out / (2 * enc->channels);
555 /* output a pcm frame */
556 /* XXX: change encoding codec API to avoid this ? */
557 switch(enc->codec->id) {
558 case CODEC_ID_PCM_S16LE:
559 case CODEC_ID_PCM_S16BE:
560 case CODEC_ID_PCM_U16LE:
561 case CODEC_ID_PCM_U16BE:
564 size_out = size_out >> 1;
567 ret = avcodec_encode_audio(enc, audio_out, size_out,
570 pkt.stream_index= ost->index;
574 pkt.pts= enc->coded_frame->pts;
575 pkt.flags |= PKT_FLAG_KEY;
576 av_interleaved_write_frame(s, &pkt);
580 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
584 AVPicture picture_tmp;
587 dec = &ist->st->codec;
589 /* deinterlace : must be done before any resize */
590 if (do_deinterlace || using_vhook) {
593 /* create temporary picture */
594 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
595 buf = av_malloc(size);
599 picture2 = &picture_tmp;
600 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
603 if(avpicture_deinterlace(picture2, picture,
604 dec->pix_fmt, dec->width, dec->height) < 0) {
605 /* if error, do not deinterlace */
611 if (img_convert(picture2, dec->pix_fmt, picture,
612 dec->pix_fmt, dec->width, dec->height) < 0) {
613 /* if error, do not copy */
623 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
625 if (picture != picture2)
626 *picture = *picture2;
630 /* we begin to correct av delay at this threshold */
631 #define AV_DELAY_MAX 0.100
634 /* Expects img to be yuv420 */
635 static void fill_pad_region(AVPicture* img, int height, int width,
636 int padtop, int padbottom, int padleft, int padright, int *color) {
641 for (i = 0; i < 3; i++) {
642 shift = (i == 0) ? 0 : 1;
644 if (padtop || padleft) {
645 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
649 if (padleft || padright) {
650 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
651 (img->linesize[i] - (padright >> shift));
653 for (y = 0; y < ((height - (padtop + padbottom)) >> shift); y++) {
654 memset(optr, color[i], (padleft + padright) >> shift);
655 optr += img->linesize[i];
660 optr = img->data[i] + (img->linesize[i] * ((height - padbottom) >> shift));
661 memset(optr, color[i], ((img->linesize[i] * padbottom) >> shift));
666 static uint8_t *bit_buffer= NULL;
668 static void do_video_out(AVFormatContext *s,
674 int nb_frames, i, ret;
675 AVFrame *final_picture, *formatted_picture;
676 AVFrame picture_format_temp, picture_crop_temp;
677 uint8_t *buf = NULL, *buf1 = NULL;
678 AVCodecContext *enc, *dec;
679 enum PixelFormat target_pixfmt;
681 #define VIDEO_BUFFER_SIZE (1024*1024)
683 avcodec_get_frame_defaults(&picture_format_temp);
684 avcodec_get_frame_defaults(&picture_crop_temp);
686 enc = &ost->st->codec;
687 dec = &ist->st->codec;
689 /* by default, we output a single frame */
694 if(video_sync_method){
696 vdelta = ost->sync_ipts * enc->frame_rate / enc->frame_rate_base - ost->sync_opts;
697 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
700 else if (vdelta > 1.1)
701 nb_frames = lrintf(vdelta);
702 //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);
706 fprintf(stderr, "*** drop!\n");
707 }else if (nb_frames > 1) {
708 nb_frames_dup += nb_frames;
710 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
713 ost->sync_opts= lrintf(ost->sync_ipts * enc->frame_rate / enc->frame_rate_base);
718 /* convert pixel format if needed */
719 target_pixfmt = ost->video_resample || ost->video_pad
720 ? PIX_FMT_YUV420P : enc->pix_fmt;
721 if (dec->pix_fmt != target_pixfmt) {
724 /* create temporary picture */
725 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
726 buf = av_malloc(size);
729 formatted_picture = &picture_format_temp;
730 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
732 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
733 (AVPicture *)in_picture, dec->pix_fmt,
734 dec->width, dec->height) < 0) {
737 fprintf(stderr, "pixel format conversion not handled\n");
742 formatted_picture = in_picture;
745 /* XXX: resampling could be done before raw format conversion in
746 some cases to go faster */
747 /* XXX: only works for YUV420P */
748 if (ost->video_resample) {
749 final_picture = &ost->pict_tmp;
750 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
752 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
753 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
754 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
758 if (enc->pix_fmt != PIX_FMT_YUV420P) {
762 /* create temporary picture */
763 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
764 buf = av_malloc(size);
767 final_picture = &picture_format_temp;
768 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
770 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
771 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
772 enc->width, enc->height) < 0) {
775 fprintf(stderr, "pixel format conversion not handled\n");
780 } else if (ost->video_crop) {
781 picture_crop_temp.data[0] = formatted_picture->data[0] +
782 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
784 picture_crop_temp.data[1] = formatted_picture->data[1] +
785 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
786 (ost->leftBand >> 1);
788 picture_crop_temp.data[2] = formatted_picture->data[2] +
789 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
790 (ost->leftBand >> 1);
792 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
793 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
794 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
795 final_picture = &picture_crop_temp;
796 } else if (ost->video_pad) {
797 final_picture = &ost->pict_tmp;
799 for (i = 0; i < 3; i++) {
800 uint8_t *optr, *iptr;
801 int shift = (i == 0) ? 0 : 1;
804 /* set offset to start writing image into */
805 optr = final_picture->data[i] + (((final_picture->linesize[i] *
806 ost->padtop) + ost->padleft) >> shift);
807 iptr = formatted_picture->data[i];
809 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
810 for (y = 0; y < yheight; y++) {
811 /* copy unpadded image row into padded image row */
812 memcpy(optr, iptr, formatted_picture->linesize[i]);
813 optr += final_picture->linesize[i];
814 iptr += formatted_picture->linesize[i];
818 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
819 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
822 if (enc->pix_fmt != PIX_FMT_YUV420P) {
826 /* create temporary picture */
827 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
828 buf = av_malloc(size);
831 final_picture = &picture_format_temp;
832 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
834 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
835 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
836 enc->width, enc->height) < 0) {
839 fprintf(stderr, "pixel format conversion not handled\n");
845 final_picture = formatted_picture;
847 /* duplicates frame if needed */
848 for(i=0;i<nb_frames;i++) {
850 av_init_packet(&pkt);
851 pkt.stream_index= ost->index;
853 if (s->oformat->flags & AVFMT_RAWPICTURE) {
854 /* raw pictures are written as AVPicture structure to
855 avoid any copies. We support temorarily the older
857 AVFrame* old_frame = enc->coded_frame;
858 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
859 pkt.data= (uint8_t *)final_picture;
860 pkt.size= sizeof(AVPicture);
862 pkt.pts= dec->coded_frame->pts;
863 if(dec->coded_frame && dec->coded_frame->key_frame)
864 pkt.flags |= PKT_FLAG_KEY;
866 av_interleaved_write_frame(s, &pkt);
867 enc->coded_frame = old_frame;
871 big_picture= *final_picture;
872 /* better than nothing: use input picture interlaced
874 big_picture.interlaced_frame = in_picture->interlaced_frame;
875 if(do_interlace_me || do_interlace_dct){
876 if(top_field_first == -1)
877 big_picture.top_field_first = in_picture->top_field_first;
879 big_picture.top_field_first = top_field_first;
882 /* handles sameq here. This is not correct because it may
883 not be a global option */
885 big_picture.quality = ist->st->quality;
887 big_picture.quality = ost->st->quality;
889 big_picture.pict_type = 0;
890 // big_picture.pts = AV_NOPTS_VALUE;
891 big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->frame_rate_base, enc->frame_rate);
892 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
893 ret = avcodec_encode_video(enc,
894 bit_buffer, VIDEO_BUFFER_SIZE,
896 //enc->frame_number = enc->real_pict_num;
898 pkt.data= bit_buffer;
901 pkt.pts= enc->coded_frame->pts;
902 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
903 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1,
904 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->frame_rate, AV_TIME_BASE*(int64_t)enc->frame_rate_base) : -1);*/
906 if(enc->coded_frame && enc->coded_frame->key_frame)
907 pkt.flags |= PKT_FLAG_KEY;
908 av_interleaved_write_frame(s, &pkt);
910 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
911 // enc->frame_number-1, enc->real_pict_num, ret,
913 /* if two pass, output log */
914 if (ost->logfile && enc->stats_out) {
915 fprintf(ost->logfile, "%s", enc->stats_out);
927 static double psnr(double d){
928 if(d==0) return INFINITY;
929 return -10.0*log(d)/log(10.0);
932 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
935 static FILE *fvstats=NULL;
942 double ti1, bitrate, avg_bitrate;
946 today = localtime(&today2);
947 sprintf(filename, "vstats_%02d%02d%02d.log", today->tm_hour,
950 fvstats = fopen(filename,"w");
958 enc = &ost->st->codec;
959 if (enc->codec_type == CODEC_TYPE_VIDEO) {
960 frame_number = ost->frame_number;
961 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
962 if (enc->flags&CODEC_FLAG_PSNR)
963 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
965 fprintf(fvstats,"f_size= %6d ", frame_size);
966 /* compute pts value */
967 ti1 = (double)ost->sync_opts *enc->frame_rate_base / enc->frame_rate;
971 bitrate = (double)(frame_size * 8) * enc->frame_rate / enc->frame_rate_base / 1000.0;
972 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
973 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
974 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
975 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
979 static void print_report(AVFormatContext **output_files,
980 AVOutputStream **ost_table, int nb_ostreams,
985 AVFormatContext *oc, *os;
988 int frame_number, vid, i;
989 double bitrate, ti1, pts;
990 static int64_t last_time = -1;
992 if (!is_last_report) {
994 /* display the report every 0.5 seconds */
995 cur_time = av_gettime();
996 if (last_time == -1) {
997 last_time = cur_time;
1000 if ((cur_time - last_time) < 500000)
1002 last_time = cur_time;
1006 oc = output_files[0];
1008 total_size = url_ftell(&oc->pb);
1013 for(i=0;i<nb_ostreams;i++) {
1015 os = output_files[ost->file_index];
1016 enc = &ost->st->codec;
1017 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1018 sprintf(buf + strlen(buf), "q=%2.1f ",
1019 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1021 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1022 frame_number = ost->frame_number;
1023 sprintf(buf + strlen(buf), "frame=%5d q=%2.1f ",
1024 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1026 sprintf(buf + strlen(buf), "L");
1027 if (enc->flags&CODEC_FLAG_PSNR){
1029 double error, error_sum=0;
1030 double scale, scale_sum=0;
1031 char type[3]= {'Y','U','V'};
1032 sprintf(buf + strlen(buf), "PSNR=");
1035 error= enc->error[j];
1036 scale= enc->width*enc->height*255.0*255.0*frame_number;
1038 error= enc->coded_frame->error[j];
1039 scale= enc->width*enc->height*255.0*255.0;
1044 sprintf(buf + strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1046 sprintf(buf + strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1050 /* compute min output value */
1051 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1052 if ((pts < ti1) && (pts > 0))
1058 if (verbose || is_last_report) {
1059 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1061 sprintf(buf + strlen(buf),
1062 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1063 (double)total_size / 1024, ti1, bitrate);
1066 sprintf(buf + strlen(buf), " dup=%d drop=%d",
1067 nb_frames_dup, nb_frames_drop);
1070 fprintf(stderr, "%s \r", buf);
1075 if (is_last_report && verbose >= 0){
1076 int64_t raw= audio_size + video_size + extra_size;
1077 fprintf(stderr, "\n");
1078 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1082 100.0*(total_size - raw)/raw
1087 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1088 static int output_packet(AVInputStream *ist, int ist_index,
1089 AVOutputStream **ost_table, int nb_ostreams,
1090 const AVPacket *pkt)
1092 AVFormatContext *os;
1093 AVOutputStream *ost;
1097 int data_size, got_picture;
1099 void *buffer_to_free;
1100 static int samples_size= 0;
1101 static short *samples= NULL;
1104 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1105 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1106 ist->next_pts = ist->pts = pkt->dts;
1108 assert(ist->pts == ist->next_pts);
1122 /* decode the packet if needed */
1123 data_buf = NULL; /* fail safe */
1125 if (ist->decoding_needed) {
1126 switch(ist->st->codec.codec_type) {
1127 case CODEC_TYPE_AUDIO:{
1129 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1130 /* XXX: could avoid copy if PCM 16 bits with same
1131 endianness as CPU */
1132 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1138 /* Some bug in mpeg audio decoder gives */
1139 /* data_size < 0, it seems they are overflows */
1140 if (data_size <= 0) {
1141 /* no audio frame */
1144 data_buf = (uint8_t *)samples;
1145 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1146 (ist->st->codec.sample_rate * ist->st->codec.channels);
1148 case CODEC_TYPE_VIDEO:
1149 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1150 /* XXX: allocate picture correctly */
1151 avcodec_get_frame_defaults(&picture);
1153 ret = avcodec_decode_video(&ist->st->codec,
1154 &picture, &got_picture, ptr, len);
1155 ist->st->quality= picture.quality;
1159 /* no picture yet */
1160 goto discard_packet;
1162 if (ist->st->codec.frame_rate_base != 0) {
1163 ist->next_pts += ((int64_t)AV_TIME_BASE *
1164 ist->st->codec.frame_rate_base) /
1165 ist->st->codec.frame_rate;
1179 buffer_to_free = NULL;
1180 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1181 pre_process_video_frame(ist, (AVPicture *)&picture,
1185 /* frame rate emulation */
1186 if (ist->st->codec.rate_emu) {
1187 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.frame_rate_base, 1000000, ist->st->codec.frame_rate);
1188 int64_t now = av_gettime() - ist->start;
1196 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1197 is the one of the next displayed one */
1198 /* XXX: add mpeg4 too ? */
1199 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1200 if (ist->st->codec.pict_type != B_TYPE) {
1202 tmp = ist->last_ip_pts;
1203 ist->last_ip_pts = ist->frac_pts.val;
1204 ist->frac_pts.val = tmp;
1208 /* if output time reached then transcode raw format,
1209 encode packets and output them */
1210 if (start_time == 0 || ist->pts >= start_time)
1211 for(i=0;i<nb_ostreams;i++) {
1215 if (ost->source_index == ist_index) {
1216 os = output_files[ost->file_index];
1219 printf("%d: got pts=%0.3f %0.3f\n", i,
1220 (double)pkt->pts / AV_TIME_BASE,
1221 ((double)ist->pts / AV_TIME_BASE) -
1222 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1224 /* set the input output pts pairs */
1225 ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index])/ AV_TIME_BASE;
1227 if (ost->encoding_needed) {
1228 switch(ost->st->codec.codec_type) {
1229 case CODEC_TYPE_AUDIO:
1230 do_audio_out(os, ost, ist, data_buf, data_size);
1232 case CODEC_TYPE_VIDEO:
1233 do_video_out(os, ost, ist, &picture, &frame_size);
1234 video_size += frame_size;
1235 if (do_vstats && frame_size)
1236 do_video_stats(os, ost, frame_size);
1242 AVFrame avframe; //FIXME/XXX remove this
1244 av_init_packet(&opkt);
1246 /* no reencoding needed : output the packet directly */
1247 /* force the input stream PTS */
1249 avcodec_get_frame_defaults(&avframe);
1250 ost->st->codec.coded_frame= &avframe;
1251 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1253 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1254 audio_size += data_size;
1255 else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1256 video_size += data_size;
1260 opkt.stream_index= ost->index;
1261 opkt.data= data_buf;
1262 opkt.size= data_size;
1263 if(pkt->pts != AV_NOPTS_VALUE)
1264 opkt.pts= pkt->pts + input_files_ts_offset[ist->file_index];
1266 opkt.pts= AV_NOPTS_VALUE;
1267 opkt.dts= pkt->dts + input_files_ts_offset[ist->file_index];
1268 opkt.flags= pkt->flags;
1270 av_interleaved_write_frame(os, &opkt);
1271 ost->st->codec.frame_number++;
1272 ost->frame_number++;
1276 av_free(buffer_to_free);
1282 for(i=0;i<nb_ostreams;i++) {
1284 if (ost->source_index == ist_index) {
1285 AVCodecContext *enc= &ost->st->codec;
1286 os = output_files[ost->file_index];
1288 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1290 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1293 if (ost->encoding_needed) {
1296 av_init_packet(&pkt);
1297 pkt.stream_index= ost->index;
1299 switch(ost->st->codec.codec_type) {
1300 case CODEC_TYPE_AUDIO:
1301 ret = avcodec_encode_audio(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1303 pkt.flags |= PKT_FLAG_KEY;
1305 case CODEC_TYPE_VIDEO:
1306 ret = avcodec_encode_video(enc, bit_buffer, VIDEO_BUFFER_SIZE, NULL);
1308 if(enc->coded_frame && enc->coded_frame->key_frame)
1309 pkt.flags |= PKT_FLAG_KEY;
1310 if (ost->logfile && enc->stats_out) {
1311 fprintf(ost->logfile, "%s", enc->stats_out);
1320 pkt.data= bit_buffer;
1322 if(enc->coded_frame)
1323 pkt.pts= enc->coded_frame->pts;
1324 av_interleaved_write_frame(os, &pkt);
1338 * The following code is the main loop of the file converter
1340 static int av_encode(AVFormatContext **output_files,
1341 int nb_output_files,
1342 AVFormatContext **input_files,
1344 AVStreamMap *stream_maps, int nb_stream_maps)
1346 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1347 AVFormatContext *is, *os;
1348 AVCodecContext *codec, *icodec;
1349 AVOutputStream *ost, **ost_table = NULL;
1350 AVInputStream *ist, **ist_table = NULL;
1351 AVInputFile *file_table;
1352 AVFormatContext *stream_no_data;
1355 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1360 bit_buffer = av_malloc(VIDEO_BUFFER_SIZE);
1364 /* input stream init */
1366 for(i=0;i<nb_input_files;i++) {
1367 is = input_files[i];
1368 file_table[i].ist_index = j;
1369 file_table[i].nb_streams = is->nb_streams;
1370 j += is->nb_streams;
1374 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1378 for(i=0;i<nb_istreams;i++) {
1379 ist = av_mallocz(sizeof(AVInputStream));
1385 for(i=0;i<nb_input_files;i++) {
1386 is = input_files[i];
1387 for(k=0;k<is->nb_streams;k++) {
1388 ist = ist_table[j++];
1389 ist->st = is->streams[k];
1390 ist->file_index = i;
1392 ist->discard = 1; /* the stream is discarded by default
1395 if (ist->st->codec.rate_emu) {
1396 ist->start = av_gettime();
1402 /* output stream init */
1404 for(i=0;i<nb_output_files;i++) {
1405 os = output_files[i];
1406 nb_ostreams += os->nb_streams;
1408 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1409 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1413 /* Sanity check the mapping args -- do the input files & streams exist? */
1414 for(i=0;i<nb_stream_maps;i++) {
1415 int fi = stream_maps[i].file_index;
1416 int si = stream_maps[i].stream_index;
1418 if (fi < 0 || fi > nb_input_files - 1 ||
1419 si < 0 || si > file_table[fi].nb_streams - 1) {
1420 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1425 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1428 for(i=0;i<nb_ostreams;i++) {
1429 ost = av_mallocz(sizeof(AVOutputStream));
1436 for(k=0;k<nb_output_files;k++) {
1437 os = output_files[k];
1438 for(i=0;i<os->nb_streams;i++) {
1440 ost = ost_table[n++];
1441 ost->file_index = k;
1443 ost->st = os->streams[i];
1444 if (nb_stream_maps > 0) {
1445 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1446 stream_maps[n-1].stream_index;
1448 /* Sanity check that the stream types match */
1449 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1450 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1451 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1452 ost->file_index, ost->index);
1457 /* get corresponding input stream index : we select the first one with the right type */
1459 for(j=0;j<nb_istreams;j++) {
1462 ist->st->codec.codec_type == ost->st->codec.codec_type) {
1463 ost->source_index = j;
1470 /* try again and reuse existing stream */
1471 for(j=0;j<nb_istreams;j++) {
1473 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1474 ost->source_index = j;
1479 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1480 ost->file_index, ost->index);
1485 ist = ist_table[ost->source_index];
1490 /* for each output stream, we compute the right encoding parameters */
1491 for(i=0;i<nb_ostreams;i++) {
1493 ist = ist_table[ost->source_index];
1495 codec = &ost->st->codec;
1496 icodec = &ist->st->codec;
1498 if (ost->st->stream_copy) {
1499 /* if stream_copy is selected, no need to decode or encode */
1500 codec->codec_id = icodec->codec_id;
1501 codec->codec_type = icodec->codec_type;
1502 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1503 codec->bit_rate = icodec->bit_rate;
1504 switch(codec->codec_type) {
1505 case CODEC_TYPE_AUDIO:
1506 codec->sample_rate = icodec->sample_rate;
1507 codec->channels = icodec->channels;
1508 codec->frame_size = icodec->frame_size;
1510 case CODEC_TYPE_VIDEO:
1511 codec->frame_rate = icodec->frame_rate;
1512 codec->frame_rate_base = icodec->frame_rate_base;
1513 codec->width = icodec->width;
1514 codec->height = icodec->height;
1520 switch(codec->codec_type) {
1521 case CODEC_TYPE_AUDIO:
1522 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1525 if (codec->channels == icodec->channels &&
1526 codec->sample_rate == icodec->sample_rate) {
1527 ost->audio_resample = 0;
1529 if (codec->channels != icodec->channels &&
1530 (icodec->codec_id == CODEC_ID_AC3 ||
1531 icodec->codec_id == CODEC_ID_DTS)) {
1532 /* Special case for 5:1 AC3 and DTS input */
1533 /* and mono or stereo output */
1534 /* Request specific number of channels */
1535 icodec->channels = codec->channels;
1536 if (codec->sample_rate == icodec->sample_rate)
1537 ost->audio_resample = 0;
1539 ost->audio_resample = 1;
1542 ost->audio_resample = 1;
1545 if(audio_sync_method>1)
1546 ost->audio_resample = 1;
1548 if(ost->audio_resample){
1549 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1550 codec->sample_rate, icodec->sample_rate);
1552 printf("Can't resample. Aborting.\n");
1556 ist->decoding_needed = 1;
1557 ost->encoding_needed = 1;
1559 case CODEC_TYPE_VIDEO:
1560 if (codec->width == icodec->width &&
1561 codec->height == icodec->height &&
1562 frame_topBand == 0 &&
1563 frame_bottomBand == 0 &&
1564 frame_leftBand == 0 &&
1565 frame_rightBand == 0 &&
1566 frame_padtop == 0 &&
1567 frame_padbottom == 0 &&
1568 frame_padleft == 0 &&
1569 frame_padright == 0)
1571 ost->video_resample = 0;
1572 ost->video_crop = 0;
1574 } else if ((codec->width == icodec->width -
1575 (frame_leftBand + frame_rightBand)) &&
1576 (codec->height == icodec->height -
1577 (frame_topBand + frame_bottomBand)))
1579 ost->video_resample = 0;
1580 ost->video_crop = 1;
1581 ost->topBand = frame_topBand;
1582 ost->leftBand = frame_leftBand;
1583 } else if ((codec->width == icodec->width +
1584 (frame_padleft + frame_padright)) &&
1585 (codec->height == icodec->height +
1586 (frame_padtop + frame_padbottom))) {
1587 ost->video_resample = 0;
1588 ost->video_crop = 0;
1590 ost->padtop = frame_padtop;
1591 ost->padleft = frame_padleft;
1592 ost->padbottom = frame_padbottom;
1593 ost->padright = frame_padright;
1594 avcodec_get_frame_defaults(&ost->pict_tmp);
1595 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1596 codec->width, codec->height ) )
1599 ost->video_resample = 1;
1600 ost->video_crop = 0; // cropping is handled as part of resample
1601 avcodec_get_frame_defaults(&ost->pict_tmp);
1602 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1603 codec->width, codec->height ) )
1606 ost->img_resample_ctx = img_resample_full_init(
1607 ost->st->codec.width, ost->st->codec.height,
1608 ist->st->codec.width, ist->st->codec.height,
1609 frame_topBand, frame_bottomBand,
1610 frame_leftBand, frame_rightBand,
1611 frame_padtop, frame_padbottom,
1612 frame_padleft, frame_padright);
1614 ost->padtop = frame_padtop;
1615 ost->padleft = frame_padleft;
1616 ost->padbottom = frame_padbottom;
1617 ost->padright = frame_padright;
1620 ost->encoding_needed = 1;
1621 ist->decoding_needed = 1;
1627 if (ost->encoding_needed &&
1628 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1629 char logfilename[1024];
1634 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1636 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1637 if (codec->flags & CODEC_FLAG_PASS1) {
1638 f = fopen(logfilename, "w");
1640 perror(logfilename);
1645 /* read the log file */
1646 f = fopen(logfilename, "r");
1648 perror(logfilename);
1651 fseek(f, 0, SEEK_END);
1653 fseek(f, 0, SEEK_SET);
1654 logbuffer = av_malloc(size + 1);
1656 fprintf(stderr, "Could not allocate log buffer\n");
1659 size = fread(logbuffer, 1, size, f);
1661 logbuffer[size] = '\0';
1662 codec->stats_in = logbuffer;
1668 /* dump the file output parameters - cannot be done before in case
1670 for(i=0;i<nb_output_files;i++) {
1671 dump_format(output_files[i], i, output_files[i]->filename, 1);
1674 /* dump the stream mapping */
1676 fprintf(stderr, "Stream mapping:\n");
1677 for(i=0;i<nb_ostreams;i++) {
1679 fprintf(stderr, " Stream #%d.%d -> #%d.%d\n",
1680 ist_table[ost->source_index]->file_index,
1681 ist_table[ost->source_index]->index,
1687 /* open each encoder */
1688 for(i=0;i<nb_ostreams;i++) {
1690 if (ost->encoding_needed) {
1692 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1694 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1695 ost->file_index, ost->index);
1698 if (avcodec_open(&ost->st->codec, codec) < 0) {
1699 fprintf(stderr, "Error while opening codec for stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1700 ost->file_index, ost->index);
1703 extra_size += ost->st->codec.extradata_size;
1707 /* open each decoder */
1708 for(i=0;i<nb_istreams;i++) {
1710 if (ist->decoding_needed) {
1712 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1714 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1715 ist->st->codec.codec_id, ist->file_index, ist->index);
1718 if (avcodec_open(&ist->st->codec, codec) < 0) {
1719 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1720 ist->file_index, ist->index);
1723 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1724 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1729 for(i=0;i<nb_istreams;i++) {
1731 is = input_files[ist->file_index];
1733 ist->next_pts = ist->st->start_time;
1734 if(ist->next_pts == AV_NOPTS_VALUE)
1739 /* compute buffer size max (should use a complete heuristic) */
1740 for(i=0;i<nb_input_files;i++) {
1741 file_table[i].buffer_size_max = 2048;
1744 /* set meta data information from input file if required */
1745 for (i=0;i<nb_meta_data_maps;i++) {
1746 AVFormatContext *out_file;
1747 AVFormatContext *in_file;
1749 int out_file_index = meta_data_maps[i].out_file;
1750 int in_file_index = meta_data_maps[i].in_file;
1751 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1752 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1756 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1757 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1762 out_file = output_files[out_file_index];
1763 in_file = input_files[in_file_index];
1765 strcpy(out_file->title, in_file->title);
1766 strcpy(out_file->author, in_file->author);
1767 strcpy(out_file->copyright, in_file->copyright);
1768 strcpy(out_file->comment, in_file->comment);
1769 strcpy(out_file->album, in_file->album);
1770 out_file->year = in_file->year;
1771 out_file->track = in_file->track;
1772 strcpy(out_file->genre, in_file->genre);
1775 /* open files and write file headers */
1776 for(i=0;i<nb_output_files;i++) {
1777 os = output_files[i];
1778 if (av_write_header(os) < 0) {
1779 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1785 #ifndef CONFIG_WIN32
1786 if ( !using_stdin && verbose >= 0) {
1787 fprintf(stderr, "Press [q] to stop encoding\n");
1788 url_set_interrupt_cb(decode_interrupt_cb);
1796 for(; received_sigterm == 0;) {
1797 int file_index, ist_index;
1805 /* if 'q' pressed, exits */
1809 /* read_key() returns 0 on EOF */
1815 /* select the stream that we must read now by looking at the
1816 smallest output pts */
1818 for(i=0;i<nb_ostreams;i++) {
1821 os = output_files[ost->file_index];
1822 ist = ist_table[ost->source_index];
1823 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
1824 opts = (double)ost->sync_opts * ost->st->codec.frame_rate_base / ost->st->codec.frame_rate;
1826 opts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1827 ipts = (double)ist->pts;
1828 if (!file_table[ist->file_index].eof_reached){
1829 if(ipts < ipts_min) {
1831 if(input_sync ) file_index = ist->file_index;
1833 if(opts < opts_min) {
1835 if(!input_sync) file_index = ist->file_index;
1839 /* if none, if is finished */
1840 if (file_index < 0) {
1844 /* finish if recording time exhausted */
1845 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1848 /* read a frame from it and output it in the fifo */
1849 is = input_files[file_index];
1850 if (av_read_frame(is, &pkt) < 0) {
1851 file_table[file_index].eof_reached = 1;
1856 stream_no_data = is;
1861 av_pkt_dump(stdout, &pkt, do_hex_dump);
1863 /* the following test is needed in case new streams appear
1864 dynamically in stream : we ignore them */
1865 if (pkt.stream_index >= file_table[file_index].nb_streams)
1866 goto discard_packet;
1867 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1868 ist = ist_table[ist_index];
1870 goto discard_packet;
1872 // 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);
1873 if (pkt.dts != AV_NOPTS_VALUE) {
1874 int64_t delta= pkt.dts - ist->next_pts;
1875 if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
1876 input_files_ts_offset[ist->file_index]-= delta;
1878 fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
1879 for(i=0; i<file_table[file_index].nb_streams; i++){
1880 int index= file_table[file_index].ist_index + i;
1881 ist_table[index]->next_pts += delta;
1882 ist_table[index]->is_start=1;
1887 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1888 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1891 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1892 ist->file_index, ist->index);
1894 av_free_packet(&pkt);
1899 av_free_packet(&pkt);
1901 /* dump report by using the output first video and audio streams */
1902 print_report(output_files, ost_table, nb_ostreams, 0);
1905 /* at the end of stream, we must flush the decoder buffers */
1906 for(i=0;i<nb_istreams;i++) {
1908 if (ist->decoding_needed) {
1909 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1915 /* write the trailer if needed and close file */
1916 for(i=0;i<nb_output_files;i++) {
1917 os = output_files[i];
1918 av_write_trailer(os);
1921 /* dump report by using the first video and audio streams */
1922 print_report(output_files, ost_table, nb_ostreams, 1);
1924 /* close each encoder */
1925 for(i=0;i<nb_ostreams;i++) {
1927 if (ost->encoding_needed) {
1928 av_freep(&ost->st->codec.stats_in);
1929 avcodec_close(&ost->st->codec);
1933 /* close each decoder */
1934 for(i=0;i<nb_istreams;i++) {
1936 if (ist->decoding_needed) {
1937 avcodec_close(&ist->st->codec);
1945 av_free(file_table);
1948 for(i=0;i<nb_istreams;i++) {
1955 for(i=0;i<nb_ostreams;i++) {
1959 fclose(ost->logfile);
1960 ost->logfile = NULL;
1962 fifo_free(&ost->fifo); /* works even if fifo is not
1963 initialized but set to zero */
1964 av_free(ost->pict_tmp.data[0]);
1965 if (ost->video_resample)
1966 img_resample_close(ost->img_resample_ctx);
1967 if (ost->audio_resample)
1968 audio_resample_close(ost->resample);
1981 int file_read(const char *filename)
1984 unsigned char buffer[1024];
1987 if (url_open(&h, filename, O_RDONLY) < 0) {
1988 printf("could not open '%s'\n", filename);
1992 len = url_read(h, buffer, sizeof(buffer));
1995 for(i=0;i<len;i++) putchar(buffer[i]);
2002 static void opt_image_format(const char *arg)
2006 for(f = first_image_format; f != NULL; f = f->next) {
2007 if (!strcmp(arg, f->name))
2011 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2017 static void opt_format(const char *arg)
2019 /* compatibility stuff for pgmyuv */
2020 if (!strcmp(arg, "pgmyuv")) {
2021 pgmyuv_compatibility_hack=1;
2022 // opt_image_format(arg);
2026 file_iformat = av_find_input_format(arg);
2027 file_oformat = guess_format(arg, NULL, NULL);
2028 if (!file_iformat && !file_oformat) {
2029 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2034 static void opt_video_bitrate(const char *arg)
2036 video_bit_rate = atoi(arg) * 1000;
2039 static void opt_video_bitrate_tolerance(const char *arg)
2041 video_bit_rate_tolerance = atoi(arg) * 1000;
2044 static void opt_video_bitrate_max(const char *arg)
2046 video_rc_max_rate = atoi(arg) * 1000;
2049 static void opt_video_bitrate_min(const char *arg)
2051 video_rc_min_rate = atoi(arg) * 1000;
2054 static void opt_video_buffer_size(const char *arg)
2056 video_rc_buffer_size = atoi(arg) * 8*1024;
2059 static void opt_video_rc_eq(char *arg)
2064 static void opt_video_rc_override_string(char *arg)
2066 video_rc_override_string = arg;
2070 static void opt_workaround_bugs(const char *arg)
2072 workaround_bugs = atoi(arg);
2075 static void opt_dct_algo(const char *arg)
2077 dct_algo = atoi(arg);
2080 static void opt_idct_algo(const char *arg)
2082 idct_algo = atoi(arg);
2085 static void opt_me_threshold(const char *arg)
2087 me_threshold = atoi(arg);
2090 static void opt_mb_threshold(const char *arg)
2092 mb_threshold = atoi(arg);
2095 static void opt_error_resilience(const char *arg)
2097 error_resilience = atoi(arg);
2100 static void opt_error_concealment(const char *arg)
2102 error_concealment = atoi(arg);
2105 static void opt_debug(const char *arg)
2110 static void opt_vismv(const char *arg)
2112 debug_mv = atoi(arg);
2115 static void opt_verbose(const char *arg)
2117 verbose = atoi(arg);
2118 av_log_set_level(atoi(arg));
2121 static void opt_frame_rate(const char *arg)
2123 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2124 fprintf(stderr, "Incorrect frame rate\n");
2129 static void opt_frame_crop_top(const char *arg)
2131 frame_topBand = atoi(arg);
2132 if (frame_topBand < 0) {
2133 fprintf(stderr, "Incorrect top crop size\n");
2136 if ((frame_topBand % 2) != 0) {
2137 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2140 if ((frame_topBand) >= frame_height){
2141 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2144 frame_height -= frame_topBand;
2147 static void opt_frame_crop_bottom(const char *arg)
2149 frame_bottomBand = atoi(arg);
2150 if (frame_bottomBand < 0) {
2151 fprintf(stderr, "Incorrect bottom crop size\n");
2154 if ((frame_bottomBand % 2) != 0) {
2155 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2158 if ((frame_bottomBand) >= frame_height){
2159 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2162 frame_height -= frame_bottomBand;
2165 static void opt_frame_crop_left(const char *arg)
2167 frame_leftBand = atoi(arg);
2168 if (frame_leftBand < 0) {
2169 fprintf(stderr, "Incorrect left crop size\n");
2172 if ((frame_leftBand % 2) != 0) {
2173 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2176 if ((frame_leftBand) >= frame_width){
2177 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2180 frame_width -= frame_leftBand;
2183 static void opt_frame_crop_right(const char *arg)
2185 frame_rightBand = atoi(arg);
2186 if (frame_rightBand < 0) {
2187 fprintf(stderr, "Incorrect right crop size\n");
2190 if ((frame_rightBand % 2) != 0) {
2191 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2194 if ((frame_rightBand) >= frame_width){
2195 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2198 frame_width -= frame_rightBand;
2201 static void opt_frame_size(const char *arg)
2203 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2204 fprintf(stderr, "Incorrect frame size\n");
2207 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2208 fprintf(stderr, "Frame size must be a multiple of 2\n");
2214 #define SCALEBITS 10
2215 #define ONE_HALF (1 << (SCALEBITS - 1))
2216 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2218 #define RGB_TO_Y(r, g, b) \
2219 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2220 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2222 #define RGB_TO_U(r1, g1, b1, shift)\
2223 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2224 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2226 #define RGB_TO_V(r1, g1, b1, shift)\
2227 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2228 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2230 static void opt_pad_color(const char *arg) {
2231 /* Input is expected to be six hex digits similar to
2232 how colors are expressed in html tags (but without the #) */
2233 int rgb = strtol(arg, NULL, 16);
2237 g = ((rgb >> 8) & 255);
2240 padcolor[0] = RGB_TO_Y(r,g,b);
2241 padcolor[1] = RGB_TO_U(r,g,b,0);
2242 padcolor[2] = RGB_TO_V(r,g,b,0);
2245 static void opt_frame_pad_top(const char *arg)
2247 frame_padtop = atoi(arg);
2248 if (frame_padtop < 0) {
2249 fprintf(stderr, "Incorrect top pad size\n");
2252 if ((frame_padtop % 2) != 0) {
2253 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2258 static void opt_frame_pad_bottom(const char *arg)
2260 frame_padbottom = atoi(arg);
2261 if (frame_padbottom < 0) {
2262 fprintf(stderr, "Incorrect bottom pad size\n");
2265 if ((frame_padbottom % 2) != 0) {
2266 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2272 static void opt_frame_pad_left(const char *arg)
2274 frame_padleft = atoi(arg);
2275 if (frame_padleft < 0) {
2276 fprintf(stderr, "Incorrect left pad size\n");
2279 if ((frame_padleft % 2) != 0) {
2280 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2286 static void opt_frame_pad_right(const char *arg)
2288 frame_padright = atoi(arg);
2289 if (frame_padright < 0) {
2290 fprintf(stderr, "Incorrect right pad size\n");
2293 if ((frame_padright % 2) != 0) {
2294 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2300 static void opt_frame_pix_fmt(const char *arg)
2302 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2305 static void opt_frame_aspect_ratio(const char *arg)
2311 p = strchr(arg, ':');
2313 x = strtol(arg, (char **)&arg, 10);
2315 y = strtol(arg+1, (char **)&arg, 10);
2317 ar = (double)x / (double)y;
2319 ar = strtod(arg, (char **)&arg);
2322 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2325 frame_aspect_ratio = ar;
2328 static void opt_gop_size(const char *arg)
2330 gop_size = atoi(arg);
2333 static void opt_b_frames(const char *arg)
2335 b_frames = atoi(arg);
2336 if (b_frames > FF_MAX_B_FRAMES) {
2337 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2339 } else if (b_frames < 1) {
2340 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2345 static void opt_mb_decision(const char *arg)
2347 mb_decision = atoi(arg);
2350 static void opt_mb_cmp(const char *arg)
2355 static void opt_ildct_cmp(const char *arg)
2357 ildct_cmp = atoi(arg);
2360 static void opt_sub_cmp(const char *arg)
2362 sub_cmp = atoi(arg);
2365 static void opt_cmp(const char *arg)
2370 static void opt_pre_cmp(const char *arg)
2372 pre_cmp = atoi(arg);
2375 static void opt_pre_me(const char *arg)
2380 static void opt_lumi_mask(const char *arg)
2382 lumi_mask = atof(arg);
2385 static void opt_dark_mask(const char *arg)
2387 dark_mask = atof(arg);
2390 static void opt_scplx_mask(const char *arg)
2392 scplx_mask = atof(arg);
2395 static void opt_tcplx_mask(const char *arg)
2397 tcplx_mask = atof(arg);
2400 static void opt_p_mask(const char *arg)
2405 static void opt_qscale(const char *arg)
2407 video_qscale = atof(arg);
2408 if (video_qscale < 0.01 ||
2409 video_qscale > 255) {
2410 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2415 static void opt_lmax(const char *arg)
2417 video_lmax = atof(arg)*FF_QP2LAMBDA;
2420 static void opt_lmin(const char *arg)
2422 video_lmin = atof(arg)*FF_QP2LAMBDA;
2425 static void opt_qmin(const char *arg)
2427 video_qmin = atoi(arg);
2428 if (video_qmin < 0 ||
2430 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2435 static void opt_qmax(const char *arg)
2437 video_qmax = atoi(arg);
2438 if (video_qmax < 0 ||
2440 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2445 static void opt_mb_qmin(const char *arg)
2447 video_mb_qmin = atoi(arg);
2448 if (video_mb_qmin < 0 ||
2449 video_mb_qmin > 31) {
2450 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2455 static void opt_mb_qmax(const char *arg)
2457 video_mb_qmax = atoi(arg);
2458 if (video_mb_qmax < 0 ||
2459 video_mb_qmax > 31) {
2460 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2465 static void opt_qdiff(const char *arg)
2467 video_qdiff = atoi(arg);
2468 if (video_qdiff < 0 ||
2470 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2475 static void opt_qblur(const char *arg)
2477 video_qblur = atof(arg);
2480 static void opt_qcomp(const char *arg)
2482 video_qcomp = atof(arg);
2485 static void opt_rc_initial_cplx(const char *arg)
2487 video_rc_initial_cplx = atof(arg);
2489 static void opt_b_qfactor(const char *arg)
2491 video_b_qfactor = atof(arg);
2493 static void opt_i_qfactor(const char *arg)
2495 video_i_qfactor = atof(arg);
2497 static void opt_b_qoffset(const char *arg)
2499 video_b_qoffset = atof(arg);
2501 static void opt_i_qoffset(const char *arg)
2503 video_i_qoffset = atof(arg);
2506 static void opt_ibias(const char *arg)
2508 video_intra_quant_bias = atoi(arg);
2510 static void opt_pbias(const char *arg)
2512 video_inter_quant_bias = atoi(arg);
2515 static void opt_packet_size(const char *arg)
2517 packet_size= atoi(arg);
2520 static void opt_error_rate(const char *arg)
2522 error_rate= atoi(arg);
2525 static void opt_strict(const char *arg)
2530 static void opt_top_field_first(const char *arg)
2532 top_field_first= atoi(arg);
2535 static void opt_noise_reduction(const char *arg)
2537 noise_reduction= atoi(arg);
2540 static void opt_qns(const char *arg)
2545 static void opt_sc_threshold(const char *arg)
2547 sc_threshold= atoi(arg);
2550 static void opt_me_range(const char *arg)
2552 me_range = atoi(arg);
2555 static void opt_thread_count(const char *arg)
2557 thread_count= atoi(arg);
2558 #if !defined(HAVE_THREADS)
2560 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2564 static void opt_audio_bitrate(const char *arg)
2566 audio_bit_rate = atoi(arg) * 1000;
2569 static void opt_audio_rate(const char *arg)
2571 audio_sample_rate = atoi(arg);
2574 static void opt_audio_channels(const char *arg)
2576 audio_channels = atoi(arg);
2579 static void opt_video_device(const char *arg)
2581 video_device = av_strdup(arg);
2584 static void opt_grab_device(const char *arg)
2586 grab_device = av_strdup(arg);
2589 static void opt_video_channel(const char *arg)
2591 video_channel = strtol(arg, NULL, 0);
2594 static void opt_video_standard(const char *arg)
2596 video_standard = av_strdup(arg);
2599 static void opt_audio_device(const char *arg)
2601 audio_device = av_strdup(arg);
2604 static void opt_audio_codec(const char *arg)
2608 if (!strcmp(arg, "copy")) {
2609 audio_stream_copy = 1;
2613 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_AUDIO)
2618 fprintf(stderr, "Unknown audio codec '%s'\n", arg);
2621 audio_codec_id = p->id;
2626 static void opt_audio_tag(const char *arg)
2629 audio_codec_tag= strtol(arg, &tail, 0);
2632 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2635 static void opt_video_tag(const char *arg)
2638 video_codec_tag= strtol(arg, &tail, 0);
2641 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2644 static void add_frame_hooker(const char *arg)
2649 char *args = av_strdup(arg);
2653 argv[0] = strtok(args, " ");
2654 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2657 i = frame_hook_add(argc, argv);
2660 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2665 const char *motion_str[] = {
2675 static void opt_motion_estimation(const char *arg)
2681 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2684 if (!strcmp(*p, arg))
2688 me_method = (p - motion_str) + 1;
2691 static void opt_video_codec(const char *arg)
2695 if (!strcmp(arg, "copy")) {
2696 video_stream_copy = 1;
2700 if (!strcmp(p->name, arg) && p->type == CODEC_TYPE_VIDEO)
2705 fprintf(stderr, "Unknown video codec '%s'\n", arg);
2708 video_codec_id = p->id;
2713 static void opt_map(const char *arg)
2719 m = &stream_maps[nb_stream_maps++];
2721 m->file_index = strtol(arg, (char **)&p, 0);
2725 m->stream_index = strtol(p, (char **)&p, 0);
2728 static void opt_map_meta_data(const char *arg)
2734 m = &meta_data_maps[nb_meta_data_maps++];
2736 m->out_file = strtol(arg, (char **)&p, 0);
2740 m->in_file = strtol(p, (char **)&p, 0);
2743 static void opt_recording_time(const char *arg)
2745 recording_time = parse_date(arg, 1);
2748 static void opt_start_time(const char *arg)
2750 start_time = parse_date(arg, 1);
2753 static void opt_rec_timestamp(const char *arg)
2755 rec_timestamp = parse_date(arg, 0) / 1000000;
2758 static void opt_input_ts_offset(const char *arg)
2760 input_ts_offset = parse_date(arg, 1);
2763 static void opt_input_file(const char *filename)
2765 AVFormatContext *ic;
2766 AVFormatParameters params, *ap = ¶ms;
2767 int err, i, ret, rfps, rfps_base;
2770 if (!strcmp(filename, "-"))
2773 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2774 !strcmp( filename, "/dev/stdin" );
2776 /* get default parameters from command line */
2777 memset(ap, 0, sizeof(*ap));
2778 ap->sample_rate = audio_sample_rate;
2779 ap->channels = audio_channels;
2780 ap->frame_rate = frame_rate;
2781 ap->frame_rate_base = frame_rate_base;
2782 ap->width = frame_width + frame_padleft + frame_padright;
2783 ap->height = frame_height + frame_padtop + frame_padbottom;
2784 ap->image_format = image_format;
2785 ap->pix_fmt = frame_pix_fmt;
2786 ap->device = grab_device;
2787 ap->channel = video_channel;
2788 ap->standard = video_standard;
2789 ap->video_codec_id = video_codec_id;
2790 ap->audio_codec_id = audio_codec_id;
2791 if(pgmyuv_compatibility_hack)
2792 ap->video_codec_id= CODEC_ID_PGMYUV;
2794 /* open the input file with generic libav function */
2795 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2797 print_error(filename, err);
2801 /* If not enough info to get the stream parameters, we decode the
2802 first frames to get it. (used in mpeg case for example) */
2803 ret = av_find_stream_info(ic);
2804 if (ret < 0 && verbose >= 0) {
2805 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2809 timestamp = start_time;
2810 /* add the stream start time */
2811 if (ic->start_time != AV_NOPTS_VALUE)
2812 timestamp += ic->start_time;
2814 /* if seeking requested, we execute it */
2815 if (start_time != 0) {
2816 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2818 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2819 filename, (double)timestamp / AV_TIME_BASE);
2821 /* reset seek info */
2825 /* update the current parameters so that they match the one of the input stream */
2826 for(i=0;i<ic->nb_streams;i++) {
2827 AVCodecContext *enc = &ic->streams[i]->codec;
2828 #if defined(HAVE_THREADS)
2830 avcodec_thread_init(enc, thread_count);
2832 enc->thread_count= thread_count;
2833 switch(enc->codec_type) {
2834 case CODEC_TYPE_AUDIO:
2835 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2836 audio_channels = enc->channels;
2837 audio_sample_rate = enc->sample_rate;
2839 case CODEC_TYPE_VIDEO:
2840 frame_height = enc->height;
2841 frame_width = enc->width;
2842 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2843 frame_pix_fmt = enc->pix_fmt;
2844 rfps = ic->streams[i]->r_frame_rate;
2845 rfps_base = ic->streams[i]->r_frame_rate_base;
2846 enc->workaround_bugs = workaround_bugs;
2847 enc->error_resilience = error_resilience;
2848 enc->error_concealment = error_concealment;
2849 enc->idct_algo = idct_algo;
2851 enc->debug_mv = debug_mv;
2852 enc->lowres= lowres;
2854 enc->flags|= CODEC_FLAG_BITEXACT;
2856 enc->debug |= FF_DEBUG_MV;
2858 assert(enc->frame_rate_base == rfps_base); // should be true for now
2859 if (enc->frame_rate != rfps) {
2862 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f->%2.2f\n",
2863 i, (float)enc->frame_rate / enc->frame_rate_base,
2865 (float)rfps / rfps_base);
2867 /* update the current frame rate to match the stream frame rate */
2869 frame_rate_base = rfps_base;
2871 enc->rate_emu = rate_emu;
2873 case CODEC_TYPE_DATA:
2880 input_files[nb_input_files] = ic;
2881 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2882 /* dump the file content */
2884 dump_format(ic, nb_input_files, filename, 0);
2887 file_iformat = NULL;
2888 file_oformat = NULL;
2889 image_format = NULL;
2897 static void opt_grab(const char *arg)
2899 file_iformat = av_find_input_format(arg);
2903 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2905 int has_video, has_audio, i, j;
2906 AVFormatContext *ic;
2910 for(j=0;j<nb_input_files;j++) {
2911 ic = input_files[j];
2912 for(i=0;i<ic->nb_streams;i++) {
2913 AVCodecContext *enc = &ic->streams[i]->codec;
2914 switch(enc->codec_type) {
2915 case CODEC_TYPE_AUDIO:
2918 case CODEC_TYPE_VIDEO:
2921 case CODEC_TYPE_DATA:
2928 *has_video_ptr = has_video;
2929 *has_audio_ptr = has_audio;
2932 static void opt_output_file(const char *filename)
2935 AVFormatContext *oc;
2936 int use_video, use_audio, nb_streams, input_has_video, input_has_audio;
2938 AVFormatParameters params, *ap = ¶ms;
2940 if (!strcmp(filename, "-"))
2943 oc = av_alloc_format_context();
2945 if (!file_oformat) {
2946 file_oformat = guess_format(NULL, filename, NULL);
2947 if (!file_oformat) {
2948 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
2954 oc->oformat = file_oformat;
2956 if (!strcmp(file_oformat->name, "ffm") &&
2957 strstart(filename, "http:", NULL)) {
2958 /* special case for files sent to ffserver: we get the stream
2959 parameters from ffserver */
2960 if (read_ffserver_streams(oc, filename) < 0) {
2961 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
2965 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
2966 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
2968 /* disable if no corresponding type found and at least one
2970 if (nb_input_files > 0) {
2971 check_audio_video_inputs(&input_has_video, &input_has_audio);
2972 if (!input_has_video)
2974 if (!input_has_audio)
2978 /* manual disable */
2979 if (audio_disable) {
2982 if (video_disable) {
2988 AVCodecContext *video_enc;
2990 st = av_new_stream(oc, nb_streams++);
2992 fprintf(stderr, "Could not alloc stream\n");
2995 #if defined(HAVE_THREADS)
2997 avcodec_thread_init(&st->codec, thread_count);
3000 video_enc = &st->codec;
3003 video_enc->codec_tag= video_codec_tag;
3005 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3006 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3007 if (video_stream_copy) {
3008 st->stream_copy = 1;
3009 video_enc->codec_type = CODEC_TYPE_VIDEO;
3015 codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_VIDEO);
3016 if (video_codec_id != CODEC_ID_NONE)
3017 codec_id = video_codec_id;
3019 video_enc->codec_id = codec_id;
3020 codec = avcodec_find_encoder(codec_id);
3022 video_enc->bit_rate = video_bit_rate;
3023 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3024 video_enc->frame_rate = frame_rate;
3025 video_enc->frame_rate_base = frame_rate_base;
3026 if(codec && codec->supported_framerates){
3027 const AVRational *p= codec->supported_framerates;
3028 AVRational req= (AVRational){frame_rate, frame_rate_base};
3029 const AVRational *best=NULL;
3030 AVRational best_error= (AVRational){INT_MAX, 1};
3031 for(; p->den!=0; p++){
3032 AVRational error= av_sub_q(req, *p);
3033 if(error.num <0) error.num *= -1;
3034 if(av_cmp_q(error, best_error) < 0){
3039 video_enc->frame_rate = best->num;
3040 video_enc->frame_rate_base= best->den;
3043 video_enc->width = frame_width + frame_padright + frame_padleft;
3044 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3045 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3046 video_enc->pix_fmt = frame_pix_fmt;
3048 if(codec && codec->pix_fmts){
3049 const enum PixelFormat *p= codec->pix_fmts;
3051 if(*p == video_enc->pix_fmt)
3055 video_enc->pix_fmt = codec->pix_fmts[0];
3059 video_enc->gop_size = gop_size;
3061 video_enc->gop_size = 0;
3062 if (video_qscale || same_quality) {
3063 video_enc->flags |= CODEC_FLAG_QSCALE;
3064 st->quality = FF_QP2LAMBDA * video_qscale;
3068 video_enc->intra_matrix = intra_matrix;
3070 video_enc->inter_matrix = inter_matrix;
3073 video_enc->flags |= CODEC_FLAG_BITEXACT;
3075 video_enc->mb_decision = mb_decision;
3076 video_enc->mb_cmp = mb_cmp;
3077 video_enc->ildct_cmp = ildct_cmp;
3078 video_enc->me_sub_cmp = sub_cmp;
3079 video_enc->me_cmp = cmp;
3080 video_enc->me_pre_cmp = pre_cmp;
3081 video_enc->pre_me = pre_me;
3082 video_enc->lumi_masking = lumi_mask;
3083 video_enc->dark_masking = dark_mask;
3084 video_enc->spatial_cplx_masking = scplx_mask;
3085 video_enc->temporal_cplx_masking = tcplx_mask;
3086 video_enc->p_masking = p_mask;
3087 video_enc->quantizer_noise_shaping= qns;
3090 video_enc->flags |= CODEC_FLAG_H263P_UMV;
3093 video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3096 video_enc->flags |= CODEC_FLAG_H263P_AIC;
3099 video_enc->flags |= CODEC_FLAG_H263P_AIV;
3102 video_enc->flags |= CODEC_FLAG_4MV;
3105 video_enc->flags |= CODEC_FLAG_OBMC;
3108 video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3112 video_enc->flags |= CODEC_FLAG_PART;
3115 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3118 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3120 if (use_scan_offset) {
3121 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3124 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3127 video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3130 video_enc->flags |= CODEC_FLAG_QPEL;
3133 video_enc->flags |= CODEC_FLAG_QP_RD;
3136 video_enc->flags |= CODEC_FLAG_CBP_RD;
3139 video_enc->max_b_frames = b_frames;
3140 video_enc->b_frame_strategy = 0;
3141 video_enc->b_quant_factor = 2.0;
3143 if (do_interlace_dct) {
3144 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3146 if (do_interlace_me) {
3147 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3149 video_enc->qmin = video_qmin;
3150 video_enc->qmax = video_qmax;
3151 video_enc->lmin = video_lmin;
3152 video_enc->lmax = video_lmax;
3153 video_enc->mb_qmin = video_mb_qmin;
3154 video_enc->mb_qmax = video_mb_qmax;
3155 video_enc->max_qdiff = video_qdiff;
3156 video_enc->qblur = video_qblur;
3157 video_enc->qcompress = video_qcomp;
3158 video_enc->rc_eq = video_rc_eq;
3159 video_enc->debug = debug;
3160 video_enc->debug_mv = debug_mv;
3161 video_enc->thread_count = thread_count;
3162 p= video_rc_override_string;
3165 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3167 fprintf(stderr, "error parsing rc_override\n");
3170 video_enc->rc_override=
3171 av_realloc(video_enc->rc_override,
3172 sizeof(RcOverride)*(i+1));
3173 video_enc->rc_override[i].start_frame= start;
3174 video_enc->rc_override[i].end_frame = end;
3176 video_enc->rc_override[i].qscale= q;
3177 video_enc->rc_override[i].quality_factor= 1.0;
3180 video_enc->rc_override[i].qscale= 0;
3181 video_enc->rc_override[i].quality_factor= -q/100.0;
3186 video_enc->rc_override_count=i;
3188 video_enc->rc_max_rate = video_rc_max_rate;
3189 video_enc->rc_min_rate = video_rc_min_rate;
3190 video_enc->rc_buffer_size = video_rc_buffer_size;
3191 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3192 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3193 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3194 video_enc->i_quant_factor = video_i_qfactor;
3195 video_enc->b_quant_factor = video_b_qfactor;
3196 video_enc->i_quant_offset = video_i_qoffset;
3197 video_enc->b_quant_offset = video_b_qoffset;
3198 video_enc->intra_quant_bias = video_intra_quant_bias;
3199 video_enc->inter_quant_bias = video_inter_quant_bias;
3200 video_enc->dct_algo = dct_algo;
3201 video_enc->idct_algo = idct_algo;
3202 video_enc->me_threshold= me_threshold;
3203 video_enc->mb_threshold= mb_threshold;
3204 video_enc->intra_dc_precision= intra_dc_precision - 8;
3205 video_enc->strict_std_compliance = strict;
3206 video_enc->error_rate = error_rate;
3207 video_enc->noise_reduction= noise_reduction;
3208 video_enc->scenechange_threshold= sc_threshold;
3209 video_enc->me_range = me_range;
3210 video_enc->coder_type= coder;
3211 video_enc->context_model= context;
3212 video_enc->prediction_method= predictor;
3213 video_enc->profile= video_profile;
3214 video_enc->level= video_level;
3215 video_enc->nsse_weight= nsse_weight;
3216 video_enc->me_subpel_quality= subpel_quality;
3219 video_enc->rtp_mode= 1;
3220 video_enc->rtp_payload_size= packet_size;
3224 video_enc->flags|= CODEC_FLAG_PSNR;
3226 video_enc->me_method = me_method;
3231 video_enc->flags |= CODEC_FLAG_PASS1;
3233 video_enc->flags |= CODEC_FLAG_PASS2;
3240 AVCodecContext *audio_enc;
3242 st = av_new_stream(oc, nb_streams++);
3244 fprintf(stderr, "Could not alloc stream\n");
3247 #if defined(HAVE_THREADS)
3249 avcodec_thread_init(&st->codec, thread_count);
3252 audio_enc = &st->codec;
3253 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3256 audio_enc->codec_tag= audio_codec_tag;
3258 if(!strcmp(file_oformat->name, "mp4") || !strcmp(file_oformat->name, "mov") || !strcmp(file_oformat->name, "3gp"))
3259 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3260 if (audio_stream_copy) {
3261 st->stream_copy = 1;
3262 audio_enc->channels = audio_channels;
3264 codec_id = av_guess_codec(file_oformat, NULL, filename, NULL, CODEC_TYPE_AUDIO);
3265 if (audio_codec_id != CODEC_ID_NONE)
3266 codec_id = audio_codec_id;
3267 audio_enc->codec_id = codec_id;
3269 audio_enc->bit_rate = audio_bit_rate;
3270 audio_enc->strict_std_compliance = strict;
3271 audio_enc->thread_count = thread_count;
3272 /* For audio codecs other than AC3 or DTS we limit */
3273 /* the number of coded channels to stereo */
3274 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3275 && codec_id != CODEC_ID_DTS) {
3276 audio_enc->channels = 2;
3278 audio_enc->channels = audio_channels;
3280 audio_enc->sample_rate = audio_sample_rate;
3283 oc->nb_streams = nb_streams;
3286 fprintf(stderr, "No audio or video streams available\n");
3290 oc->timestamp = rec_timestamp;
3293 pstrcpy(oc->title, sizeof(oc->title), str_title);
3295 pstrcpy(oc->author, sizeof(oc->author), str_author);
3297 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3299 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3302 output_files[nb_output_files++] = oc;
3304 strcpy(oc->filename, filename);
3306 /* check filename in case of an image number is expected */
3307 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3308 if (filename_number_test(oc->filename) < 0) {
3309 print_error(oc->filename, AVERROR_NUMEXPECTED);
3314 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3315 /* test if it already exists to avoid loosing precious files */
3316 if (!file_overwrite &&
3317 (strchr(filename, ':') == NULL ||
3318 strstart(filename, "file:", NULL))) {
3319 if (url_exist(filename)) {
3322 if ( !using_stdin ) {
3323 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3326 if (toupper(c) != 'Y') {
3327 fprintf(stderr, "Not overwriting - exiting\n");
3332 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3339 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3340 fprintf(stderr, "Could not open '%s'\n", filename);
3345 memset(ap, 0, sizeof(*ap));
3346 ap->image_format = image_format;
3347 if (av_set_parameters(oc, ap) < 0) {
3348 fprintf(stderr, "%s: Invalid encoding parameters\n",
3353 oc->packet_size= mux_packet_size;
3354 oc->mux_rate= mux_rate;
3355 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3356 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3358 /* reset some options */
3359 file_oformat = NULL;
3360 file_iformat = NULL;
3361 image_format = NULL;
3364 audio_codec_id = CODEC_ID_NONE;
3365 video_codec_id = CODEC_ID_NONE;
3366 audio_stream_copy = 0;
3367 video_stream_copy = 0;
3370 /* prepare dummy protocols for grab */
3371 static void prepare_grab(void)
3373 int has_video, has_audio, i, j;
3374 AVFormatContext *oc;
3375 AVFormatContext *ic;
3376 AVFormatParameters vp1, *vp = &vp1;
3377 AVFormatParameters ap1, *ap = &ap1;
3379 /* see if audio/video inputs are needed */
3382 memset(ap, 0, sizeof(*ap));
3383 memset(vp, 0, sizeof(*vp));
3384 vp->frame_rate_base= 1;
3385 for(j=0;j<nb_output_files;j++) {
3386 oc = output_files[j];
3387 for(i=0;i<oc->nb_streams;i++) {
3388 AVCodecContext *enc = &oc->streams[i]->codec;
3389 switch(enc->codec_type) {
3390 case CODEC_TYPE_AUDIO:
3391 if (enc->sample_rate > ap->sample_rate)
3392 ap->sample_rate = enc->sample_rate;
3393 if (enc->channels > ap->channels)
3394 ap->channels = enc->channels;
3397 case CODEC_TYPE_VIDEO:
3398 if (enc->width > vp->width)
3399 vp->width = enc->width;
3400 if (enc->height > vp->height)
3401 vp->height = enc->height;
3403 if (vp->frame_rate_base*(int64_t)enc->frame_rate > enc->frame_rate_base*(int64_t)vp->frame_rate){
3404 vp->frame_rate = enc->frame_rate;
3405 vp->frame_rate_base = enc->frame_rate_base;
3415 if (has_video == 0 && has_audio == 0) {
3416 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3421 AVInputFormat *fmt1;
3422 fmt1 = av_find_input_format(video_grab_format);
3423 vp->device = video_device;
3424 vp->channel = video_channel;
3425 vp->standard = video_standard;
3426 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3427 fprintf(stderr, "Could not find video grab device\n");
3430 /* If not enough info to get the stream parameters, we decode the
3431 first frames to get it. */
3432 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3433 fprintf(stderr, "Could not find video grab parameters\n");
3436 /* by now video grab has one stream */
3437 ic->streams[0]->r_frame_rate = vp->frame_rate;
3438 ic->streams[0]->r_frame_rate_base = vp->frame_rate_base;
3439 input_files[nb_input_files] = ic;
3442 dump_format(ic, nb_input_files, "", 0);
3446 if (has_audio && audio_grab_format) {
3447 AVInputFormat *fmt1;
3448 fmt1 = av_find_input_format(audio_grab_format);
3449 ap->device = audio_device;
3450 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3451 fprintf(stderr, "Could not find audio grab device\n");
3454 input_files[nb_input_files] = ic;
3457 dump_format(ic, nb_input_files, "", 0);
3463 /* same option as mencoder */
3464 static void opt_pass(const char *pass_str)
3467 pass = atoi(pass_str);
3468 if (pass != 1 && pass != 2) {
3469 fprintf(stderr, "pass number can be only 1 or 2\n");
3475 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3476 static int64_t getutime(void)
3478 return av_gettime();
3481 static int64_t getutime(void)
3483 struct rusage rusage;
3485 getrusage(RUSAGE_SELF, &rusage);
3486 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3490 extern int ffm_nopts;
3492 static void opt_bitexact(void)
3495 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3499 static void show_formats(void)
3501 AVInputFormat *ifmt;
3502 AVOutputFormat *ofmt;
3503 AVImageFormat *image_fmt;
3506 const char **pp, *last_name;
3508 printf("File formats:\n");
3513 const char *name=NULL;
3514 const char *long_name=NULL;
3516 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3517 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3518 strcmp(ofmt->name, last_name)>0){
3520 long_name= ofmt->long_name;
3524 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3525 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3526 strcmp(ifmt->name, last_name)>0){
3528 long_name= ifmt->long_name;
3531 if(name && strcmp(ifmt->name, name)==0)
3543 long_name ? long_name:" ");
3547 printf("Image formats (filename extensions, if any, follow):\n");
3548 for(image_fmt = first_image_format; image_fmt != NULL;
3549 image_fmt = image_fmt->next) {
3552 image_fmt->img_read ? "D":" ",
3553 image_fmt->img_write ? "E":" ",
3555 image_fmt->extensions ? image_fmt->extensions:" ");
3559 printf("Codecs:\n");
3567 for(p = first_avcodec; p != NULL; p = p->next) {
3568 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3569 strcmp(p->name, last_name)>0){
3571 decode= encode= cap=0;
3573 if(p2 && strcmp(p->name, p2->name)==0){
3574 if(p->decode) decode=1;
3575 if(p->encode) encode=1;
3576 cap |= p->capabilities;
3581 last_name= p2->name;
3585 decode ? "D": (/*p2->decoder ? "d":*/" "),
3587 p2->type == CODEC_TYPE_AUDIO ? "A":"V",
3588 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3589 cap & CODEC_CAP_DR1 ? "D":" ",
3590 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3592 /* if(p2->decoder && decode==0)
3593 printf(" use %s for decoding", p2->decoder->name);*/
3598 printf("Supported file protocols:\n");
3599 for(up = first_protocol; up != NULL; up = up->next)
3600 printf(" %s:", up->name);
3603 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3604 printf("Motion estimation methods:\n");
3608 if ((pp - motion_str + 1) == ME_ZERO)
3609 printf("(fastest)");
3610 else if ((pp - motion_str + 1) == ME_FULL)
3611 printf("(slowest)");
3612 else if ((pp - motion_str + 1) == ME_EPZS)
3613 printf("(default)");
3618 "Note, the names of encoders and decoders dont always match, so there are\n"
3619 "several cases where the above table shows encoder only or decoder only entries\n"
3620 "even though both encoding and decoding are supported for example, the h263\n"
3621 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3626 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3629 const char *p = str;
3636 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3643 void opt_inter_matrix(const char *arg)
3645 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3646 parse_matrix_coeffs(inter_matrix, arg);
3649 void opt_intra_matrix(const char *arg)
3651 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3652 parse_matrix_coeffs(intra_matrix, arg);
3655 static void opt_target(const char *arg)
3659 if(!strncmp(arg, "pal-", 4)) {
3662 } else if(!strncmp(arg, "ntsc-", 5)) {
3667 /* Calculate FR via float to avoid int overflow */
3668 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3671 } else if((fr == 29970) || (fr == 23976)) {
3674 /* Try to determine PAL/NTSC by peeking in the input files */
3675 if(nb_input_files) {
3677 for(j = 0; j < nb_input_files; j++) {
3678 for(i = 0; i < input_files[j]->nb_streams; i++) {
3679 AVCodecContext *c = &input_files[j]->streams[i]->codec;
3680 if(c->codec_type != CODEC_TYPE_VIDEO)
3682 fr = c->frame_rate * 1000 / c->frame_rate_base;
3686 } else if((fr == 29970) || (fr == 23976)) {
3696 if(verbose && norm >= 0)
3697 printf("Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3701 fprintf(stderr, "Could not determine norm (PAL/NTSC) for target.\n");
3702 fprintf(stderr, "Please prefix target with \"pal-\" or \"ntsc-\",\n");
3703 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3707 if(!strcmp(arg, "vcd")) {
3709 opt_video_codec("mpeg1video");
3710 opt_audio_codec("mp2");
3713 opt_frame_size(norm ? "352x240" : "352x288");
3715 video_bit_rate = 1150000;
3716 video_rc_max_rate = 1150000;
3717 video_rc_min_rate = 1150000;
3718 video_rc_buffer_size = 40*1024*8;
3720 audio_bit_rate = 224000;
3721 audio_sample_rate = 44100;
3723 mux_packet_size= 2324;
3724 mux_rate= 2352 * 75 * 8;
3726 /* We have to offset the PTS, so that it is consistent with the SCR.
3727 SCR starts at 36000, but the first two packs contain only padding
3728 and the first pack from the other stream, respectively, may also have
3729 been written before.
3730 So the real data starts at SCR 36000+3*1200. */
3731 mux_preload= (36000+3*1200) / 90000.0; //0.44
3732 } else if(!strcmp(arg, "svcd")) {
3734 opt_video_codec("mpeg2video");
3735 opt_audio_codec("mp2");
3738 opt_frame_size(norm ? "480x480" : "480x576");
3739 opt_gop_size(norm ? "18" : "15");
3741 video_bit_rate = 2040000;
3742 video_rc_max_rate = 2516000;
3743 video_rc_min_rate = 0; //1145000;
3744 video_rc_buffer_size = 224*1024*8;
3745 use_scan_offset = 1;
3747 audio_bit_rate = 224000;
3748 audio_sample_rate = 44100;
3750 mux_packet_size= 2324;
3752 } else if(!strcmp(arg, "dvd")) {
3754 opt_video_codec("mpeg2video");
3755 opt_audio_codec("ac3");
3758 opt_frame_size(norm ? "720x480" : "720x576");
3759 opt_gop_size(norm ? "18" : "15");
3761 video_bit_rate = 6000000;
3762 video_rc_max_rate = 9000000;
3763 video_rc_min_rate = 0; //1500000;
3764 video_rc_buffer_size = 224*1024*8;
3766 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3767 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3769 audio_bit_rate = 448000;
3770 audio_sample_rate = 48000;
3773 fprintf(stderr, "Unknown target: %s\n", arg);
3778 static void show_version(void)
3780 printf("ffmpeg " FFMPEG_VERSION "\n"
3783 avcodec_build(), LIBAVFORMAT_BUILD);
3787 const OptionDef options[] = {
3789 { "L", 0, {(void*)show_license}, "show license" },
3790 { "h", 0, {(void*)show_help}, "show help" },
3791 { "version", 0, {(void*)show_version}, "show version" },
3792 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3793 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3794 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3795 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3796 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3797 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream" },
3798 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3799 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3800 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3801 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3802 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3803 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3804 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3805 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3806 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3807 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
3808 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
3809 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3810 "add timings for benchmarking" },
3811 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3812 "dump each input packet" },
3813 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3814 "when dumping packets, also dump the payload" },
3815 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
3816 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3817 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3818 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3819 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3820 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3821 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3822 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3823 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3826 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3827 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3828 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3829 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3830 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3831 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3832 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3833 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3834 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3835 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3836 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3837 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3838 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3839 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3840 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
3841 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3842 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3843 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
3844 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
3845 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
3846 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
3847 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
3848 { "mbqmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmin}, "min macroblock quantiser scale (VBR)", "q" },
3849 { "mbqmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_qmax}, "max macroblock quantiser scale (VBR)", "q" },
3850 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
3851 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
3852 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
3853 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
3854 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
3855 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
3856 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
3857 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
3858 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
3859 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
3860 // { "b_strategy", HAS_ARG | OPT_EXPERT, {(void*)opt_b_strategy}, "dynamic b frame selection strategy", "strategy" },
3861 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
3862 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3863 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
3864 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
3865 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
3866 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
3867 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3868 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
3870 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
3871 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
3872 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
3873 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
3874 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
3875 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
3876 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
3877 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
3878 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
3879 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
3880 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
3881 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
3882 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
3883 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
3884 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
3885 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
3886 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
3887 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
3888 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
3889 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
3890 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
3891 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
3892 { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
3893 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
3894 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
3895 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
3896 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
3897 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
3898 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3899 "use same video quality as source (implies VBR)" },
3900 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3901 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
3902 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3903 "deinterlace pictures" },
3904 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
3905 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
3906 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
3907 "force interlaced me support in encoder (MPEG2/MPEG4)" },
3908 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3909 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
3910 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
3911 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
3912 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
3913 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
3914 { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
3915 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
3916 { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
3917 { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
3918 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
3919 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
3920 { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
3921 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
3922 { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
3923 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3924 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3925 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3926 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
3927 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
3928 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
3929 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
3930 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3931 { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
3932 { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
3933 { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
3934 { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
3935 { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
3936 { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
3937 { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
3938 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
3939 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3942 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
3943 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3944 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3945 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3946 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3947 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3950 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
3951 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3952 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3953 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
3955 /* G.2 grab options */
3956 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
3957 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
3960 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
3961 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
3962 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3963 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3967 static void show_banner(void)
3969 printf("ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
3971 printf(" configuration: %s\n", FFMPEG_CONFIGURATION);
3972 printf(" built on " __DATE__ " " __TIME__);
3974 printf(", gcc: %s\n", __VERSION__);
3976 printf(", using a non-gcc compiler\n");
3980 static void show_license(void)
3985 "This program is free software; you can redistribute it and/or modify\n"
3986 "it under the terms of the GNU General Public License as published by\n"
3987 "the Free Software Foundation; either version 2 of the License, or\n"
3988 "(at your option) any later version.\n"
3990 "This program is distributed in the hope that it will be useful,\n"
3991 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
3992 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
3993 "GNU General Public License for more details.\n"
3995 "You should have received a copy of the GNU General Public License\n"
3996 "along with this program; if not, write to the Free Software\n"
3997 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4001 "This library is free software; you can redistribute it and/or\n"
4002 "modify it under the terms of the GNU Lesser General Public\n"
4003 "License as published by the Free Software Foundation; either\n"
4004 "version 2 of the License, or (at your option) any later version.\n"
4006 "This library is distributed in the hope that it will be useful,\n"
4007 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4008 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4009 "Lesser General Public License for more details.\n"
4011 "You should have received a copy of the GNU Lesser General Public\n"
4012 "License along with this library; if not, write to the Free Software\n"
4013 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4019 static void show_help(void)
4022 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4023 "Hyper fast Audio and Video encoder\n");
4025 show_help_options(options, "Main options:\n",
4026 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4027 show_help_options(options, "\nVideo options:\n",
4028 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4030 show_help_options(options, "\nAdvanced Video options:\n",
4031 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4032 OPT_VIDEO | OPT_EXPERT);
4033 show_help_options(options, "\nAudio options:\n",
4034 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4036 show_help_options(options, "\nAdvanced Audio options:\n",
4037 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4038 OPT_AUDIO | OPT_EXPERT);
4039 show_help_options(options, "\nAudio/Video grab options:\n",
4042 show_help_options(options, "\nAdvanced options:\n",
4043 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4048 void parse_arg_file(const char *filename)
4050 opt_output_file(filename);
4053 int main(int argc, char **argv)
4066 parse_options(argc, argv, options);
4068 /* file converter / grab */
4069 if (nb_output_files <= 0) {
4070 fprintf(stderr, "Must supply at least one output file\n");
4074 if (nb_input_files == 0) {
4080 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4081 stream_maps, nb_stream_maps);
4082 ti = getutime() - ti;
4084 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4088 for(i=0;i<nb_output_files;i++) {
4089 /* maybe av_close_output_file ??? */
4090 AVFormatContext *s = output_files[i];
4092 if (!(s->oformat->flags & AVFMT_NOFILE))
4094 for(j=0;j<s->nb_streams;j++)
4095 av_free(s->streams[j]);
4098 for(i=0;i<nb_input_files;i++)
4099 av_close_input_file(input_files[i]);
4104 av_free(intra_matrix);
4106 av_free(inter_matrix);
4108 #ifdef POWERPC_PERFORMANCE_REPORT
4109 extern void powerpc_display_perf_report(void);
4110 powerpc_display_perf_report();
4111 #endif /* POWERPC_PERFORMANCE_REPORT */
4113 #ifndef CONFIG_WIN32
4114 if (received_sigterm) {
4116 "Received signal %d: terminating.\n",
4117 (int) received_sigterm);
4121 exit(0); /* not all OS-es handle main() return value */