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 {
56 int sync_stream_index;
59 /** select an input file for an output file */
60 typedef struct AVMetaDataMap {
65 extern const OptionDef options[];
67 static void show_help(void);
68 static void show_license(void);
72 static AVFormatContext *input_files[MAX_FILES];
73 static int64_t input_files_ts_offset[MAX_FILES];
74 static int nb_input_files = 0;
76 static AVFormatContext *output_files[MAX_FILES];
77 static int nb_output_files = 0;
79 static AVStreamMap stream_maps[MAX_FILES];
80 static int nb_stream_maps;
82 static AVMetaDataMap meta_data_maps[MAX_FILES];
83 static int nb_meta_data_maps;
85 static AVInputFormat *file_iformat;
86 static AVOutputFormat *file_oformat;
87 static AVImageFormat *image_format;
88 static int frame_width = 0;
89 static int frame_height = 0;
90 static float frame_aspect_ratio = 0;
91 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
92 static int frame_padtop = 0;
93 static int frame_padbottom = 0;
94 static int frame_padleft = 0;
95 static int frame_padright = 0;
96 static int padcolor[3] = {16,128,128}; /* default to black */
97 static int frame_topBand = 0;
98 static int frame_bottomBand = 0;
99 static int frame_leftBand = 0;
100 static int frame_rightBand = 0;
101 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
102 static int frame_rate = 25;
103 static int frame_rate_base = 1;
104 static int video_bit_rate = 200*1000;
105 static int video_bit_rate_tolerance = 4000*1000;
106 static float video_qscale = 0;
107 static int video_qmin = 2;
108 static int video_qmax = 31;
109 static int video_lmin = 2*FF_QP2LAMBDA;
110 static int video_lmax = 31*FF_QP2LAMBDA;
111 static int video_mb_lmin = 2*FF_QP2LAMBDA;
112 static int video_mb_lmax = 31*FF_QP2LAMBDA;
113 static int video_qdiff = 3;
114 static int video_lelim = 0;
115 static int video_celim = 0;
116 static float video_qblur = 0.5;
117 static float video_qsquish = 0.0;
118 static float video_qcomp = 0.5;
119 static uint16_t *intra_matrix = NULL;
120 static uint16_t *inter_matrix = NULL;
121 #if 0 //experimental, (can be removed)
122 static float video_rc_qsquish=1.0;
123 static float video_rc_qmod_amp=0;
124 static int video_rc_qmod_freq=0;
126 static char *video_rc_override_string=NULL;
127 static char *video_rc_eq="tex^qComp";
128 static int video_rc_buffer_size=0;
129 static float video_rc_buffer_aggressivity=1.0;
130 static int video_rc_max_rate=0;
131 static int video_rc_min_rate=0;
132 static float video_rc_initial_cplx=0;
133 static float video_b_qfactor = 1.25;
134 static float video_b_qoffset = 1.25;
135 static float video_i_qfactor = -0.8;
136 static float video_i_qoffset = 0.0;
137 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
138 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
139 static int me_method = ME_EPZS;
140 static int video_disable = 0;
141 static int video_discard = 0;
142 static int video_codec_id = CODEC_ID_NONE;
143 static int video_codec_tag = 0;
144 static int same_quality = 0;
145 static int b_frames = 0;
146 static int b_strategy = 0;
147 static int mb_decision = FF_MB_DECISION_SIMPLE;
148 static int ildct_cmp = FF_CMP_VSAD;
149 static int mb_cmp = FF_CMP_SAD;
150 static int sub_cmp = FF_CMP_SAD;
151 static int cmp = FF_CMP_SAD;
152 static int pre_cmp = FF_CMP_SAD;
153 static int pre_me = 0;
154 static float lumi_mask = 0;
155 static float dark_mask = 0;
156 static float scplx_mask = 0;
157 static float tcplx_mask = 0;
158 static float p_mask = 0;
159 static int use_4mv = 0;
160 static int use_obmc = 0;
161 static int use_loop = 0;
162 static int use_aic = 0;
163 static int use_aiv = 0;
164 static int use_umv = 0;
165 static int use_ss = 0;
166 static int use_alt_scan = 0;
167 static int use_trell = 0;
168 static int use_scan_offset = 0;
169 static int use_qpel = 0;
170 static int use_qprd = 0;
171 static int use_cbprd = 0;
172 static int use_mv0 = 0;
173 static int do_normalize_aqp = 0;
175 static int closed_gop = 0;
176 static int strict_gop = 0;
177 static int no_output = 0;
178 static int do_deinterlace = 0;
179 static int do_interlace_dct = 0;
180 static int do_interlace_me = 0;
181 static int workaround_bugs = FF_BUG_AUTODETECT;
182 static int error_resilience = FF_ER_CAREFULL;
183 static int error_concealment = 3;
184 static int dct_algo = 0;
185 static int idct_algo = 0;
186 static int use_part = 0;
187 static int packet_size = 0;
188 static int error_rate = 0;
189 static int strict = 0;
190 static int top_field_first = -1;
191 static int noise_reduction = 0;
192 static int sc_threshold = 0;
193 static int debug = 0;
194 static int debug_mv = 0;
195 static int me_threshold = 0;
196 static int mb_threshold = 0;
197 static int intra_dc_precision = 8;
198 static int coder = 0;
199 static int context = 0;
200 static int predictor = 0;
201 static int video_profile = FF_PROFILE_UNKNOWN;
202 static int video_level = FF_LEVEL_UNKNOWN;
203 static int nsse_weight = 8;
204 static int subpel_quality= 8;
205 static int me_penalty_compensation= 256;
206 static int lowres= 0;
207 static int frame_skip_threshold= 0;
208 static int frame_skip_factor= 0;
209 static int frame_skip_exp= 0;
210 static int frame_skip_cmp= FF_CMP_DCTMAX;
211 extern int loop_input; /* currently a hack */
212 static int loop_output = AVFMT_NOOUTPUTLOOP;
213 static int gray_only = 0;
215 static int gop_size = 12;
216 static int intra_only = 0;
217 static int audio_sample_rate = 44100;
218 static int audio_bit_rate = 64000;
219 static int audio_disable = 0;
220 static int audio_channels = 1;
221 static int audio_codec_id = CODEC_ID_NONE;
222 static int audio_codec_tag = 0;
223 static char *audio_language = NULL;
225 static int subtitle_codec_id = CODEC_ID_NONE;
226 static char *subtitle_language = NULL;
228 static int mux_rate= 0;
229 static int mux_packet_size= 0;
230 static float mux_preload= 0.5;
231 static float mux_max_delay= 0.7;
233 static int64_t recording_time = 0;
234 static int64_t start_time = 0;
235 static int64_t rec_timestamp = 0;
236 static int64_t input_ts_offset = 0;
237 static int file_overwrite = 0;
238 static char *str_title = NULL;
239 static char *str_author = NULL;
240 static char *str_copyright = NULL;
241 static char *str_comment = NULL;
242 static int do_benchmark = 0;
243 static int do_hex_dump = 0;
244 static int do_pkt_dump = 0;
245 static int do_psnr = 0;
246 static int do_vstats = 0;
247 static int do_pass = 0;
248 static int bitexact = 0;
249 static char *pass_logfilename = NULL;
250 static int audio_stream_copy = 0;
251 static int video_stream_copy = 0;
252 static int subtitle_stream_copy = 0;
253 static int video_sync_method= 1;
254 static int audio_sync_method= 0;
255 static int copy_ts= 0;
256 static int opt_shortest = 0; //
257 static int video_global_header = 0;
259 static int rate_emu = 0;
262 static char *video_grab_format = "bktr";
264 static char *video_grab_format = "video4linux";
266 static char *video_device = NULL;
267 static char *grab_device = NULL;
268 static int video_channel = 0;
269 static char *video_standard = "ntsc";
271 static char *audio_grab_format = "audio_device";
272 static char *audio_device = NULL;
273 static int audio_volume = 256;
275 static int using_stdin = 0;
276 static int using_vhook = 0;
277 static int verbose = 1;
278 static int thread_count= 1;
279 static int q_pressed = 0;
280 static int me_range = 0;
281 static int64_t video_size = 0;
282 static int64_t audio_size = 0;
283 static int64_t extra_size = 0;
284 static int nb_frames_dup = 0;
285 static int nb_frames_drop = 0;
286 static int input_sync;
287 static int limit_filesize = 0; //
289 static int pgmyuv_compatibility_hack=0;
292 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
294 struct AVInputStream;
296 typedef struct AVOutputStream {
297 int file_index; /* file index */
298 int index; /* stream index in the output file */
299 int source_index; /* AVInputStream index */
300 AVStream *st; /* stream in the output file */
301 int encoding_needed; /* true if encoding needed for this stream */
303 /* input pts and corresponding output pts
305 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
306 struct AVInputStream *sync_ist; /* input stream to sync against */
307 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
309 int video_resample; /* video_resample and video_crop are mutually exclusive */
310 AVFrame pict_tmp; /* temporary image for resampling */
311 ImgReSampleContext *img_resample_ctx; /* for image resampling */
313 int video_crop; /* video_resample and video_crop are mutually exclusive */
314 int topBand; /* cropping area sizes */
317 int video_pad; /* video_resample and video_pad are mutually exclusive */
318 int padtop; /* padding area sizes */
325 ReSampleContext *resample; /* for audio resampling */
326 FifoBuffer fifo; /* for compression: one audio fifo per codec */
330 typedef struct AVInputStream {
334 int discard; /* true if stream data should be discarded */
335 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
336 int64_t sample_index; /* current sample */
338 int64_t start; /* time when read started */
339 unsigned long frame; /* current frame */
340 int64_t next_pts; /* synthetic pts for cases where pkt.pts
342 int64_t pts; /* current pts */
343 int is_start; /* is 1 at the start and after a discontinuity */
346 typedef struct AVInputFile {
347 int eof_reached; /* true if eof reached */
348 int ist_index; /* index of first stream in ist_table */
349 int buffer_size; /* current total buffer size */
350 int buffer_size_max; /* buffer size at which we consider we can stop
352 int nb_streams; /* nb streams we are aware of */
357 /* init terminal so that we can grab keys */
358 static struct termios oldtty;
360 static void term_exit(void)
362 tcsetattr (0, TCSANOW, &oldtty);
365 static volatile sig_atomic_t received_sigterm = 0;
368 sigterm_handler(int sig)
370 received_sigterm = sig;
374 static void term_init(void)
381 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
382 |INLCR|IGNCR|ICRNL|IXON);
383 tty.c_oflag |= OPOST;
384 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
385 tty.c_cflag &= ~(CSIZE|PARENB);
390 tcsetattr (0, TCSANOW, &tty);
392 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
393 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
394 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
396 register a function to be called at normal program termination
399 #ifdef CONFIG_BEOS_NETSERVER
400 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
404 /* read a key without blocking */
405 static int read_key(void)
409 #ifndef CONFIG_BEOS_NETSERVER
417 n = select(1, &rfds, NULL, NULL, &tv);
429 static int decode_interrupt_cb(void)
431 return q_pressed || (q_pressed = read_key() == 'q');
436 static volatile int received_sigterm = 0;
438 /* no interactive support */
439 static void term_exit(void)
443 static void term_init(void)
447 static int read_key(void)
454 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
459 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
462 /* copy stream format */
463 s->nb_streams = ic->nb_streams;
464 for(i=0;i<ic->nb_streams;i++) {
467 st = av_mallocz(sizeof(AVStream));
468 memcpy(st, ic->streams[i], sizeof(AVStream));
472 av_close_input_file(ic);
477 get_sync_ipts(const AVOutputStream *ost)
479 const AVInputStream *ist = ost->sync_ist;
480 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
483 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
485 static void do_audio_out(AVFormatContext *s,
488 unsigned char *buf, int size)
491 static uint8_t *audio_buf = NULL;
492 static uint8_t *audio_out = NULL;
493 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
495 int size_out, frame_bytes, ret;
496 AVCodecContext *enc= &ost->st->codec;
498 /* SC: dynamic allocation of buffers */
500 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
502 audio_out = av_malloc(audio_out_size);
503 if (!audio_buf || !audio_out)
504 return; /* Should signal an error ! */
506 if(audio_sync_method){
507 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
508 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2);
509 double idelta= delta*ist->st->codec.sample_rate / enc->sample_rate;
510 int byte_delta= ((int)idelta)*2*ist->st->codec.channels;
512 //FIXME resample delay
513 if(fabs(delta) > 50){
516 byte_delta= FFMAX(byte_delta, -size);
520 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
525 static uint8_t *input_tmp= NULL;
526 input_tmp= av_realloc(input_tmp, byte_delta + size);
528 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
531 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
533 memset(input_tmp, 0, byte_delta);
534 memcpy(input_tmp + byte_delta, buf, size);
538 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
540 }else if(audio_sync_method>1){
541 int comp= clip(delta, -audio_sync_method, audio_sync_method);
542 assert(ost->audio_resample);
544 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
545 // fprintf(stderr, "drift:%f len:%d opts:%lld ipts:%lld fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2));
546 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
550 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
551 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec.channels * 2); //FIXME wrong
553 if (ost->audio_resample) {
555 size_out = audio_resample(ost->resample,
556 (short *)buftmp, (short *)buf,
557 size / (ist->st->codec.channels * 2));
558 size_out = size_out * enc->channels * 2;
564 /* now encode as many frames as possible */
565 if (enc->frame_size > 1) {
566 /* output resampled raw samples */
567 fifo_write(&ost->fifo, buftmp, size_out,
570 frame_bytes = enc->frame_size * 2 * enc->channels;
572 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
573 &ost->fifo.rptr) == 0) {
575 av_init_packet(&pkt);
577 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
580 pkt.stream_index= ost->index;
584 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
585 pkt.flags |= PKT_FLAG_KEY;
586 av_interleaved_write_frame(s, &pkt);
588 ost->sync_opts += enc->frame_size;
592 av_init_packet(&pkt);
594 ost->sync_opts += size_out / (2 * enc->channels);
596 /* output a pcm frame */
597 /* XXX: change encoding codec API to avoid this ? */
598 switch(enc->codec->id) {
599 case CODEC_ID_PCM_S16LE:
600 case CODEC_ID_PCM_S16BE:
601 case CODEC_ID_PCM_U16LE:
602 case CODEC_ID_PCM_U16BE:
605 size_out = size_out >> 1;
608 ret = avcodec_encode_audio(enc, audio_out, size_out,
611 pkt.stream_index= ost->index;
615 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
616 pkt.flags |= PKT_FLAG_KEY;
617 av_interleaved_write_frame(s, &pkt);
621 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
625 AVPicture picture_tmp;
628 dec = &ist->st->codec;
630 /* deinterlace : must be done before any resize */
631 if (do_deinterlace || using_vhook) {
634 /* create temporary picture */
635 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
636 buf = av_malloc(size);
640 picture2 = &picture_tmp;
641 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
644 if(avpicture_deinterlace(picture2, picture,
645 dec->pix_fmt, dec->width, dec->height) < 0) {
646 /* if error, do not deinterlace */
652 if (img_convert(picture2, dec->pix_fmt, picture,
653 dec->pix_fmt, dec->width, dec->height) < 0) {
654 /* if error, do not copy */
664 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
666 if (picture != picture2)
667 *picture = *picture2;
671 /* we begin to correct av delay at this threshold */
672 #define AV_DELAY_MAX 0.100
675 /* Expects img to be yuv420 */
676 static void fill_pad_region(AVPicture* img, int height, int width,
677 int padtop, int padbottom, int padleft, int padright, int *color) {
682 for (i = 0; i < 3; i++) {
683 shift = (i == 0) ? 0 : 1;
685 if (padtop || padleft) {
686 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
690 if (padleft || padright) {
691 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
692 (img->linesize[i] - (padright >> shift));
694 for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
695 memset(optr, color[i], (padleft + padright) >> shift);
696 optr += img->linesize[i];
700 if (padbottom || padright) {
701 optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
702 memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
707 static void do_subtitle_out(AVFormatContext *s,
713 static uint8_t *subtitle_out = NULL;
714 int subtitle_out_max_size = 65536;
715 int subtitle_out_size, nb, i;
719 if (pts == AV_NOPTS_VALUE) {
720 fprintf(stderr, "Subtitle packets must have a pts\n");
724 enc = &ost->st->codec;
727 subtitle_out = av_malloc(subtitle_out_max_size);
730 /* Note: DVB subtitle need one packet to draw them and one other
731 packet to clear them */
732 /* XXX: signal it in the codec context ? */
733 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
738 for(i = 0; i < nb; i++) {
739 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
740 subtitle_out_max_size, sub);
742 av_init_packet(&pkt);
743 pkt.stream_index = ost->index;
744 pkt.data = subtitle_out;
745 pkt.size = subtitle_out_size;
746 pkt.pts = av_rescale_q(av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
747 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
748 /* XXX: the pts correction is handled here. Maybe handling
749 it in the codec would be better */
751 pkt.pts += 90 * sub->start_display_time;
753 pkt.pts += 90 * sub->end_display_time;
755 av_interleaved_write_frame(s, &pkt);
759 static int bit_buffer_size= 1024*256;
760 static uint8_t *bit_buffer= NULL;
762 static void do_video_out(AVFormatContext *s,
768 int nb_frames, i, ret;
769 AVFrame *final_picture, *formatted_picture;
770 AVFrame picture_format_temp, picture_crop_temp;
771 uint8_t *buf = NULL, *buf1 = NULL;
772 AVCodecContext *enc, *dec;
773 enum PixelFormat target_pixfmt;
775 avcodec_get_frame_defaults(&picture_format_temp);
776 avcodec_get_frame_defaults(&picture_crop_temp);
778 enc = &ost->st->codec;
779 dec = &ist->st->codec;
781 /* by default, we output a single frame */
786 if(video_sync_method){
788 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
789 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
792 else if (vdelta > 1.1)
793 nb_frames = lrintf(vdelta);
794 //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);
798 fprintf(stderr, "*** drop!\n");
799 }else if (nb_frames > 1) {
800 nb_frames_dup += nb_frames;
802 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
805 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
807 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
811 /* convert pixel format if needed */
812 target_pixfmt = ost->video_resample || ost->video_pad
813 ? PIX_FMT_YUV420P : enc->pix_fmt;
814 if (dec->pix_fmt != target_pixfmt) {
817 /* create temporary picture */
818 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
819 buf = av_malloc(size);
822 formatted_picture = &picture_format_temp;
823 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
825 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
826 (AVPicture *)in_picture, dec->pix_fmt,
827 dec->width, dec->height) < 0) {
830 fprintf(stderr, "pixel format conversion not handled\n");
835 formatted_picture = in_picture;
838 /* XXX: resampling could be done before raw format conversion in
839 some cases to go faster */
840 /* XXX: only works for YUV420P */
841 if (ost->video_resample) {
842 final_picture = &ost->pict_tmp;
843 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
845 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
846 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
847 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
851 if (enc->pix_fmt != PIX_FMT_YUV420P) {
855 /* create temporary picture */
856 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
857 buf = av_malloc(size);
860 final_picture = &picture_format_temp;
861 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
863 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
864 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
865 enc->width, enc->height) < 0) {
868 fprintf(stderr, "pixel format conversion not handled\n");
873 } else if (ost->video_crop) {
874 picture_crop_temp.data[0] = formatted_picture->data[0] +
875 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
877 picture_crop_temp.data[1] = formatted_picture->data[1] +
878 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
879 (ost->leftBand >> 1);
881 picture_crop_temp.data[2] = formatted_picture->data[2] +
882 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
883 (ost->leftBand >> 1);
885 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
886 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
887 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
888 final_picture = &picture_crop_temp;
889 } else if (ost->video_pad) {
890 final_picture = &ost->pict_tmp;
892 for (i = 0; i < 3; i++) {
893 uint8_t *optr, *iptr;
894 int shift = (i == 0) ? 0 : 1;
897 /* set offset to start writing image into */
898 optr = final_picture->data[i] + (((final_picture->linesize[i] *
899 ost->padtop) + ost->padleft) >> shift);
900 iptr = formatted_picture->data[i];
902 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
903 for (y = 0; y < yheight; y++) {
904 /* copy unpadded image row into padded image row */
905 memcpy(optr, iptr, formatted_picture->linesize[i]);
906 optr += final_picture->linesize[i];
907 iptr += formatted_picture->linesize[i];
911 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
912 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
915 if (enc->pix_fmt != PIX_FMT_YUV420P) {
919 /* create temporary picture */
920 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
921 buf = av_malloc(size);
924 final_picture = &picture_format_temp;
925 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
927 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
928 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
929 enc->width, enc->height) < 0) {
932 fprintf(stderr, "pixel format conversion not handled\n");
938 final_picture = formatted_picture;
940 /* duplicates frame if needed */
941 for(i=0;i<nb_frames;i++) {
943 av_init_packet(&pkt);
944 pkt.stream_index= ost->index;
946 if (s->oformat->flags & AVFMT_RAWPICTURE) {
947 /* raw pictures are written as AVPicture structure to
948 avoid any copies. We support temorarily the older
950 AVFrame* old_frame = enc->coded_frame;
951 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
952 pkt.data= (uint8_t *)final_picture;
953 pkt.size= sizeof(AVPicture);
955 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
956 if(dec->coded_frame && dec->coded_frame->key_frame)
957 pkt.flags |= PKT_FLAG_KEY;
959 av_interleaved_write_frame(s, &pkt);
960 enc->coded_frame = old_frame;
964 big_picture= *final_picture;
965 /* better than nothing: use input picture interlaced
967 big_picture.interlaced_frame = in_picture->interlaced_frame;
968 if(do_interlace_me || do_interlace_dct){
969 if(top_field_first == -1)
970 big_picture.top_field_first = in_picture->top_field_first;
972 big_picture.top_field_first = top_field_first;
975 /* handles sameq here. This is not correct because it may
976 not be a global option */
978 big_picture.quality = ist->st->quality;
980 big_picture.quality = ost->st->quality;
982 big_picture.pict_type = 0;
983 // big_picture.pts = AV_NOPTS_VALUE;
984 big_picture.pts= ost->sync_opts;
985 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
986 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
987 ret = avcodec_encode_video(enc,
988 bit_buffer, bit_buffer_size,
990 //enc->frame_number = enc->real_pict_num;
992 pkt.data= bit_buffer;
995 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
996 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
997 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
998 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1000 if(enc->coded_frame && enc->coded_frame->key_frame)
1001 pkt.flags |= PKT_FLAG_KEY;
1002 av_interleaved_write_frame(s, &pkt);
1004 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
1005 // enc->frame_number-1, enc->real_pict_num, ret,
1007 /* if two pass, output log */
1008 if (ost->logfile && enc->stats_out) {
1009 fprintf(ost->logfile, "%s", enc->stats_out);
1014 ost->frame_number++;
1021 static double psnr(double d){
1022 if(d==0) return INFINITY;
1023 return -10.0*log(d)/log(10.0);
1026 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1029 static FILE *fvstats=NULL;
1033 AVCodecContext *enc;
1036 double ti1, bitrate, avg_bitrate;
1039 today2 = time(NULL);
1040 today = localtime(&today2);
1041 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
1044 fvstats = fopen(filename,"w");
1052 enc = &ost->st->codec;
1053 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1054 frame_number = ost->frame_number;
1055 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1056 if (enc->flags&CODEC_FLAG_PSNR)
1057 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1059 fprintf(fvstats,"f_size= %6d ", frame_size);
1060 /* compute pts value */
1061 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1065 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1066 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1067 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1068 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1069 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1073 static void print_report(AVFormatContext **output_files,
1074 AVOutputStream **ost_table, int nb_ostreams,
1078 AVOutputStream *ost;
1079 AVFormatContext *oc, *os;
1081 AVCodecContext *enc;
1082 int frame_number, vid, i;
1083 double bitrate, ti1, pts;
1084 static int64_t last_time = -1;
1086 if (!is_last_report) {
1088 /* display the report every 0.5 seconds */
1089 cur_time = av_gettime();
1090 if (last_time == -1) {
1091 last_time = cur_time;
1094 if ((cur_time - last_time) < 500000)
1096 last_time = cur_time;
1100 oc = output_files[0];
1102 total_size = url_ftell(&oc->pb);
1107 for(i=0;i<nb_ostreams;i++) {
1109 os = output_files[ost->file_index];
1110 enc = &ost->st->codec;
1111 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1112 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1113 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1115 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1116 frame_number = ost->frame_number;
1117 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%2.1f ",
1118 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1120 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1121 if (enc->flags&CODEC_FLAG_PSNR){
1123 double error, error_sum=0;
1124 double scale, scale_sum=0;
1125 char type[3]= {'Y','U','V'};
1126 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1129 error= enc->error[j];
1130 scale= enc->width*enc->height*255.0*255.0*frame_number;
1132 error= enc->coded_frame->error[j];
1133 scale= enc->width*enc->height*255.0*255.0;
1138 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1140 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1144 /* compute min output value */
1145 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1146 if ((pts < ti1) && (pts > 0))
1152 if (verbose || is_last_report) {
1153 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1155 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1156 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1157 (double)total_size / 1024, ti1, bitrate);
1160 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1161 nb_frames_dup, nb_frames_drop);
1164 fprintf(stderr, "%s \r", buf);
1169 if (is_last_report && verbose >= 0){
1170 int64_t raw= audio_size + video_size + extra_size;
1171 fprintf(stderr, "\n");
1172 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1176 100.0*(total_size - raw)/raw
1181 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1182 static int output_packet(AVInputStream *ist, int ist_index,
1183 AVOutputStream **ost_table, int nb_ostreams,
1184 const AVPacket *pkt)
1186 AVFormatContext *os;
1187 AVOutputStream *ost;
1191 int data_size, got_picture;
1193 void *buffer_to_free;
1194 static int samples_size= 0;
1195 static short *samples= NULL;
1196 AVSubtitle subtitle, *subtitle_to_free;
1200 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1201 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1202 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1204 // assert(ist->pts == ist->next_pts);
1218 /* decode the packet if needed */
1219 data_buf = NULL; /* fail safe */
1221 subtitle_to_free = NULL;
1222 if (ist->decoding_needed) {
1223 switch(ist->st->codec.codec_type) {
1224 case CODEC_TYPE_AUDIO:{
1226 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1227 /* XXX: could avoid copy if PCM 16 bits with same
1228 endianness as CPU */
1229 ret = avcodec_decode_audio(&ist->st->codec, samples, &data_size,
1235 /* Some bug in mpeg audio decoder gives */
1236 /* data_size < 0, it seems they are overflows */
1237 if (data_size <= 0) {
1238 /* no audio frame */
1241 data_buf = (uint8_t *)samples;
1242 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1243 (ist->st->codec.sample_rate * ist->st->codec.channels);
1245 case CODEC_TYPE_VIDEO:
1246 data_size = (ist->st->codec.width * ist->st->codec.height * 3) / 2;
1247 /* XXX: allocate picture correctly */
1248 avcodec_get_frame_defaults(&picture);
1250 ret = avcodec_decode_video(&ist->st->codec,
1251 &picture, &got_picture, ptr, len);
1252 ist->st->quality= picture.quality;
1256 /* no picture yet */
1257 goto discard_packet;
1259 if (ist->st->codec.time_base.num != 0) {
1260 ist->next_pts += ((int64_t)AV_TIME_BASE *
1261 ist->st->codec.time_base.num) /
1262 ist->st->codec.time_base.den;
1266 case CODEC_TYPE_SUBTITLE:
1267 ret = avcodec_decode_subtitle(&ist->st->codec,
1268 &subtitle, &got_subtitle, ptr, len);
1271 if (!got_subtitle) {
1272 goto discard_packet;
1274 subtitle_to_free = &subtitle;
1281 switch(ist->st->codec.codec_type) {
1282 case CODEC_TYPE_AUDIO:
1283 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec.frame_size) /
1284 (ist->st->codec.sample_rate * ist->st->codec.channels);
1286 case CODEC_TYPE_VIDEO:
1287 if (ist->st->codec.time_base.num != 0) {
1288 ist->next_pts += ((int64_t)AV_TIME_BASE *
1289 ist->st->codec.time_base.num) /
1290 ist->st->codec.time_base.den;
1300 buffer_to_free = NULL;
1301 if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1302 pre_process_video_frame(ist, (AVPicture *)&picture,
1306 // preprocess audio (volume)
1307 if (ist->st->codec.codec_type == CODEC_TYPE_AUDIO) {
1308 if (audio_volume != 256) {
1311 for(i=0;i<(data_size / sizeof(short));i++) {
1312 int v = ((*volp) * audio_volume + 128) >> 8;
1313 if (v < -32768) v = -32768;
1314 if (v > 32767) v = 32767;
1320 /* frame rate emulation */
1321 if (ist->st->codec.rate_emu) {
1322 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec.time_base.num, 1000000, ist->st->codec.time_base.den);
1323 int64_t now = av_gettime() - ist->start;
1331 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1332 is the one of the next displayed one */
1333 /* XXX: add mpeg4 too ? */
1334 if (ist->st->codec.codec_id == CODEC_ID_MPEG1VIDEO) {
1335 if (ist->st->codec.pict_type != B_TYPE) {
1337 tmp = ist->last_ip_pts;
1338 ist->last_ip_pts = ist->frac_pts.val;
1339 ist->frac_pts.val = tmp;
1343 /* if output time reached then transcode raw format,
1344 encode packets and output them */
1345 if (start_time == 0 || ist->pts >= start_time)
1346 for(i=0;i<nb_ostreams;i++) {
1350 if (ost->source_index == ist_index) {
1351 os = output_files[ost->file_index];
1354 printf("%d: got pts=%0.3f %0.3f\n", i,
1355 (double)pkt->pts / AV_TIME_BASE,
1356 ((double)ist->pts / AV_TIME_BASE) -
1357 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1359 /* set the input output pts pairs */
1360 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1362 if (ost->encoding_needed) {
1363 switch(ost->st->codec.codec_type) {
1364 case CODEC_TYPE_AUDIO:
1365 do_audio_out(os, ost, ist, data_buf, data_size);
1367 case CODEC_TYPE_VIDEO:
1368 do_video_out(os, ost, ist, &picture, &frame_size);
1369 video_size += frame_size;
1370 if (do_vstats && frame_size)
1371 do_video_stats(os, ost, frame_size);
1373 case CODEC_TYPE_SUBTITLE:
1374 do_subtitle_out(os, ost, ist, &subtitle,
1381 AVFrame avframe; //FIXME/XXX remove this
1383 av_init_packet(&opkt);
1385 /* no reencoding needed : output the packet directly */
1386 /* force the input stream PTS */
1388 avcodec_get_frame_defaults(&avframe);
1389 ost->st->codec.coded_frame= &avframe;
1390 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1392 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO)
1393 audio_size += data_size;
1394 else if (ost->st->codec.codec_type == CODEC_TYPE_VIDEO) {
1395 video_size += data_size;
1399 opkt.stream_index= ost->index;
1400 if(pkt->pts != AV_NOPTS_VALUE)
1401 opkt.pts= av_rescale_q(av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q) + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1403 opkt.pts= AV_NOPTS_VALUE;
1407 if (pkt->dts == AV_NOPTS_VALUE)
1408 dts = ist->next_pts;
1410 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1411 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1413 opkt.flags= pkt->flags;
1414 if(av_parser_change(ist->st->parser, &ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1415 opkt.destruct= av_destruct_packet;
1416 av_interleaved_write_frame(os, &opkt);
1417 ost->st->codec.frame_number++;
1418 ost->frame_number++;
1419 av_free_packet(&opkt);
1423 av_free(buffer_to_free);
1424 /* XXX: allocate the subtitles in the codec ? */
1425 if (subtitle_to_free) {
1426 av_free(subtitle_to_free->bitmap);
1427 av_free(subtitle_to_free->rgba_palette);
1428 subtitle_to_free = NULL;
1435 for(i=0;i<nb_ostreams;i++) {
1437 if (ost->source_index == ist_index) {
1438 AVCodecContext *enc= &ost->st->codec;
1439 os = output_files[ost->file_index];
1441 if(ost->st->codec.codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1443 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1446 if (ost->encoding_needed) {
1449 av_init_packet(&pkt);
1450 pkt.stream_index= ost->index;
1452 switch(ost->st->codec.codec_type) {
1453 case CODEC_TYPE_AUDIO:
1454 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1456 pkt.flags |= PKT_FLAG_KEY;
1458 case CODEC_TYPE_VIDEO:
1459 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1461 if(enc->coded_frame && enc->coded_frame->key_frame)
1462 pkt.flags |= PKT_FLAG_KEY;
1463 if (ost->logfile && enc->stats_out) {
1464 fprintf(ost->logfile, "%s", enc->stats_out);
1473 pkt.data= bit_buffer;
1475 if(enc->coded_frame)
1476 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1477 av_interleaved_write_frame(os, &pkt);
1491 * The following code is the main loop of the file converter
1493 static int av_encode(AVFormatContext **output_files,
1494 int nb_output_files,
1495 AVFormatContext **input_files,
1497 AVStreamMap *stream_maps, int nb_stream_maps)
1499 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1500 AVFormatContext *is, *os;
1501 AVCodecContext *codec, *icodec;
1502 AVOutputStream *ost, **ost_table = NULL;
1503 AVInputStream *ist, **ist_table = NULL;
1504 AVInputFile *file_table;
1505 AVFormatContext *stream_no_data;
1508 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1512 /* input stream init */
1514 for(i=0;i<nb_input_files;i++) {
1515 is = input_files[i];
1516 file_table[i].ist_index = j;
1517 file_table[i].nb_streams = is->nb_streams;
1518 j += is->nb_streams;
1522 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1526 for(i=0;i<nb_istreams;i++) {
1527 ist = av_mallocz(sizeof(AVInputStream));
1533 for(i=0;i<nb_input_files;i++) {
1534 is = input_files[i];
1535 for(k=0;k<is->nb_streams;k++) {
1536 ist = ist_table[j++];
1537 ist->st = is->streams[k];
1538 ist->file_index = i;
1540 ist->discard = 1; /* the stream is discarded by default
1543 if (ist->st->codec.rate_emu) {
1544 ist->start = av_gettime();
1550 /* output stream init */
1552 for(i=0;i<nb_output_files;i++) {
1553 os = output_files[i];
1554 nb_ostreams += os->nb_streams;
1556 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1557 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1561 /* Sanity check the mapping args -- do the input files & streams exist? */
1562 for(i=0;i<nb_stream_maps;i++) {
1563 int fi = stream_maps[i].file_index;
1564 int si = stream_maps[i].stream_index;
1566 if (fi < 0 || fi > nb_input_files - 1 ||
1567 si < 0 || si > file_table[fi].nb_streams - 1) {
1568 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1571 fi = stream_maps[i].sync_file_index;
1572 si = stream_maps[i].sync_stream_index;
1573 if (fi < 0 || fi > nb_input_files - 1 ||
1574 si < 0 || si > file_table[fi].nb_streams - 1) {
1575 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1580 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1583 for(i=0;i<nb_ostreams;i++) {
1584 ost = av_mallocz(sizeof(AVOutputStream));
1591 for(k=0;k<nb_output_files;k++) {
1592 os = output_files[k];
1593 for(i=0;i<os->nb_streams;i++) {
1595 ost = ost_table[n++];
1596 ost->file_index = k;
1598 ost->st = os->streams[i];
1599 if (nb_stream_maps > 0) {
1600 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1601 stream_maps[n-1].stream_index;
1603 /* Sanity check that the stream types match */
1604 if (ist_table[ost->source_index]->st->codec.codec_type != ost->st->codec.codec_type) {
1605 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1606 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1607 ost->file_index, ost->index);
1612 /* get corresponding input stream index : we select the first one with the right type */
1614 for(j=0;j<nb_istreams;j++) {
1617 ist->st->codec.codec_type == ost->st->codec.codec_type) {
1618 ost->source_index = j;
1625 /* try again and reuse existing stream */
1626 for(j=0;j<nb_istreams;j++) {
1628 if (ist->st->codec.codec_type == ost->st->codec.codec_type) {
1629 ost->source_index = j;
1634 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1635 ost->file_index, ost->index);
1640 ist = ist_table[ost->source_index];
1642 ost->sync_ist = (nb_stream_maps > 0) ?
1643 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1644 stream_maps[n-1].sync_stream_index] : ist;
1648 /* for each output stream, we compute the right encoding parameters */
1649 for(i=0;i<nb_ostreams;i++) {
1651 ist = ist_table[ost->source_index];
1653 codec = &ost->st->codec;
1654 icodec = &ist->st->codec;
1656 if (ost->st->stream_copy) {
1657 /* if stream_copy is selected, no need to decode or encode */
1658 codec->codec_id = icodec->codec_id;
1659 codec->codec_type = icodec->codec_type;
1660 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1661 codec->bit_rate = icodec->bit_rate;
1662 codec->extradata= icodec->extradata;
1663 codec->extradata_size= icodec->extradata_size;
1664 switch(codec->codec_type) {
1665 case CODEC_TYPE_AUDIO:
1666 codec->sample_rate = icodec->sample_rate;
1667 codec->channels = icodec->channels;
1668 codec->frame_size = icodec->frame_size;
1669 codec->block_align= icodec->block_align;
1671 case CODEC_TYPE_VIDEO:
1672 codec->time_base = icodec->time_base;
1673 codec->width = icodec->width;
1674 codec->height = icodec->height;
1675 codec->has_b_frames = icodec->has_b_frames;
1677 case CODEC_TYPE_SUBTITLE:
1683 switch(codec->codec_type) {
1684 case CODEC_TYPE_AUDIO:
1685 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1688 if (codec->channels == icodec->channels &&
1689 codec->sample_rate == icodec->sample_rate) {
1690 ost->audio_resample = 0;
1692 if (codec->channels != icodec->channels &&
1693 (icodec->codec_id == CODEC_ID_AC3 ||
1694 icodec->codec_id == CODEC_ID_DTS)) {
1695 /* Special case for 5:1 AC3 and DTS input */
1696 /* and mono or stereo output */
1697 /* Request specific number of channels */
1698 icodec->channels = codec->channels;
1699 if (codec->sample_rate == icodec->sample_rate)
1700 ost->audio_resample = 0;
1702 ost->audio_resample = 1;
1705 ost->audio_resample = 1;
1708 if(audio_sync_method>1)
1709 ost->audio_resample = 1;
1711 if(ost->audio_resample){
1712 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1713 codec->sample_rate, icodec->sample_rate);
1715 printf("Can't resample. Aborting.\n");
1719 ist->decoding_needed = 1;
1720 ost->encoding_needed = 1;
1722 case CODEC_TYPE_VIDEO:
1723 if (codec->width == icodec->width &&
1724 codec->height == icodec->height &&
1725 frame_topBand == 0 &&
1726 frame_bottomBand == 0 &&
1727 frame_leftBand == 0 &&
1728 frame_rightBand == 0 &&
1729 frame_padtop == 0 &&
1730 frame_padbottom == 0 &&
1731 frame_padleft == 0 &&
1732 frame_padright == 0)
1734 ost->video_resample = 0;
1735 ost->video_crop = 0;
1737 } else if ((codec->width == icodec->width -
1738 (frame_leftBand + frame_rightBand)) &&
1739 (codec->height == icodec->height -
1740 (frame_topBand + frame_bottomBand)))
1742 ost->video_resample = 0;
1743 ost->video_crop = 1;
1744 ost->topBand = frame_topBand;
1745 ost->leftBand = frame_leftBand;
1746 } else if ((codec->width == icodec->width +
1747 (frame_padleft + frame_padright)) &&
1748 (codec->height == icodec->height +
1749 (frame_padtop + frame_padbottom))) {
1750 ost->video_resample = 0;
1751 ost->video_crop = 0;
1753 ost->padtop = frame_padtop;
1754 ost->padleft = frame_padleft;
1755 ost->padbottom = frame_padbottom;
1756 ost->padright = frame_padright;
1757 avcodec_get_frame_defaults(&ost->pict_tmp);
1758 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1759 codec->width, codec->height ) )
1762 ost->video_resample = 1;
1763 ost->video_crop = 0; // cropping is handled as part of resample
1764 avcodec_get_frame_defaults(&ost->pict_tmp);
1765 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1766 codec->width, codec->height ) )
1769 ost->img_resample_ctx = img_resample_full_init(
1770 ost->st->codec.width, ost->st->codec.height,
1771 ist->st->codec.width, ist->st->codec.height,
1772 frame_topBand, frame_bottomBand,
1773 frame_leftBand, frame_rightBand,
1774 frame_padtop, frame_padbottom,
1775 frame_padleft, frame_padright);
1777 ost->padtop = frame_padtop;
1778 ost->padleft = frame_padleft;
1779 ost->padbottom = frame_padbottom;
1780 ost->padright = frame_padright;
1783 ost->encoding_needed = 1;
1784 ist->decoding_needed = 1;
1786 case CODEC_TYPE_SUBTITLE:
1787 ost->encoding_needed = 1;
1788 ist->decoding_needed = 1;
1795 if (ost->encoding_needed &&
1796 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1797 char logfilename[1024];
1802 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1804 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1805 if (codec->flags & CODEC_FLAG_PASS1) {
1806 f = fopen(logfilename, "w");
1808 perror(logfilename);
1813 /* read the log file */
1814 f = fopen(logfilename, "r");
1816 perror(logfilename);
1819 fseek(f, 0, SEEK_END);
1821 fseek(f, 0, SEEK_SET);
1822 logbuffer = av_malloc(size + 1);
1824 fprintf(stderr, "Could not allocate log buffer\n");
1827 size = fread(logbuffer, 1, size, f);
1829 logbuffer[size] = '\0';
1830 codec->stats_in = logbuffer;
1834 if(codec->codec_type == CODEC_TYPE_VIDEO){
1835 int size= codec->width * codec->height;
1836 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1841 bit_buffer = av_malloc(bit_buffer_size);
1845 /* dump the file output parameters - cannot be done before in case
1847 for(i=0;i<nb_output_files;i++) {
1848 dump_format(output_files[i], i, output_files[i]->filename, 1);
1851 /* dump the stream mapping */
1853 fprintf(stderr, "Stream mapping:\n");
1854 for(i=0;i<nb_ostreams;i++) {
1856 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1857 ist_table[ost->source_index]->file_index,
1858 ist_table[ost->source_index]->index,
1861 if (ost->sync_ist != ist_table[ost->source_index])
1862 fprintf(stderr, " [sync #%d.%d]",
1863 ost->sync_ist->file_index,
1864 ost->sync_ist->index);
1865 fprintf(stderr, "\n");
1869 /* open each encoder */
1870 for(i=0;i<nb_ostreams;i++) {
1872 if (ost->encoding_needed) {
1874 codec = avcodec_find_encoder(ost->st->codec.codec_id);
1876 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1877 ost->file_index, ost->index);
1880 if (avcodec_open(&ost->st->codec, codec) < 0) {
1881 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1882 ost->file_index, ost->index);
1885 extra_size += ost->st->codec.extradata_size;
1889 /* open each decoder */
1890 for(i=0;i<nb_istreams;i++) {
1892 if (ist->decoding_needed) {
1894 codec = avcodec_find_decoder(ist->st->codec.codec_id);
1896 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1897 ist->st->codec.codec_id, ist->file_index, ist->index);
1900 if (avcodec_open(&ist->st->codec, codec) < 0) {
1901 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1902 ist->file_index, ist->index);
1905 //if (ist->st->codec.codec_type == CODEC_TYPE_VIDEO)
1906 // ist->st->codec.flags |= CODEC_FLAG_REPEAT_FIELD;
1911 for(i=0;i<nb_istreams;i++) {
1913 is = input_files[ist->file_index];
1915 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1916 if(ist->st->start_time == AV_NOPTS_VALUE)
1918 if(input_files_ts_offset[ist->file_index])
1919 ist->next_pts= AV_NOPTS_VALUE;
1923 /* compute buffer size max (should use a complete heuristic) */
1924 for(i=0;i<nb_input_files;i++) {
1925 file_table[i].buffer_size_max = 2048;
1928 /* set meta data information from input file if required */
1929 for (i=0;i<nb_meta_data_maps;i++) {
1930 AVFormatContext *out_file;
1931 AVFormatContext *in_file;
1933 int out_file_index = meta_data_maps[i].out_file;
1934 int in_file_index = meta_data_maps[i].in_file;
1935 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1936 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1940 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1941 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1946 out_file = output_files[out_file_index];
1947 in_file = input_files[in_file_index];
1949 strcpy(out_file->title, in_file->title);
1950 strcpy(out_file->author, in_file->author);
1951 strcpy(out_file->copyright, in_file->copyright);
1952 strcpy(out_file->comment, in_file->comment);
1953 strcpy(out_file->album, in_file->album);
1954 out_file->year = in_file->year;
1955 out_file->track = in_file->track;
1956 strcpy(out_file->genre, in_file->genre);
1959 /* open files and write file headers */
1960 for(i=0;i<nb_output_files;i++) {
1961 os = output_files[i];
1962 if (av_write_header(os) < 0) {
1963 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1969 #ifndef CONFIG_WIN32
1970 if ( !using_stdin && verbose >= 0) {
1971 fprintf(stderr, "Press [q] to stop encoding\n");
1972 url_set_interrupt_cb(decode_interrupt_cb);
1980 for(; received_sigterm == 0;) {
1981 int file_index, ist_index;
1989 /* if 'q' pressed, exits */
1993 /* read_key() returns 0 on EOF */
1999 /* select the stream that we must read now by looking at the
2000 smallest output pts */
2002 for(i=0;i<nb_ostreams;i++) {
2005 os = output_files[ost->file_index];
2006 ist = ist_table[ost->source_index];
2007 if(ost->st->codec.codec_type == CODEC_TYPE_VIDEO)
2008 opts = ost->sync_opts * av_q2d(ost->st->codec.time_base);
2010 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2011 ipts = (double)ist->pts;
2012 if (!file_table[ist->file_index].eof_reached){
2013 if(ipts < ipts_min) {
2015 if(input_sync ) file_index = ist->file_index;
2017 if(opts < opts_min) {
2019 if(!input_sync) file_index = ist->file_index;
2022 if(ost->frame_number >= max_frames[ost->st->codec.codec_type]){
2027 /* if none, if is finished */
2028 if (file_index < 0) {
2032 /* finish if recording time exhausted */
2033 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2036 /* finish if limit size exhausted */
2037 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
2040 /* read a frame from it and output it in the fifo */
2041 is = input_files[file_index];
2042 if (av_read_frame(is, &pkt) < 0) {
2043 file_table[file_index].eof_reached = 1;
2044 if (opt_shortest) break; else continue; //
2048 stream_no_data = is;
2053 av_pkt_dump(stdout, &pkt, do_hex_dump);
2055 /* the following test is needed in case new streams appear
2056 dynamically in stream : we ignore them */
2057 if (pkt.stream_index >= file_table[file_index].nb_streams)
2058 goto discard_packet;
2059 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2060 ist = ist_table[ist_index];
2062 goto discard_packet;
2064 // 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);
2065 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2066 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
2067 if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
2068 input_files_ts_offset[ist->file_index]-= delta;
2070 fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
2071 for(i=0; i<file_table[file_index].nb_streams; i++){
2072 int index= file_table[file_index].ist_index + i;
2073 ist_table[index]->next_pts += delta;
2074 ist_table[index]->is_start=1;
2079 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2080 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2083 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2084 ist->file_index, ist->index);
2086 av_free_packet(&pkt);
2091 av_free_packet(&pkt);
2093 /* dump report by using the output first video and audio streams */
2094 print_report(output_files, ost_table, nb_ostreams, 0);
2097 /* at the end of stream, we must flush the decoder buffers */
2098 for(i=0;i<nb_istreams;i++) {
2100 if (ist->decoding_needed) {
2101 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2107 /* write the trailer if needed and close file */
2108 for(i=0;i<nb_output_files;i++) {
2109 os = output_files[i];
2110 av_write_trailer(os);
2113 /* dump report by using the first video and audio streams */
2114 print_report(output_files, ost_table, nb_ostreams, 1);
2116 /* close each encoder */
2117 for(i=0;i<nb_ostreams;i++) {
2119 if (ost->encoding_needed) {
2120 av_freep(&ost->st->codec.stats_in);
2121 avcodec_close(&ost->st->codec);
2125 /* close each decoder */
2126 for(i=0;i<nb_istreams;i++) {
2128 if (ist->decoding_needed) {
2129 avcodec_close(&ist->st->codec);
2137 av_freep(&bit_buffer);
2138 av_free(file_table);
2141 for(i=0;i<nb_istreams;i++) {
2148 for(i=0;i<nb_ostreams;i++) {
2152 fclose(ost->logfile);
2153 ost->logfile = NULL;
2155 fifo_free(&ost->fifo); /* works even if fifo is not
2156 initialized but set to zero */
2157 av_free(ost->pict_tmp.data[0]);
2158 if (ost->video_resample)
2159 img_resample_close(ost->img_resample_ctx);
2160 if (ost->audio_resample)
2161 audio_resample_close(ost->resample);
2174 int file_read(const char *filename)
2177 unsigned char buffer[1024];
2180 if (url_open(&h, filename, O_RDONLY) < 0) {
2181 printf("could not open '%s'\n", filename);
2185 len = url_read(h, buffer, sizeof(buffer));
2188 for(i=0;i<len;i++) putchar(buffer[i]);
2195 static void opt_image_format(const char *arg)
2199 for(f = first_image_format; f != NULL; f = f->next) {
2200 if (!strcmp(arg, f->name))
2204 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2210 static void opt_format(const char *arg)
2212 /* compatibility stuff for pgmyuv */
2213 if (!strcmp(arg, "pgmyuv")) {
2214 pgmyuv_compatibility_hack=1;
2215 // opt_image_format(arg);
2219 file_iformat = av_find_input_format(arg);
2220 file_oformat = guess_format(arg, NULL, NULL);
2221 if (!file_iformat && !file_oformat) {
2222 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2227 static void opt_video_bitrate(const char *arg)
2229 video_bit_rate = atoi(arg) * 1000;
2232 static void opt_video_bitrate_tolerance(const char *arg)
2234 video_bit_rate_tolerance = atoi(arg) * 1000;
2237 static void opt_video_bitrate_max(const char *arg)
2239 video_rc_max_rate = atoi(arg) * 1000;
2242 static void opt_video_bitrate_min(const char *arg)
2244 video_rc_min_rate = atoi(arg) * 1000;
2247 static void opt_video_buffer_size(const char *arg)
2249 video_rc_buffer_size = atoi(arg) * 8*1024;
2252 static void opt_video_rc_eq(char *arg)
2257 static void opt_video_rc_override_string(char *arg)
2259 video_rc_override_string = arg;
2263 static void opt_workaround_bugs(const char *arg)
2265 workaround_bugs = atoi(arg);
2268 static void opt_dct_algo(const char *arg)
2270 dct_algo = atoi(arg);
2273 static void opt_idct_algo(const char *arg)
2275 idct_algo = atoi(arg);
2278 static void opt_me_threshold(const char *arg)
2280 me_threshold = atoi(arg);
2283 static void opt_mb_threshold(const char *arg)
2285 mb_threshold = atoi(arg);
2288 static void opt_error_resilience(const char *arg)
2290 error_resilience = atoi(arg);
2293 static void opt_error_concealment(const char *arg)
2295 error_concealment = atoi(arg);
2298 static void opt_debug(const char *arg)
2301 av_log_set_level(AV_LOG_DEBUG);
2304 static void opt_vismv(const char *arg)
2306 debug_mv = atoi(arg);
2309 static void opt_verbose(const char *arg)
2311 verbose = atoi(arg);
2312 av_log_set_level(atoi(arg));
2315 static void opt_frame_rate(const char *arg)
2317 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2318 fprintf(stderr, "Incorrect frame rate\n");
2323 static void opt_frame_crop_top(const char *arg)
2325 frame_topBand = atoi(arg);
2326 if (frame_topBand < 0) {
2327 fprintf(stderr, "Incorrect top crop size\n");
2330 if ((frame_topBand % 2) != 0) {
2331 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2334 if ((frame_topBand) >= frame_height){
2335 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2338 frame_height -= frame_topBand;
2341 static void opt_frame_crop_bottom(const char *arg)
2343 frame_bottomBand = atoi(arg);
2344 if (frame_bottomBand < 0) {
2345 fprintf(stderr, "Incorrect bottom crop size\n");
2348 if ((frame_bottomBand % 2) != 0) {
2349 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2352 if ((frame_bottomBand) >= frame_height){
2353 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2356 frame_height -= frame_bottomBand;
2359 static void opt_frame_crop_left(const char *arg)
2361 frame_leftBand = atoi(arg);
2362 if (frame_leftBand < 0) {
2363 fprintf(stderr, "Incorrect left crop size\n");
2366 if ((frame_leftBand % 2) != 0) {
2367 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2370 if ((frame_leftBand) >= frame_width){
2371 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2374 frame_width -= frame_leftBand;
2377 static void opt_frame_crop_right(const char *arg)
2379 frame_rightBand = atoi(arg);
2380 if (frame_rightBand < 0) {
2381 fprintf(stderr, "Incorrect right crop size\n");
2384 if ((frame_rightBand % 2) != 0) {
2385 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2388 if ((frame_rightBand) >= frame_width){
2389 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2392 frame_width -= frame_rightBand;
2395 static void opt_frame_size(const char *arg)
2397 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2398 fprintf(stderr, "Incorrect frame size\n");
2401 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2402 fprintf(stderr, "Frame size must be a multiple of 2\n");
2408 #define SCALEBITS 10
2409 #define ONE_HALF (1 << (SCALEBITS - 1))
2410 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2412 #define RGB_TO_Y(r, g, b) \
2413 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2414 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2416 #define RGB_TO_U(r1, g1, b1, shift)\
2417 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2418 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2420 #define RGB_TO_V(r1, g1, b1, shift)\
2421 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2422 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2424 static void opt_pad_color(const char *arg) {
2425 /* Input is expected to be six hex digits similar to
2426 how colors are expressed in html tags (but without the #) */
2427 int rgb = strtol(arg, NULL, 16);
2431 g = ((rgb >> 8) & 255);
2434 padcolor[0] = RGB_TO_Y(r,g,b);
2435 padcolor[1] = RGB_TO_U(r,g,b,0);
2436 padcolor[2] = RGB_TO_V(r,g,b,0);
2439 static void opt_frame_pad_top(const char *arg)
2441 frame_padtop = atoi(arg);
2442 if (frame_padtop < 0) {
2443 fprintf(stderr, "Incorrect top pad size\n");
2446 if ((frame_padtop % 2) != 0) {
2447 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2452 static void opt_frame_pad_bottom(const char *arg)
2454 frame_padbottom = atoi(arg);
2455 if (frame_padbottom < 0) {
2456 fprintf(stderr, "Incorrect bottom pad size\n");
2459 if ((frame_padbottom % 2) != 0) {
2460 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2466 static void opt_frame_pad_left(const char *arg)
2468 frame_padleft = atoi(arg);
2469 if (frame_padleft < 0) {
2470 fprintf(stderr, "Incorrect left pad size\n");
2473 if ((frame_padleft % 2) != 0) {
2474 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2480 static void opt_frame_pad_right(const char *arg)
2482 frame_padright = atoi(arg);
2483 if (frame_padright < 0) {
2484 fprintf(stderr, "Incorrect right pad size\n");
2487 if ((frame_padright % 2) != 0) {
2488 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2494 static void opt_frame_pix_fmt(const char *arg)
2496 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2499 static void opt_frame_aspect_ratio(const char *arg)
2505 p = strchr(arg, ':');
2507 x = strtol(arg, (char **)&arg, 10);
2509 y = strtol(arg+1, (char **)&arg, 10);
2511 ar = (double)x / (double)y;
2513 ar = strtod(arg, (char **)&arg);
2516 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2519 frame_aspect_ratio = ar;
2522 static void opt_gop_size(const char *arg)
2524 gop_size = atoi(arg);
2527 static void opt_b_frames(const char *arg)
2529 b_frames = atoi(arg);
2530 if (b_frames > FF_MAX_B_FRAMES) {
2531 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2533 } else if (b_frames < 1) {
2534 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2539 static void opt_mb_decision(const char *arg)
2541 mb_decision = atoi(arg);
2544 static void opt_mb_cmp(const char *arg)
2549 static void opt_ildct_cmp(const char *arg)
2551 ildct_cmp = atoi(arg);
2554 static void opt_sub_cmp(const char *arg)
2556 sub_cmp = atoi(arg);
2559 static void opt_cmp(const char *arg)
2564 static void opt_pre_cmp(const char *arg)
2566 pre_cmp = atoi(arg);
2569 static void opt_pre_me(const char *arg)
2574 static void opt_lumi_mask(const char *arg)
2576 lumi_mask = atof(arg);
2579 static void opt_dark_mask(const char *arg)
2581 dark_mask = atof(arg);
2584 static void opt_scplx_mask(const char *arg)
2586 scplx_mask = atof(arg);
2589 static void opt_tcplx_mask(const char *arg)
2591 tcplx_mask = atof(arg);
2594 static void opt_p_mask(const char *arg)
2599 static void opt_qscale(const char *arg)
2601 video_qscale = atof(arg);
2602 if (video_qscale < 0.01 ||
2603 video_qscale > 255) {
2604 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2609 static void opt_qsquish(const char *arg)
2611 video_qsquish = atof(arg);
2612 if (video_qsquish < 0.0 ||
2613 video_qsquish > 99.0) {
2614 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2619 static void opt_lelim(const char *arg)
2621 video_lelim = atoi(arg);
2622 if (video_lelim < -99 ||
2624 fprintf(stderr, "lelim must be >= -99 and <= 99\n");
2629 static void opt_celim(const char *arg)
2631 video_celim = atoi(arg);
2632 if (video_celim < -99 ||
2634 fprintf(stderr, "celim must be >= -99 and <= 99\n");
2639 static void opt_lmax(const char *arg)
2641 video_lmax = atof(arg)*FF_QP2LAMBDA;
2644 static void opt_lmin(const char *arg)
2646 video_lmin = atof(arg)*FF_QP2LAMBDA;
2649 static void opt_qmin(const char *arg)
2651 video_qmin = atoi(arg);
2652 if (video_qmin < 1 ||
2654 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2659 static void opt_qmax(const char *arg)
2661 video_qmax = atoi(arg);
2662 if (video_qmax < 1 ||
2664 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2669 static void opt_mb_lmin(const char *arg)
2671 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2672 if (video_mb_lmin < 1 ||
2673 video_mb_lmin > FF_LAMBDA_MAX) {
2674 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2679 static void opt_mb_lmax(const char *arg)
2681 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2682 if (video_mb_lmax < 1 ||
2683 video_mb_lmax > FF_LAMBDA_MAX) {
2684 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2689 static void opt_qdiff(const char *arg)
2691 video_qdiff = atoi(arg);
2692 if (video_qdiff < 0 ||
2694 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2699 static void opt_qblur(const char *arg)
2701 video_qblur = atof(arg);
2704 static void opt_qcomp(const char *arg)
2706 video_qcomp = atof(arg);
2709 static void opt_rc_initial_cplx(const char *arg)
2711 video_rc_initial_cplx = atof(arg);
2713 static void opt_b_qfactor(const char *arg)
2715 video_b_qfactor = atof(arg);
2717 static void opt_i_qfactor(const char *arg)
2719 video_i_qfactor = atof(arg);
2721 static void opt_b_qoffset(const char *arg)
2723 video_b_qoffset = atof(arg);
2725 static void opt_i_qoffset(const char *arg)
2727 video_i_qoffset = atof(arg);
2730 static void opt_ibias(const char *arg)
2732 video_intra_quant_bias = atoi(arg);
2734 static void opt_pbias(const char *arg)
2736 video_inter_quant_bias = atoi(arg);
2739 static void opt_packet_size(const char *arg)
2741 packet_size= atoi(arg);
2744 static void opt_error_rate(const char *arg)
2746 error_rate= atoi(arg);
2749 static void opt_strict(const char *arg)
2754 static void opt_top_field_first(const char *arg)
2756 top_field_first= atoi(arg);
2759 static void opt_noise_reduction(const char *arg)
2761 noise_reduction= atoi(arg);
2764 static void opt_qns(const char *arg)
2769 static void opt_sc_threshold(const char *arg)
2771 sc_threshold= atoi(arg);
2774 static void opt_me_range(const char *arg)
2776 me_range = atoi(arg);
2779 static void opt_thread_count(const char *arg)
2781 thread_count= atoi(arg);
2782 #if !defined(HAVE_THREADS)
2784 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2788 static void opt_audio_bitrate(const char *arg)
2790 audio_bit_rate = atoi(arg) * 1000;
2793 static void opt_audio_rate(const char *arg)
2795 audio_sample_rate = atoi(arg);
2798 static void opt_audio_channels(const char *arg)
2800 audio_channels = atoi(arg);
2803 static void opt_video_device(const char *arg)
2805 video_device = av_strdup(arg);
2808 static void opt_grab_device(const char *arg)
2810 grab_device = av_strdup(arg);
2813 static void opt_video_channel(const char *arg)
2815 video_channel = strtol(arg, NULL, 0);
2818 static void opt_video_standard(const char *arg)
2820 video_standard = av_strdup(arg);
2823 static void opt_audio_device(const char *arg)
2825 audio_device = av_strdup(arg);
2828 static void opt_codec(int *pstream_copy, int *pcodec_id,
2829 int codec_type, const char *arg)
2833 if (!strcmp(arg, "copy")) {
2838 if (!strcmp(p->name, arg) && p->type == codec_type)
2843 fprintf(stderr, "Unknown codec '%s'\n", arg);
2851 static void opt_audio_codec(const char *arg)
2853 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2856 static void opt_audio_tag(const char *arg)
2859 audio_codec_tag= strtol(arg, &tail, 0);
2862 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2865 static void opt_video_tag(const char *arg)
2868 video_codec_tag= strtol(arg, &tail, 0);
2871 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2874 static void add_frame_hooker(const char *arg)
2879 char *args = av_strdup(arg);
2883 argv[0] = strtok(args, " ");
2884 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2887 i = frame_hook_add(argc, argv);
2890 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2895 const char *motion_str[] = {
2905 static void opt_motion_estimation(const char *arg)
2911 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2914 if (!strcmp(*p, arg))
2918 me_method = (p - motion_str) + 1;
2921 static void opt_video_codec(const char *arg)
2923 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2926 static void opt_subtitle_codec(const char *arg)
2928 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2931 static void opt_map(const char *arg)
2937 m = &stream_maps[nb_stream_maps++];
2939 m->file_index = strtol(arg, (char **)&p, 0);
2943 m->stream_index = strtol(p, (char **)&p, 0);
2946 m->sync_file_index = strtol(p, (char **)&p, 0);
2949 m->sync_stream_index = strtol(p, (char **)&p, 0);
2951 m->sync_file_index = m->file_index;
2952 m->sync_stream_index = m->stream_index;
2956 static void opt_map_meta_data(const char *arg)
2962 m = &meta_data_maps[nb_meta_data_maps++];
2964 m->out_file = strtol(arg, (char **)&p, 0);
2968 m->in_file = strtol(p, (char **)&p, 0);
2971 static void opt_recording_time(const char *arg)
2973 recording_time = parse_date(arg, 1);
2976 static void opt_start_time(const char *arg)
2978 start_time = parse_date(arg, 1);
2981 static void opt_rec_timestamp(const char *arg)
2983 rec_timestamp = parse_date(arg, 0) / 1000000;
2986 static void opt_input_ts_offset(const char *arg)
2988 input_ts_offset = parse_date(arg, 1);
2991 static void opt_input_file(const char *filename)
2993 AVFormatContext *ic;
2994 AVFormatParameters params, *ap = ¶ms;
2995 int err, i, ret, rfps, rfps_base;
2998 if (!strcmp(filename, "-"))
3001 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3002 !strcmp( filename, "/dev/stdin" );
3004 /* get default parameters from command line */
3005 memset(ap, 0, sizeof(*ap));
3006 ap->sample_rate = audio_sample_rate;
3007 ap->channels = audio_channels;
3008 ap->time_base.den = frame_rate;
3009 ap->time_base.num = frame_rate_base;
3010 ap->width = frame_width + frame_padleft + frame_padright;
3011 ap->height = frame_height + frame_padtop + frame_padbottom;
3012 ap->image_format = image_format;
3013 ap->pix_fmt = frame_pix_fmt;
3014 ap->device = grab_device;
3015 ap->channel = video_channel;
3016 ap->standard = video_standard;
3017 ap->video_codec_id = video_codec_id;
3018 ap->audio_codec_id = audio_codec_id;
3019 if(pgmyuv_compatibility_hack)
3020 ap->video_codec_id= CODEC_ID_PGMYUV;
3022 /* open the input file with generic libav function */
3023 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3025 print_error(filename, err);
3029 /* If not enough info to get the stream parameters, we decode the
3030 first frames to get it. (used in mpeg case for example) */
3031 ret = av_find_stream_info(ic);
3032 if (ret < 0 && verbose >= 0) {
3033 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3037 timestamp = start_time;
3038 /* add the stream start time */
3039 if (ic->start_time != AV_NOPTS_VALUE)
3040 timestamp += ic->start_time;
3042 /* if seeking requested, we execute it */
3043 if (start_time != 0) {
3044 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3046 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3047 filename, (double)timestamp / AV_TIME_BASE);
3049 /* reset seek info */
3053 /* update the current parameters so that they match the one of the input stream */
3054 for(i=0;i<ic->nb_streams;i++) {
3055 AVCodecContext *enc = &ic->streams[i]->codec;
3056 #if defined(HAVE_THREADS)
3058 avcodec_thread_init(enc, thread_count);
3060 enc->thread_count= thread_count;
3061 switch(enc->codec_type) {
3062 case CODEC_TYPE_AUDIO:
3063 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3064 audio_channels = enc->channels;
3065 audio_sample_rate = enc->sample_rate;
3067 ic->streams[i]->discard= AVDISCARD_ALL;
3069 case CODEC_TYPE_VIDEO:
3070 frame_height = enc->height;
3071 frame_width = enc->width;
3072 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
3073 frame_pix_fmt = enc->pix_fmt;
3074 rfps = ic->streams[i]->r_frame_rate.num;
3075 rfps_base = ic->streams[i]->r_frame_rate.den;
3076 enc->workaround_bugs = workaround_bugs;
3077 enc->error_resilience = error_resilience;
3078 enc->error_concealment = error_concealment;
3079 enc->idct_algo = idct_algo;
3081 enc->debug_mv = debug_mv;
3082 enc->lowres= lowres;
3083 if(lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
3085 enc->flags|= CODEC_FLAG_BITEXACT;
3087 enc->debug |= FF_DEBUG_MV;
3089 enc->flags |= CODEC_FLAG_GRAY;
3091 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
3094 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3095 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
3097 (float)rfps / rfps_base, rfps, rfps_base);
3099 /* update the current frame rate to match the stream frame rate */
3101 frame_rate_base = rfps_base;
3103 enc->rate_emu = rate_emu;
3105 ic->streams[i]->discard= AVDISCARD_ALL;
3106 else if(video_discard)
3107 ic->streams[i]->discard= video_discard;
3109 case CODEC_TYPE_DATA:
3111 case CODEC_TYPE_SUBTITLE:
3118 input_files[nb_input_files] = ic;
3119 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3120 /* dump the file content */
3122 dump_format(ic, nb_input_files, filename, 0);
3125 file_iformat = NULL;
3126 file_oformat = NULL;
3127 image_format = NULL;
3135 static void opt_grab(const char *arg)
3137 file_iformat = av_find_input_format(arg);
3141 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
3143 int has_video, has_audio, i, j;
3144 AVFormatContext *ic;
3148 for(j=0;j<nb_input_files;j++) {
3149 ic = input_files[j];
3150 for(i=0;i<ic->nb_streams;i++) {
3151 AVCodecContext *enc = &ic->streams[i]->codec;
3152 switch(enc->codec_type) {
3153 case CODEC_TYPE_AUDIO:
3156 case CODEC_TYPE_VIDEO:
3159 case CODEC_TYPE_DATA:
3160 case CODEC_TYPE_SUBTITLE:
3167 *has_video_ptr = has_video;
3168 *has_audio_ptr = has_audio;
3171 static void new_video_stream(AVFormatContext *oc)
3174 AVCodecContext *video_enc;
3177 st = av_new_stream(oc, oc->nb_streams);
3179 fprintf(stderr, "Could not alloc stream\n");
3182 #if defined(HAVE_THREADS)
3184 avcodec_thread_init(&st->codec, thread_count);
3187 video_enc = &st->codec;
3190 video_enc->codec_tag= video_codec_tag;
3192 if( (video_global_header&1)
3193 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER)))
3194 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3195 if(video_global_header&2)
3196 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3198 if (video_stream_copy) {
3199 st->stream_copy = 1;
3200 video_enc->codec_type = CODEC_TYPE_VIDEO;
3206 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3207 if (video_codec_id != CODEC_ID_NONE)
3208 codec_id = video_codec_id;
3210 video_enc->codec_id = codec_id;
3211 codec = avcodec_find_encoder(codec_id);
3213 video_enc->bit_rate = video_bit_rate;
3214 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3215 video_enc->time_base.den = frame_rate;
3216 video_enc->time_base.num = frame_rate_base;
3217 if(codec && codec->supported_framerates){
3218 const AVRational *p= codec->supported_framerates;
3219 AVRational req= (AVRational){frame_rate, frame_rate_base};
3220 const AVRational *best=NULL;
3221 AVRational best_error= (AVRational){INT_MAX, 1};
3222 for(; p->den!=0; p++){
3223 AVRational error= av_sub_q(req, *p);
3224 if(error.num <0) error.num *= -1;
3225 if(av_cmp_q(error, best_error) < 0){
3230 video_enc->time_base.den= best->num;
3231 video_enc->time_base.num= best->den;
3234 video_enc->width = frame_width + frame_padright + frame_padleft;
3235 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3236 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3237 video_enc->pix_fmt = frame_pix_fmt;
3239 if(codec && codec->pix_fmts){
3240 const enum PixelFormat *p= codec->pix_fmts;
3242 if(*p == video_enc->pix_fmt)
3246 video_enc->pix_fmt = codec->pix_fmts[0];
3250 video_enc->gop_size = gop_size;
3252 video_enc->gop_size = 0;
3253 if (video_qscale || same_quality) {
3254 video_enc->flags |= CODEC_FLAG_QSCALE;
3255 video_enc->global_quality=
3256 st->quality = FF_QP2LAMBDA * video_qscale;
3260 video_enc->intra_matrix = intra_matrix;
3262 video_enc->inter_matrix = inter_matrix;
3265 video_enc->flags |= CODEC_FLAG_BITEXACT;
3267 video_enc->mb_decision = mb_decision;
3268 video_enc->mb_cmp = mb_cmp;
3269 video_enc->ildct_cmp = ildct_cmp;
3270 video_enc->me_sub_cmp = sub_cmp;
3271 video_enc->me_cmp = cmp;
3272 video_enc->me_pre_cmp = pre_cmp;
3273 video_enc->pre_me = pre_me;
3274 video_enc->lumi_masking = lumi_mask;
3275 video_enc->dark_masking = dark_mask;
3276 video_enc->spatial_cplx_masking = scplx_mask;
3277 video_enc->temporal_cplx_masking = tcplx_mask;
3278 video_enc->p_masking = p_mask;
3279 video_enc->quantizer_noise_shaping= qns;
3282 video_enc->flags |= CODEC_FLAG_H263P_UMV;
3285 video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3288 video_enc->flags |= CODEC_FLAG_H263P_AIC;
3291 video_enc->flags |= CODEC_FLAG_H263P_AIV;
3294 video_enc->flags |= CODEC_FLAG_4MV;
3297 video_enc->flags |= CODEC_FLAG_OBMC;
3300 video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3304 video_enc->flags |= CODEC_FLAG_PART;
3307 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3310 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3313 video_enc->flags |= CODEC_FLAG_MV0;
3315 if (do_normalize_aqp) {
3316 video_enc->flags |= CODEC_FLAG_NORMALIZE_AQP;
3318 if (use_scan_offset) {
3319 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3322 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3325 video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3328 video_enc->flags |= CODEC_FLAG_QPEL;
3331 video_enc->flags |= CODEC_FLAG_QP_RD;
3334 video_enc->flags |= CODEC_FLAG_CBP_RD;
3337 video_enc->max_b_frames = b_frames;
3338 video_enc->b_frame_strategy = b_strategy;
3339 video_enc->b_quant_factor = 2.0;
3341 if (do_interlace_dct) {
3342 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3344 if (do_interlace_me) {
3345 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3348 video_enc->flags2 |= CODEC_FLAG2_NO_OUTPUT;
3351 video_enc->flags |= CODEC_FLAG_GRAY;
3353 video_enc->qmin = video_qmin;
3354 video_enc->qmax = video_qmax;
3355 video_enc->lmin = video_lmin;
3356 video_enc->lmax = video_lmax;
3357 video_enc->rc_qsquish = video_qsquish;
3358 video_enc->luma_elim_threshold = video_lelim;
3359 video_enc->chroma_elim_threshold = video_celim;
3360 video_enc->mb_lmin = video_mb_lmin;
3361 video_enc->mb_lmax = video_mb_lmax;
3362 video_enc->max_qdiff = video_qdiff;
3363 video_enc->qblur = video_qblur;
3364 video_enc->qcompress = video_qcomp;
3365 video_enc->rc_eq = video_rc_eq;
3366 video_enc->debug = debug;
3367 video_enc->debug_mv = debug_mv;
3368 video_enc->workaround_bugs = workaround_bugs;
3369 video_enc->thread_count = thread_count;
3370 p= video_rc_override_string;
3373 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3375 fprintf(stderr, "error parsing rc_override\n");
3378 video_enc->rc_override=
3379 av_realloc(video_enc->rc_override,
3380 sizeof(RcOverride)*(i+1));
3381 video_enc->rc_override[i].start_frame= start;
3382 video_enc->rc_override[i].end_frame = end;
3384 video_enc->rc_override[i].qscale= q;
3385 video_enc->rc_override[i].quality_factor= 1.0;
3388 video_enc->rc_override[i].qscale= 0;
3389 video_enc->rc_override[i].quality_factor= -q/100.0;
3394 video_enc->rc_override_count=i;
3396 video_enc->rc_max_rate = video_rc_max_rate;
3397 video_enc->rc_min_rate = video_rc_min_rate;
3398 video_enc->rc_buffer_size = video_rc_buffer_size;
3399 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3400 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3401 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3402 video_enc->i_quant_factor = video_i_qfactor;
3403 video_enc->b_quant_factor = video_b_qfactor;
3404 video_enc->i_quant_offset = video_i_qoffset;
3405 video_enc->b_quant_offset = video_b_qoffset;
3406 video_enc->intra_quant_bias = video_intra_quant_bias;
3407 video_enc->inter_quant_bias = video_inter_quant_bias;
3408 video_enc->dct_algo = dct_algo;
3409 video_enc->idct_algo = idct_algo;
3410 video_enc->me_threshold= me_threshold;
3411 video_enc->mb_threshold= mb_threshold;
3412 video_enc->intra_dc_precision= intra_dc_precision - 8;
3413 video_enc->strict_std_compliance = strict;
3414 video_enc->error_rate = error_rate;
3415 video_enc->noise_reduction= noise_reduction;
3416 video_enc->scenechange_threshold= sc_threshold;
3417 video_enc->me_range = me_range;
3418 video_enc->coder_type= coder;
3419 video_enc->context_model= context;
3420 video_enc->prediction_method= predictor;
3421 video_enc->profile= video_profile;
3422 video_enc->level= video_level;
3423 video_enc->nsse_weight= nsse_weight;
3424 video_enc->me_subpel_quality= subpel_quality;
3425 video_enc->me_penalty_compensation= me_penalty_compensation;
3426 video_enc->frame_skip_threshold= frame_skip_threshold;
3427 video_enc->frame_skip_factor= frame_skip_factor;
3428 video_enc->frame_skip_exp= frame_skip_exp;
3429 video_enc->frame_skip_cmp= frame_skip_cmp;
3432 video_enc->rtp_mode= 1;
3433 video_enc->rtp_payload_size= packet_size;
3437 video_enc->flags|= CODEC_FLAG_PSNR;
3439 video_enc->me_method = me_method;
3444 video_enc->flags |= CODEC_FLAG_PASS1;
3446 video_enc->flags |= CODEC_FLAG_PASS2;
3451 /* reset some key parameters */
3453 video_codec_id = CODEC_ID_NONE;
3454 video_stream_copy = 0;
3457 static void new_audio_stream(AVFormatContext *oc)
3460 AVCodecContext *audio_enc;
3463 st = av_new_stream(oc, oc->nb_streams);
3465 fprintf(stderr, "Could not alloc stream\n");
3468 #if defined(HAVE_THREADS)
3470 avcodec_thread_init(&st->codec, thread_count);
3473 audio_enc = &st->codec;
3474 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3477 audio_enc->codec_tag= audio_codec_tag;
3479 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3480 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3481 if (audio_stream_copy) {
3482 st->stream_copy = 1;
3483 audio_enc->channels = audio_channels;
3485 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3486 if (audio_codec_id != CODEC_ID_NONE)
3487 codec_id = audio_codec_id;
3488 audio_enc->codec_id = codec_id;
3490 audio_enc->bit_rate = audio_bit_rate;
3491 audio_enc->strict_std_compliance = strict;
3492 audio_enc->thread_count = thread_count;
3493 /* For audio codecs other than AC3 or DTS we limit */
3494 /* the number of coded channels to stereo */
3495 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3496 && codec_id != CODEC_ID_DTS) {
3497 audio_enc->channels = 2;
3499 audio_enc->channels = audio_channels;
3501 audio_enc->sample_rate = audio_sample_rate;
3502 if (audio_language) {
3503 pstrcpy(st->language, sizeof(st->language), audio_language);
3504 av_free(audio_language);
3505 audio_language = NULL;
3508 /* reset some key parameters */
3510 audio_codec_id = CODEC_ID_NONE;
3511 audio_stream_copy = 0;
3514 static void opt_new_subtitle_stream(void)
3516 AVFormatContext *oc;
3518 AVCodecContext *subtitle_enc;
3520 if (nb_output_files <= 0) {
3521 fprintf(stderr, "At least one output file must be specified\n");
3524 oc = output_files[nb_output_files - 1];
3526 st = av_new_stream(oc, oc->nb_streams);
3528 fprintf(stderr, "Could not alloc stream\n");
3532 subtitle_enc = &st->codec;
3533 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3534 if (subtitle_stream_copy) {
3535 st->stream_copy = 1;
3537 subtitle_enc->codec_id = subtitle_codec_id;
3540 if (subtitle_language) {
3541 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3542 av_free(subtitle_language);
3543 subtitle_language = NULL;
3546 subtitle_codec_id = CODEC_ID_NONE;
3547 subtitle_stream_copy = 0;
3550 static void opt_new_audio_stream(void)
3552 AVFormatContext *oc;
3553 if (nb_output_files <= 0) {
3554 fprintf(stderr, "At least one output file must be specified\n");
3557 oc = output_files[nb_output_files - 1];
3558 new_audio_stream(oc);
3561 static void opt_new_video_stream(void)
3563 AVFormatContext *oc;
3564 if (nb_output_files <= 0) {
3565 fprintf(stderr, "At least one output file must be specified\n");
3568 oc = output_files[nb_output_files - 1];
3569 new_video_stream(oc);
3572 static void opt_output_file(const char *filename)
3574 AVFormatContext *oc;
3575 int use_video, use_audio, input_has_video, input_has_audio;
3576 AVFormatParameters params, *ap = ¶ms;
3578 if (!strcmp(filename, "-"))
3581 oc = av_alloc_format_context();
3583 if (!file_oformat) {
3584 file_oformat = guess_format(NULL, filename, NULL);
3585 if (!file_oformat) {
3586 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3592 oc->oformat = file_oformat;
3593 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3595 if (!strcmp(file_oformat->name, "ffm") &&
3596 strstart(filename, "http:", NULL)) {
3597 /* special case for files sent to ffserver: we get the stream
3598 parameters from ffserver */
3599 if (read_ffserver_streams(oc, filename) < 0) {
3600 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3604 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy;
3605 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy;
3607 /* disable if no corresponding type found and at least one
3609 if (nb_input_files > 0) {
3610 check_audio_video_inputs(&input_has_video, &input_has_audio);
3611 if (!input_has_video)
3613 if (!input_has_audio)
3617 /* manual disable */
3618 if (audio_disable) {
3621 if (video_disable) {
3626 new_video_stream(oc);
3630 new_audio_stream(oc);
3633 if (!oc->nb_streams) {
3634 fprintf(stderr, "No audio or video streams available\n");
3638 oc->timestamp = rec_timestamp;
3641 pstrcpy(oc->title, sizeof(oc->title), str_title);
3643 pstrcpy(oc->author, sizeof(oc->author), str_author);
3645 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3647 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3650 output_files[nb_output_files++] = oc;
3652 /* check filename in case of an image number is expected */
3653 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3654 if (filename_number_test(oc->filename) < 0) {
3655 print_error(oc->filename, AVERROR_NUMEXPECTED);
3660 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3661 /* test if it already exists to avoid loosing precious files */
3662 if (!file_overwrite &&
3663 (strchr(filename, ':') == NULL ||
3664 strstart(filename, "file:", NULL))) {
3665 if (url_exist(filename)) {
3668 if ( !using_stdin ) {
3669 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3672 if (toupper(c) != 'Y') {
3673 fprintf(stderr, "Not overwriting - exiting\n");
3678 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3685 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3686 fprintf(stderr, "Could not open '%s'\n", filename);
3691 memset(ap, 0, sizeof(*ap));
3692 ap->image_format = image_format;
3693 if (av_set_parameters(oc, ap) < 0) {
3694 fprintf(stderr, "%s: Invalid encoding parameters\n",
3699 oc->packet_size= mux_packet_size;
3700 oc->mux_rate= mux_rate;
3701 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3702 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3703 oc->loop_output = loop_output;
3705 /* reset some options */
3706 file_oformat = NULL;
3707 file_iformat = NULL;
3708 image_format = NULL;
3711 /* prepare dummy protocols for grab */
3712 static void prepare_grab(void)
3714 int has_video, has_audio, i, j;
3715 AVFormatContext *oc;
3716 AVFormatContext *ic;
3717 AVFormatParameters vp1, *vp = &vp1;
3718 AVFormatParameters ap1, *ap = &ap1;
3720 /* see if audio/video inputs are needed */
3723 memset(ap, 0, sizeof(*ap));
3724 memset(vp, 0, sizeof(*vp));
3725 vp->time_base.num= 1;
3726 for(j=0;j<nb_output_files;j++) {
3727 oc = output_files[j];
3728 for(i=0;i<oc->nb_streams;i++) {
3729 AVCodecContext *enc = &oc->streams[i]->codec;
3730 switch(enc->codec_type) {
3731 case CODEC_TYPE_AUDIO:
3732 if (enc->sample_rate > ap->sample_rate)
3733 ap->sample_rate = enc->sample_rate;
3734 if (enc->channels > ap->channels)
3735 ap->channels = enc->channels;
3738 case CODEC_TYPE_VIDEO:
3739 if (enc->width > vp->width)
3740 vp->width = enc->width;
3741 if (enc->height > vp->height)
3742 vp->height = enc->height;
3744 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3745 vp->time_base = enc->time_base;
3755 if (has_video == 0 && has_audio == 0) {
3756 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3761 AVInputFormat *fmt1;
3762 fmt1 = av_find_input_format(video_grab_format);
3763 vp->device = video_device;
3764 vp->channel = video_channel;
3765 vp->standard = video_standard;
3766 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3767 fprintf(stderr, "Could not find video grab device\n");
3770 /* If not enough info to get the stream parameters, we decode the
3771 first frames to get it. */
3772 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3773 fprintf(stderr, "Could not find video grab parameters\n");
3776 /* by now video grab has one stream */
3777 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3778 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3779 input_files[nb_input_files] = ic;
3782 dump_format(ic, nb_input_files, "", 0);
3786 if (has_audio && audio_grab_format) {
3787 AVInputFormat *fmt1;
3788 fmt1 = av_find_input_format(audio_grab_format);
3789 ap->device = audio_device;
3790 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3791 fprintf(stderr, "Could not find audio grab device\n");
3794 input_files[nb_input_files] = ic;
3797 dump_format(ic, nb_input_files, "", 0);
3803 /* same option as mencoder */
3804 static void opt_pass(const char *pass_str)
3807 pass = atoi(pass_str);
3808 if (pass != 1 && pass != 2) {
3809 fprintf(stderr, "pass number can be only 1 or 2\n");
3815 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3816 static int64_t getutime(void)
3818 return av_gettime();
3821 static int64_t getutime(void)
3823 struct rusage rusage;
3825 getrusage(RUSAGE_SELF, &rusage);
3826 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3830 extern int ffm_nopts;
3832 static void opt_bitexact(void)
3835 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3839 static void show_formats(void)
3841 AVInputFormat *ifmt;
3842 AVOutputFormat *ofmt;
3843 AVImageFormat *image_fmt;
3846 const char **pp, *last_name;
3848 printf("File formats:\n");
3853 const char *name=NULL;
3854 const char *long_name=NULL;
3856 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3857 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3858 strcmp(ofmt->name, last_name)>0){
3860 long_name= ofmt->long_name;
3864 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3865 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3866 strcmp(ifmt->name, last_name)>0){
3868 long_name= ifmt->long_name;
3871 if(name && strcmp(ifmt->name, name)==0)
3883 long_name ? long_name:" ");
3887 printf("Image formats (filename extensions, if any, follow):\n");
3888 for(image_fmt = first_image_format; image_fmt != NULL;
3889 image_fmt = image_fmt->next) {
3892 image_fmt->img_read ? "D":" ",
3893 image_fmt->img_write ? "E":" ",
3895 image_fmt->extensions ? image_fmt->extensions:" ");
3899 printf("Codecs:\n");
3905 const char *type_str;
3908 for(p = first_avcodec; p != NULL; p = p->next) {
3909 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3910 strcmp(p->name, last_name)>0){
3912 decode= encode= cap=0;
3914 if(p2 && strcmp(p->name, p2->name)==0){
3915 if(p->decode) decode=1;
3916 if(p->encode) encode=1;
3917 cap |= p->capabilities;
3922 last_name= p2->name;
3925 case CODEC_TYPE_VIDEO:
3928 case CODEC_TYPE_AUDIO:
3931 case CODEC_TYPE_SUBTITLE:
3940 decode ? "D": (/*p2->decoder ? "d":*/" "),
3943 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3944 cap & CODEC_CAP_DR1 ? "D":" ",
3945 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3947 /* if(p2->decoder && decode==0)
3948 printf(" use %s for decoding", p2->decoder->name);*/
3953 printf("Supported file protocols:\n");
3954 for(up = first_protocol; up != NULL; up = up->next)
3955 printf(" %s:", up->name);
3958 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3959 printf("Motion estimation methods:\n");
3963 if ((pp - motion_str + 1) == ME_ZERO)
3964 printf("(fastest)");
3965 else if ((pp - motion_str + 1) == ME_FULL)
3966 printf("(slowest)");
3967 else if ((pp - motion_str + 1) == ME_EPZS)
3968 printf("(default)");
3973 "Note, the names of encoders and decoders dont always match, so there are\n"
3974 "several cases where the above table shows encoder only or decoder only entries\n"
3975 "even though both encoding and decoding are supported for example, the h263\n"
3976 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3981 void parse_matrix_coeffs(uint16_t *dest, const char *str)
3984 const char *p = str;
3991 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3998 void opt_inter_matrix(const char *arg)
4000 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4001 parse_matrix_coeffs(inter_matrix, arg);
4004 void opt_intra_matrix(const char *arg)
4006 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4007 parse_matrix_coeffs(intra_matrix, arg);
4010 static void opt_target(const char *arg)
4013 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4015 if(!strncmp(arg, "pal-", 4)) {
4018 } else if(!strncmp(arg, "ntsc-", 5)) {
4021 } else if(!strncmp(arg, "film-", 5)) {
4026 /* Calculate FR via float to avoid int overflow */
4027 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
4030 } else if((fr == 29970) || (fr == 23976)) {
4033 /* Try to determine PAL/NTSC by peeking in the input files */
4034 if(nb_input_files) {
4036 for(j = 0; j < nb_input_files; j++) {
4037 for(i = 0; i < input_files[j]->nb_streams; i++) {
4038 AVCodecContext *c = &input_files[j]->streams[i]->codec;
4039 if(c->codec_type != CODEC_TYPE_VIDEO)
4041 fr = c->time_base.den * 1000 / c->time_base.num;
4045 } else if((fr == 29970) || (fr == 23976)) {
4055 if(verbose && norm >= 0)
4056 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
4060 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4061 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4062 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4066 if(!strcmp(arg, "vcd")) {
4068 opt_video_codec("mpeg1video");
4069 opt_audio_codec("mp2");
4072 opt_frame_size(norm ? "352x240" : "352x288");
4073 opt_frame_rate(frame_rates[norm]);
4074 opt_gop_size(norm ? "18" : "15");
4076 video_bit_rate = 1150000;
4077 video_rc_max_rate = 1150000;
4078 video_rc_min_rate = 1150000;
4079 video_rc_buffer_size = 40*1024*8;
4081 audio_bit_rate = 224000;
4082 audio_sample_rate = 44100;
4084 mux_packet_size= 2324;
4085 mux_rate= 2352 * 75 * 8;
4087 /* We have to offset the PTS, so that it is consistent with the SCR.
4088 SCR starts at 36000, but the first two packs contain only padding
4089 and the first pack from the other stream, respectively, may also have
4090 been written before.
4091 So the real data starts at SCR 36000+3*1200. */
4092 mux_preload= (36000+3*1200) / 90000.0; //0.44
4093 } else if(!strcmp(arg, "svcd")) {
4095 opt_video_codec("mpeg2video");
4096 opt_audio_codec("mp2");
4099 opt_frame_size(norm ? "480x480" : "480x576");
4100 opt_frame_rate(frame_rates[norm]);
4101 opt_gop_size(norm ? "18" : "15");
4103 video_bit_rate = 2040000;
4104 video_rc_max_rate = 2516000;
4105 video_rc_min_rate = 0; //1145000;
4106 video_rc_buffer_size = 224*1024*8;
4107 use_scan_offset = 1;
4109 audio_bit_rate = 224000;
4110 audio_sample_rate = 44100;
4112 mux_packet_size= 2324;
4114 } else if(!strcmp(arg, "dvd")) {
4116 opt_video_codec("mpeg2video");
4117 opt_audio_codec("ac3");
4120 opt_frame_size(norm ? "720x480" : "720x576");
4121 opt_frame_rate(frame_rates[norm]);
4122 opt_gop_size(norm ? "18" : "15");
4124 video_bit_rate = 6000000;
4125 video_rc_max_rate = 9000000;
4126 video_rc_min_rate = 0; //1500000;
4127 video_rc_buffer_size = 224*1024*8;
4129 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4130 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4132 audio_bit_rate = 448000;
4133 audio_sample_rate = 48000;
4135 } else if(!strcmp(arg, "dv")) {
4139 opt_frame_size(norm ? "720x480" : "720x576");
4140 opt_frame_rate(frame_rates[norm]);
4142 audio_sample_rate = 48000;
4146 fprintf(stderr, "Unknown target: %s\n", arg);
4151 static void show_version(void)
4153 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
4156 avcodec_build(), LIBAVFORMAT_BUILD);
4160 const OptionDef options[] = {
4162 { "L", 0, {(void*)show_license}, "show license" },
4163 { "h", 0, {(void*)show_help}, "show help" },
4164 { "version", 0, {(void*)show_version}, "show version" },
4165 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
4166 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4167 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
4168 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4169 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4170 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4171 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4172 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
4173 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
4174 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4175 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4176 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4177 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
4178 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
4179 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
4180 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
4181 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
4182 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
4183 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4184 "add timings for benchmarking" },
4185 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4186 "dump each input packet" },
4187 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4188 "when dumping packets, also dump the payload" },
4189 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
4190 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4191 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4192 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "number of times to loop output in formats that support looping (0 loops forever)", "" },
4193 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4194 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4195 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4196 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4197 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4198 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4199 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4200 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4203 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4204 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4205 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4206 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4207 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4208 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4209 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4210 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4211 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4212 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4213 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4214 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4215 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4216 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4217 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4218 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4219 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4220 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4221 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4222 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4223 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4224 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4225 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4226 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4227 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4228 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4229 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4230 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4231 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4232 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4233 { "qsquish", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qsquish}, "how to keep quantiser between qmin and qmax (0 = clip, 1 = use differentiable function)", "squish" },
4234 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4235 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4236 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4237 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4238 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4239 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4240 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4241 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4242 { "b_strategy", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&b_strategy}, "dynamic b frame selection strategy", "strategy" },
4243 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4244 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4245 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4246 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4247 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4248 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4249 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4250 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4252 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
4253 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
4254 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
4255 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
4256 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
4257 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
4258 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4259 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
4260 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
4261 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
4262 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
4263 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
4264 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
4265 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
4266 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4267 { "lelim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lelim}, "single coefficient elimination threshold for luminance (negative values also consider DC coefficient)", "elim" },
4268 { "celim", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_celim}, "single coefficient elimination threshold for chrominance (negative values also consider DC coefficient)", "elim" },
4269 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
4270 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
4271 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
4272 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
4273 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
4274 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
4275 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
4276 { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
4277 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
4278 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4279 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4280 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4281 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4282 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4283 "use same video quality as source (implies VBR)" },
4284 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4285 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4286 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4287 "deinterlace pictures" },
4288 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
4289 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
4290 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
4291 "force interlaced me support in encoder (MPEG2/MPEG4)" },
4292 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4293 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4294 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4295 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
4296 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
4297 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
4298 { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
4299 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
4300 { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
4301 { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
4302 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
4303 { "mv0", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_mv0}, "try to encode each MB with MV=<0,0> and choose the better one (has no effect if mbd=0)" },
4304 { "naq", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_normalize_aqp}, "normalize adaptive quantization" },
4305 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
4306 { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
4307 { "noout", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&no_output}, "skip bitstream encoding" },
4308 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
4309 { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
4310 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4311 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4312 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4313 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
4314 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
4315 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4316 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4317 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4318 { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
4319 { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
4320 { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
4321 { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
4322 { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
4323 { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
4324 { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
4325 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4326 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
4327 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4328 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4329 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4330 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4331 { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
4332 { "gray", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&gray_only }, "encode/decode grayscale" },
4333 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4336 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4337 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4338 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4339 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4340 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4341 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4342 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4343 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4344 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4346 /* subtitle options */
4347 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4348 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4349 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4352 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4353 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4354 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4355 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4357 /* G.2 grab options */
4358 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4359 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4362 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4363 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4364 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4365 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4369 static void show_banner(void)
4371 fprintf(stderr, "ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4373 fprintf(stderr, " configuration: %s\n", FFMPEG_CONFIGURATION);
4374 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4376 fprintf(stderr, ", gcc: %s\n", __VERSION__);
4378 fprintf(stderr, ", using a non-gcc compiler\n");
4382 static void show_license(void)
4387 "This program is free software; you can redistribute it and/or modify\n"
4388 "it under the terms of the GNU General Public License as published by\n"
4389 "the Free Software Foundation; either version 2 of the License, or\n"
4390 "(at your option) any later version.\n"
4392 "This program is distributed in the hope that it will be useful,\n"
4393 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4394 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4395 "GNU General Public License for more details.\n"
4397 "You should have received a copy of the GNU General Public License\n"
4398 "along with this program; if not, write to the Free Software\n"
4399 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4403 "This library is free software; you can redistribute it and/or\n"
4404 "modify it under the terms of the GNU Lesser General Public\n"
4405 "License as published by the Free Software Foundation; either\n"
4406 "version 2 of the License, or (at your option) any later version.\n"
4408 "This library is distributed in the hope that it will be useful,\n"
4409 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4410 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4411 "Lesser General Public License for more details.\n"
4413 "You should have received a copy of the GNU Lesser General Public\n"
4414 "License along with this library; if not, write to the Free Software\n"
4415 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4421 static void show_help(void)
4424 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4425 "Hyper fast Audio and Video encoder\n");
4427 show_help_options(options, "Main options:\n",
4428 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4429 show_help_options(options, "\nVideo options:\n",
4430 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4432 show_help_options(options, "\nAdvanced Video options:\n",
4433 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4434 OPT_VIDEO | OPT_EXPERT);
4435 show_help_options(options, "\nAudio options:\n",
4436 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4438 show_help_options(options, "\nAdvanced Audio options:\n",
4439 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4440 OPT_AUDIO | OPT_EXPERT);
4441 show_help_options(options, "\nSubtitle options:\n",
4442 OPT_SUBTITLE | OPT_GRAB,
4444 show_help_options(options, "\nAudio/Video grab options:\n",
4447 show_help_options(options, "\nAdvanced options:\n",
4448 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4453 void parse_arg_file(const char *filename)
4455 opt_output_file(filename);
4458 int main(int argc, char **argv)
4471 parse_options(argc, argv, options);
4473 /* file converter / grab */
4474 if (nb_output_files <= 0) {
4475 fprintf(stderr, "Must supply at least one output file\n");
4479 if (nb_input_files == 0) {
4485 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4486 stream_maps, nb_stream_maps);
4487 ti = getutime() - ti;
4489 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4493 for(i=0;i<nb_output_files;i++) {
4494 /* maybe av_close_output_file ??? */
4495 AVFormatContext *s = output_files[i];
4497 if (!(s->oformat->flags & AVFMT_NOFILE))
4499 for(j=0;j<s->nb_streams;j++)
4500 av_free(s->streams[j]);
4503 for(i=0;i<nb_input_files;i++)
4504 av_close_input_file(input_files[i]);
4509 av_free(intra_matrix);
4511 av_free(inter_matrix);
4513 #ifdef POWERPC_PERFORMANCE_REPORT
4514 extern void powerpc_display_perf_report(void);
4515 powerpc_display_perf_report();
4516 #endif /* POWERPC_PERFORMANCE_REPORT */
4518 #ifndef CONFIG_WIN32
4519 if (received_sigterm) {
4521 "Received signal %d: terminating.\n",
4522 (int) received_sigterm);
4526 exit(0); /* not all OS-es handle main() return value */