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 float video_qblur = 0.5;
115 static float video_qsquish = 0.0;
116 static float video_qcomp = 0.5;
117 static uint16_t *intra_matrix = NULL;
118 static uint16_t *inter_matrix = NULL;
119 #if 0 //experimental, (can be removed)
120 static float video_rc_qsquish=1.0;
121 static float video_rc_qmod_amp=0;
122 static int video_rc_qmod_freq=0;
124 static char *video_rc_override_string=NULL;
125 static char *video_rc_eq="tex^qComp";
126 static int video_rc_buffer_size=0;
127 static float video_rc_buffer_aggressivity=1.0;
128 static int video_rc_max_rate=0;
129 static int video_rc_min_rate=0;
130 static float video_rc_initial_cplx=0;
131 static float video_b_qfactor = 1.25;
132 static float video_b_qoffset = 1.25;
133 static float video_i_qfactor = -0.8;
134 static float video_i_qoffset = 0.0;
135 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
136 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
137 static int me_method = ME_EPZS;
138 static int video_disable = 0;
139 static int video_discard = 0;
140 static int video_codec_id = CODEC_ID_NONE;
141 static int video_codec_tag = 0;
142 static int same_quality = 0;
143 static int b_frames = 0;
144 static int b_strategy = 0;
145 static int mb_decision = FF_MB_DECISION_SIMPLE;
146 static int ildct_cmp = FF_CMP_VSAD;
147 static int mb_cmp = FF_CMP_SAD;
148 static int sub_cmp = FF_CMP_SAD;
149 static int cmp = FF_CMP_SAD;
150 static int pre_cmp = FF_CMP_SAD;
151 static int pre_me = 0;
152 static float lumi_mask = 0;
153 static float dark_mask = 0;
154 static float scplx_mask = 0;
155 static float tcplx_mask = 0;
156 static float p_mask = 0;
157 static int use_4mv = 0;
158 static int use_obmc = 0;
159 static int use_loop = 0;
160 static int use_aic = 0;
161 static int use_aiv = 0;
162 static int use_umv = 0;
163 static int use_ss = 0;
164 static int use_alt_scan = 0;
165 static int use_trell = 0;
166 static int use_scan_offset = 0;
167 static int use_qpel = 0;
168 static int use_qprd = 0;
169 static int use_cbprd = 0;
170 static int use_mv0 = 0;
171 static int do_normalize_aqp = 0;
173 static int closed_gop = 0;
174 static int strict_gop = 0;
175 static int no_output = 0;
176 static int do_deinterlace = 0;
177 static int do_interlace_dct = 0;
178 static int do_interlace_me = 0;
179 static int workaround_bugs = FF_BUG_AUTODETECT;
180 static int error_resilience = FF_ER_CAREFULL;
181 static int error_concealment = 3;
182 static int dct_algo = 0;
183 static int idct_algo = 0;
184 static int use_part = 0;
185 static int packet_size = 0;
186 static int error_rate = 0;
187 static int strict = 0;
188 static int top_field_first = -1;
189 static int noise_reduction = 0;
190 static int sc_threshold = 0;
191 static int debug = 0;
192 static int debug_mv = 0;
193 static int me_threshold = 0;
194 static int mb_threshold = 0;
195 static int intra_dc_precision = 8;
196 static int coder = 0;
197 static int context = 0;
198 static int predictor = 0;
199 static int video_profile = FF_PROFILE_UNKNOWN;
200 static int video_level = FF_LEVEL_UNKNOWN;
201 static int nsse_weight = 8;
202 static int subpel_quality= 8;
203 static int me_penalty_compensation= 256;
204 static int lowres= 0;
205 static int frame_skip_threshold= 0;
206 static int frame_skip_factor= 0;
207 static int frame_skip_exp= 0;
208 static int frame_skip_cmp= FF_CMP_DCTMAX;
209 extern int loop_input; /* currently a hack */
210 static int loop_output = AVFMT_NOOUTPUTLOOP;
211 static int gray_only = 0;
212 static int genpts = 0;
214 static int gop_size = 12;
215 static int intra_only = 0;
216 static int audio_sample_rate = 44100;
217 static int audio_bit_rate = 64000;
218 #define QSCALE_NONE -99999
219 static float audio_qscale = QSCALE_NONE;
220 static int audio_disable = 0;
221 static int audio_channels = 1;
222 static int audio_codec_id = CODEC_ID_NONE;
223 static int audio_codec_tag = 0;
224 static char *audio_language = NULL;
226 static int subtitle_codec_id = CODEC_ID_NONE;
227 static char *subtitle_language = NULL;
229 static int mux_rate= 0;
230 static int mux_packet_size= 0;
231 static float mux_preload= 0.5;
232 static float mux_max_delay= 0.7;
234 static int64_t recording_time = 0;
235 static int64_t start_time = 0;
236 static int64_t rec_timestamp = 0;
237 static int64_t input_ts_offset = 0;
238 static int file_overwrite = 0;
239 static char *str_title = NULL;
240 static char *str_author = NULL;
241 static char *str_copyright = NULL;
242 static char *str_comment = NULL;
243 static int do_benchmark = 0;
244 static int do_hex_dump = 0;
245 static int do_pkt_dump = 0;
246 static int do_psnr = 0;
247 static int do_vstats = 0;
248 static int do_pass = 0;
249 static int bitexact = 0;
250 static char *pass_logfilename = NULL;
251 static int audio_stream_copy = 0;
252 static int video_stream_copy = 0;
253 static int subtitle_stream_copy = 0;
254 static int video_sync_method= 1;
255 static int audio_sync_method= 0;
256 static int copy_ts= 0;
257 static int opt_shortest = 0; //
258 static int video_global_header = 0;
260 static int rate_emu = 0;
263 static char *video_grab_format = "bktr";
265 static char *video_grab_format = "video4linux";
267 static char *video_device = NULL;
268 static char *grab_device = NULL;
269 static int video_channel = 0;
270 static char *video_standard = "ntsc";
272 static char *audio_grab_format = "audio_device";
273 static char *audio_device = NULL;
274 static int audio_volume = 256;
276 static int using_stdin = 0;
277 static int using_vhook = 0;
278 static int verbose = 1;
279 static int thread_count= 1;
280 static int q_pressed = 0;
281 static int me_range = 0;
282 static int64_t video_size = 0;
283 static int64_t audio_size = 0;
284 static int64_t extra_size = 0;
285 static int nb_frames_dup = 0;
286 static int nb_frames_drop = 0;
287 static int input_sync;
288 static int limit_filesize = 0; //
290 static int pgmyuv_compatibility_hack=0;
292 const char **opt_names=NULL;
293 int opt_name_count=0;
294 AVCodecContext *avctx_opts;
297 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
299 struct AVInputStream;
301 typedef struct AVOutputStream {
302 int file_index; /* file index */
303 int index; /* stream index in the output file */
304 int source_index; /* AVInputStream index */
305 AVStream *st; /* stream in the output file */
306 int encoding_needed; /* true if encoding needed for this stream */
308 /* input pts and corresponding output pts
310 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
311 struct AVInputStream *sync_ist; /* input stream to sync against */
312 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
314 int video_resample; /* video_resample and video_crop are mutually exclusive */
315 AVFrame pict_tmp; /* temporary image for resampling */
316 ImgReSampleContext *img_resample_ctx; /* for image resampling */
318 int video_crop; /* video_resample and video_crop are mutually exclusive */
319 int topBand; /* cropping area sizes */
322 int video_pad; /* video_resample and video_pad are mutually exclusive */
323 int padtop; /* padding area sizes */
330 ReSampleContext *resample; /* for audio resampling */
331 FifoBuffer fifo; /* for compression: one audio fifo per codec */
335 typedef struct AVInputStream {
339 int discard; /* true if stream data should be discarded */
340 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
341 int64_t sample_index; /* current sample */
343 int64_t start; /* time when read started */
344 unsigned long frame; /* current frame */
345 int64_t next_pts; /* synthetic pts for cases where pkt.pts
347 int64_t pts; /* current pts */
348 int is_start; /* is 1 at the start and after a discontinuity */
351 typedef struct AVInputFile {
352 int eof_reached; /* true if eof reached */
353 int ist_index; /* index of first stream in ist_table */
354 int buffer_size; /* current total buffer size */
355 int buffer_size_max; /* buffer size at which we consider we can stop
357 int nb_streams; /* nb streams we are aware of */
362 /* init terminal so that we can grab keys */
363 static struct termios oldtty;
365 static void term_exit(void)
367 tcsetattr (0, TCSANOW, &oldtty);
370 static volatile sig_atomic_t received_sigterm = 0;
373 sigterm_handler(int sig)
375 received_sigterm = sig;
379 static void term_init(void)
386 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
387 |INLCR|IGNCR|ICRNL|IXON);
388 tty.c_oflag |= OPOST;
389 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
390 tty.c_cflag &= ~(CSIZE|PARENB);
395 tcsetattr (0, TCSANOW, &tty);
397 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
398 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
399 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
401 register a function to be called at normal program termination
404 #ifdef CONFIG_BEOS_NETSERVER
405 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
409 /* read a key without blocking */
410 static int read_key(void)
414 #ifndef CONFIG_BEOS_NETSERVER
422 n = select(1, &rfds, NULL, NULL, &tv);
434 static int decode_interrupt_cb(void)
436 return q_pressed || (q_pressed = read_key() == 'q');
441 static volatile int received_sigterm = 0;
443 /* no interactive support */
444 static void term_exit(void)
448 static void term_init(void)
452 static int read_key(void)
459 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
464 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
467 /* copy stream format */
468 s->nb_streams = ic->nb_streams;
469 for(i=0;i<ic->nb_streams;i++) {
472 st = av_mallocz(sizeof(AVStream));
473 memcpy(st, ic->streams[i], sizeof(AVStream));
477 av_close_input_file(ic);
482 get_sync_ipts(const AVOutputStream *ost)
484 const AVInputStream *ist = ost->sync_ist;
485 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
488 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
490 static void do_audio_out(AVFormatContext *s,
493 unsigned char *buf, int size)
496 static uint8_t *audio_buf = NULL;
497 static uint8_t *audio_out = NULL;
498 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
500 int size_out, frame_bytes, ret;
501 AVCodecContext *enc= ost->st->codec;
503 /* SC: dynamic allocation of buffers */
505 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
507 audio_out = av_malloc(audio_out_size);
508 if (!audio_buf || !audio_out)
509 return; /* Should signal an error ! */
511 if(audio_sync_method){
512 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
513 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
514 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
515 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
517 //FIXME resample delay
518 if(fabs(delta) > 50){
521 byte_delta= FFMAX(byte_delta, -size);
525 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
530 static uint8_t *input_tmp= NULL;
531 input_tmp= av_realloc(input_tmp, byte_delta + size);
533 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
536 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
538 memset(input_tmp, 0, byte_delta);
539 memcpy(input_tmp + byte_delta, buf, size);
543 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
545 }else if(audio_sync_method>1){
546 int comp= clip(delta, -audio_sync_method, audio_sync_method);
547 assert(ost->audio_resample);
549 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
550 // 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));
551 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
555 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
556 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
558 if (ost->audio_resample) {
560 size_out = audio_resample(ost->resample,
561 (short *)buftmp, (short *)buf,
562 size / (ist->st->codec->channels * 2));
563 size_out = size_out * enc->channels * 2;
569 /* now encode as many frames as possible */
570 if (enc->frame_size > 1) {
571 /* output resampled raw samples */
572 fifo_write(&ost->fifo, buftmp, size_out,
575 frame_bytes = enc->frame_size * 2 * enc->channels;
577 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
578 &ost->fifo.rptr) == 0) {
580 av_init_packet(&pkt);
582 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
585 pkt.stream_index= ost->index;
588 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
589 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
590 pkt.flags |= PKT_FLAG_KEY;
591 av_interleaved_write_frame(s, &pkt);
593 ost->sync_opts += enc->frame_size;
597 av_init_packet(&pkt);
599 ost->sync_opts += size_out / (2 * enc->channels);
601 /* output a pcm frame */
602 /* XXX: change encoding codec API to avoid this ? */
603 switch(enc->codec->id) {
604 case CODEC_ID_PCM_S32LE:
605 case CODEC_ID_PCM_S32BE:
606 case CODEC_ID_PCM_U32LE:
607 case CODEC_ID_PCM_U32BE:
608 size_out = size_out << 1;
610 case CODEC_ID_PCM_S24LE:
611 case CODEC_ID_PCM_S24BE:
612 case CODEC_ID_PCM_U24LE:
613 case CODEC_ID_PCM_U24BE:
614 case CODEC_ID_PCM_S24DAUD:
615 size_out = size_out / 2 * 3;
617 case CODEC_ID_PCM_S16LE:
618 case CODEC_ID_PCM_S16BE:
619 case CODEC_ID_PCM_U16LE:
620 case CODEC_ID_PCM_U16BE:
623 size_out = size_out >> 1;
626 ret = avcodec_encode_audio(enc, audio_out, size_out,
629 pkt.stream_index= ost->index;
632 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
633 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
634 pkt.flags |= PKT_FLAG_KEY;
635 av_interleaved_write_frame(s, &pkt);
639 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
643 AVPicture picture_tmp;
646 dec = ist->st->codec;
648 /* deinterlace : must be done before any resize */
649 if (do_deinterlace || using_vhook) {
652 /* create temporary picture */
653 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
654 buf = av_malloc(size);
658 picture2 = &picture_tmp;
659 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
662 if(avpicture_deinterlace(picture2, picture,
663 dec->pix_fmt, dec->width, dec->height) < 0) {
664 /* if error, do not deinterlace */
670 if (img_convert(picture2, dec->pix_fmt, picture,
671 dec->pix_fmt, dec->width, dec->height) < 0) {
672 /* if error, do not copy */
682 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
684 if (picture != picture2)
685 *picture = *picture2;
689 /* we begin to correct av delay at this threshold */
690 #define AV_DELAY_MAX 0.100
693 /* Expects img to be yuv420 */
694 static void fill_pad_region(AVPicture* img, int height, int width,
695 int padtop, int padbottom, int padleft, int padright, int *color) {
700 for (i = 0; i < 3; i++) {
701 shift = (i == 0) ? 0 : 1;
703 if (padtop || padleft) {
704 memset(img->data[i], color[i], (((img->linesize[i] * padtop) +
708 if (padleft || padright) {
709 optr = img->data[i] + (img->linesize[i] * (padtop >> shift)) +
710 (img->linesize[i] - (padright >> shift));
712 for (y = 0; y < ((height - (padtop + padbottom) - 1) >> shift); y++) {
713 memset(optr, color[i], (padleft + padright) >> shift);
714 optr += img->linesize[i];
718 if (padbottom || padright) {
719 optr = img->data[i] + (((img->linesize[i] * (height - padbottom)) - padright) >> shift);
720 memset(optr, color[i], (((img->linesize[i] * padbottom) + padright) >> shift));
725 static void do_subtitle_out(AVFormatContext *s,
731 static uint8_t *subtitle_out = NULL;
732 int subtitle_out_max_size = 65536;
733 int subtitle_out_size, nb, i;
737 if (pts == AV_NOPTS_VALUE) {
738 fprintf(stderr, "Subtitle packets must have a pts\n");
742 enc = ost->st->codec;
745 subtitle_out = av_malloc(subtitle_out_max_size);
748 /* Note: DVB subtitle need one packet to draw them and one other
749 packet to clear them */
750 /* XXX: signal it in the codec context ? */
751 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
756 for(i = 0; i < nb; i++) {
757 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
758 subtitle_out_max_size, sub);
760 av_init_packet(&pkt);
761 pkt.stream_index = ost->index;
762 pkt.data = subtitle_out;
763 pkt.size = subtitle_out_size;
764 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);
765 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
766 /* XXX: the pts correction is handled here. Maybe handling
767 it in the codec would be better */
769 pkt.pts += 90 * sub->start_display_time;
771 pkt.pts += 90 * sub->end_display_time;
773 av_interleaved_write_frame(s, &pkt);
777 static int bit_buffer_size= 1024*256;
778 static uint8_t *bit_buffer= NULL;
780 static void do_video_out(AVFormatContext *s,
786 int nb_frames, i, ret;
787 AVFrame *final_picture, *formatted_picture;
788 AVFrame picture_format_temp, picture_crop_temp;
789 uint8_t *buf = NULL, *buf1 = NULL;
790 AVCodecContext *enc, *dec;
791 enum PixelFormat target_pixfmt;
793 avcodec_get_frame_defaults(&picture_format_temp);
794 avcodec_get_frame_defaults(&picture_crop_temp);
796 enc = ost->st->codec;
797 dec = ist->st->codec;
799 /* by default, we output a single frame */
804 if(video_sync_method){
806 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
807 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
810 else if (vdelta > 1.1)
811 nb_frames = lrintf(vdelta);
812 //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);
816 fprintf(stderr, "*** drop!\n");
817 }else if (nb_frames > 1) {
818 nb_frames_dup += nb_frames;
820 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
823 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
825 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
829 /* convert pixel format if needed */
830 target_pixfmt = ost->video_resample || ost->video_pad
831 ? PIX_FMT_YUV420P : enc->pix_fmt;
832 if (dec->pix_fmt != target_pixfmt) {
835 /* create temporary picture */
836 size = avpicture_get_size(target_pixfmt, dec->width, dec->height);
837 buf = av_malloc(size);
840 formatted_picture = &picture_format_temp;
841 avpicture_fill((AVPicture*)formatted_picture, buf, target_pixfmt, dec->width, dec->height);
843 if (img_convert((AVPicture*)formatted_picture, target_pixfmt,
844 (AVPicture *)in_picture, dec->pix_fmt,
845 dec->width, dec->height) < 0) {
848 fprintf(stderr, "pixel format conversion not handled\n");
853 formatted_picture = in_picture;
856 /* XXX: resampling could be done before raw format conversion in
857 some cases to go faster */
858 /* XXX: only works for YUV420P */
859 if (ost->video_resample) {
860 final_picture = &ost->pict_tmp;
861 img_resample(ost->img_resample_ctx, (AVPicture*)final_picture, (AVPicture*)formatted_picture);
863 if (ost->padtop || ost->padbottom || ost->padleft || ost->padright) {
864 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
865 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
869 if (enc->pix_fmt != PIX_FMT_YUV420P) {
873 /* create temporary picture */
874 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
875 buf = av_malloc(size);
878 final_picture = &picture_format_temp;
879 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
881 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
882 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
883 enc->width, enc->height) < 0) {
886 fprintf(stderr, "pixel format conversion not handled\n");
891 } else if (ost->video_crop) {
892 picture_crop_temp.data[0] = formatted_picture->data[0] +
893 (ost->topBand * formatted_picture->linesize[0]) + ost->leftBand;
895 picture_crop_temp.data[1] = formatted_picture->data[1] +
896 ((ost->topBand >> 1) * formatted_picture->linesize[1]) +
897 (ost->leftBand >> 1);
899 picture_crop_temp.data[2] = formatted_picture->data[2] +
900 ((ost->topBand >> 1) * formatted_picture->linesize[2]) +
901 (ost->leftBand >> 1);
903 picture_crop_temp.linesize[0] = formatted_picture->linesize[0];
904 picture_crop_temp.linesize[1] = formatted_picture->linesize[1];
905 picture_crop_temp.linesize[2] = formatted_picture->linesize[2];
906 final_picture = &picture_crop_temp;
907 } else if (ost->video_pad) {
908 final_picture = &ost->pict_tmp;
910 for (i = 0; i < 3; i++) {
911 uint8_t *optr, *iptr;
912 int shift = (i == 0) ? 0 : 1;
915 /* set offset to start writing image into */
916 optr = final_picture->data[i] + (((final_picture->linesize[i] *
917 ost->padtop) + ost->padleft) >> shift);
918 iptr = formatted_picture->data[i];
920 yheight = (enc->height - ost->padtop - ost->padbottom) >> shift;
921 for (y = 0; y < yheight; y++) {
922 /* copy unpadded image row into padded image row */
923 memcpy(optr, iptr, formatted_picture->linesize[i]);
924 optr += final_picture->linesize[i];
925 iptr += formatted_picture->linesize[i];
929 fill_pad_region((AVPicture*)final_picture, enc->height, enc->width,
930 ost->padtop, ost->padbottom, ost->padleft, ost->padright,
933 if (enc->pix_fmt != PIX_FMT_YUV420P) {
937 /* create temporary picture */
938 size = avpicture_get_size(enc->pix_fmt, enc->width, enc->height);
939 buf = av_malloc(size);
942 final_picture = &picture_format_temp;
943 avpicture_fill((AVPicture*)final_picture, buf, enc->pix_fmt, enc->width, enc->height);
945 if (img_convert((AVPicture*)final_picture, enc->pix_fmt,
946 (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
947 enc->width, enc->height) < 0) {
950 fprintf(stderr, "pixel format conversion not handled\n");
956 final_picture = formatted_picture;
958 /* duplicates frame if needed */
959 for(i=0;i<nb_frames;i++) {
961 av_init_packet(&pkt);
962 pkt.stream_index= ost->index;
964 if (s->oformat->flags & AVFMT_RAWPICTURE) {
965 /* raw pictures are written as AVPicture structure to
966 avoid any copies. We support temorarily the older
968 AVFrame* old_frame = enc->coded_frame;
969 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
970 pkt.data= (uint8_t *)final_picture;
971 pkt.size= sizeof(AVPicture);
972 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
973 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
974 if(dec->coded_frame && dec->coded_frame->key_frame)
975 pkt.flags |= PKT_FLAG_KEY;
977 av_interleaved_write_frame(s, &pkt);
978 enc->coded_frame = old_frame;
982 big_picture= *final_picture;
983 /* better than nothing: use input picture interlaced
985 big_picture.interlaced_frame = in_picture->interlaced_frame;
986 if(do_interlace_me || do_interlace_dct){
987 if(top_field_first == -1)
988 big_picture.top_field_first = in_picture->top_field_first;
990 big_picture.top_field_first = top_field_first;
993 /* handles sameq here. This is not correct because it may
994 not be a global option */
996 big_picture.quality = ist->st->quality;
998 big_picture.quality = ost->st->quality;
1000 big_picture.pict_type = 0;
1001 // big_picture.pts = AV_NOPTS_VALUE;
1002 big_picture.pts= ost->sync_opts;
1003 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1004 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
1005 ret = avcodec_encode_video(enc,
1006 bit_buffer, bit_buffer_size,
1008 //enc->frame_number = enc->real_pict_num;
1010 pkt.data= bit_buffer;
1012 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1013 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1014 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
1015 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1016 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1018 if(enc->coded_frame && enc->coded_frame->key_frame)
1019 pkt.flags |= PKT_FLAG_KEY;
1020 av_interleaved_write_frame(s, &pkt);
1022 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
1023 // enc->frame_number-1, enc->real_pict_num, ret,
1025 /* if two pass, output log */
1026 if (ost->logfile && enc->stats_out) {
1027 fprintf(ost->logfile, "%s", enc->stats_out);
1032 ost->frame_number++;
1039 static double psnr(double d){
1040 if(d==0) return INFINITY;
1041 return -10.0*log(d)/log(10.0);
1044 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1047 static FILE *fvstats=NULL;
1051 AVCodecContext *enc;
1054 double ti1, bitrate, avg_bitrate;
1057 today2 = time(NULL);
1058 today = localtime(&today2);
1059 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
1062 fvstats = fopen(filename,"w");
1070 enc = ost->st->codec;
1071 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1072 frame_number = ost->frame_number;
1073 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1074 if (enc->flags&CODEC_FLAG_PSNR)
1075 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1077 fprintf(fvstats,"f_size= %6d ", frame_size);
1078 /* compute pts value */
1079 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1083 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1084 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1085 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1086 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1087 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1091 static void print_report(AVFormatContext **output_files,
1092 AVOutputStream **ost_table, int nb_ostreams,
1096 AVOutputStream *ost;
1097 AVFormatContext *oc, *os;
1099 AVCodecContext *enc;
1100 int frame_number, vid, i;
1101 double bitrate, ti1, pts;
1102 static int64_t last_time = -1;
1104 if (!is_last_report) {
1106 /* display the report every 0.5 seconds */
1107 cur_time = av_gettime();
1108 if (last_time == -1) {
1109 last_time = cur_time;
1112 if ((cur_time - last_time) < 500000)
1114 last_time = cur_time;
1118 oc = output_files[0];
1120 total_size = url_ftell(&oc->pb);
1125 for(i=0;i<nb_ostreams;i++) {
1127 os = output_files[ost->file_index];
1128 enc = ost->st->codec;
1129 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1130 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1131 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1133 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1134 frame_number = ost->frame_number;
1135 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%2.1f ",
1136 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : 0);
1138 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1139 if (enc->flags&CODEC_FLAG_PSNR){
1141 double error, error_sum=0;
1142 double scale, scale_sum=0;
1143 char type[3]= {'Y','U','V'};
1144 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1147 error= enc->error[j];
1148 scale= enc->width*enc->height*255.0*255.0*frame_number;
1150 error= enc->coded_frame->error[j];
1151 scale= enc->width*enc->height*255.0*255.0;
1156 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1158 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1162 /* compute min output value */
1163 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1164 if ((pts < ti1) && (pts > 0))
1170 if (verbose || is_last_report) {
1171 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1173 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1174 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1175 (double)total_size / 1024, ti1, bitrate);
1178 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1179 nb_frames_dup, nb_frames_drop);
1182 fprintf(stderr, "%s \r", buf);
1187 if (is_last_report && verbose >= 0){
1188 int64_t raw= audio_size + video_size + extra_size;
1189 fprintf(stderr, "\n");
1190 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1194 100.0*(total_size - raw)/raw
1199 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1200 static int output_packet(AVInputStream *ist, int ist_index,
1201 AVOutputStream **ost_table, int nb_ostreams,
1202 const AVPacket *pkt)
1204 AVFormatContext *os;
1205 AVOutputStream *ost;
1209 int data_size, got_picture;
1211 void *buffer_to_free;
1212 static int samples_size= 0;
1213 static short *samples= NULL;
1214 AVSubtitle subtitle, *subtitle_to_free;
1218 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1219 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1220 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1222 // assert(ist->pts == ist->next_pts);
1236 /* decode the packet if needed */
1237 data_buf = NULL; /* fail safe */
1239 subtitle_to_free = NULL;
1240 if (ist->decoding_needed) {
1241 switch(ist->st->codec->codec_type) {
1242 case CODEC_TYPE_AUDIO:{
1244 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1245 /* XXX: could avoid copy if PCM 16 bits with same
1246 endianness as CPU */
1247 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1253 /* Some bug in mpeg audio decoder gives */
1254 /* data_size < 0, it seems they are overflows */
1255 if (data_size <= 0) {
1256 /* no audio frame */
1259 data_buf = (uint8_t *)samples;
1260 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1261 (ist->st->codec->sample_rate * ist->st->codec->channels);
1263 case CODEC_TYPE_VIDEO:
1264 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1265 /* XXX: allocate picture correctly */
1266 avcodec_get_frame_defaults(&picture);
1268 ret = avcodec_decode_video(ist->st->codec,
1269 &picture, &got_picture, ptr, len);
1270 ist->st->quality= picture.quality;
1274 /* no picture yet */
1275 goto discard_packet;
1277 if (ist->st->codec->time_base.num != 0) {
1278 ist->next_pts += ((int64_t)AV_TIME_BASE *
1279 ist->st->codec->time_base.num) /
1280 ist->st->codec->time_base.den;
1284 case CODEC_TYPE_SUBTITLE:
1285 ret = avcodec_decode_subtitle(ist->st->codec,
1286 &subtitle, &got_subtitle, ptr, len);
1289 if (!got_subtitle) {
1290 goto discard_packet;
1292 subtitle_to_free = &subtitle;
1299 switch(ist->st->codec->codec_type) {
1300 case CODEC_TYPE_AUDIO:
1301 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1302 (ist->st->codec->sample_rate * ist->st->codec->channels);
1304 case CODEC_TYPE_VIDEO:
1305 if (ist->st->codec->time_base.num != 0) {
1306 ist->next_pts += ((int64_t)AV_TIME_BASE *
1307 ist->st->codec->time_base.num) /
1308 ist->st->codec->time_base.den;
1318 buffer_to_free = NULL;
1319 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1320 pre_process_video_frame(ist, (AVPicture *)&picture,
1324 // preprocess audio (volume)
1325 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1326 if (audio_volume != 256) {
1329 for(i=0;i<(data_size / sizeof(short));i++) {
1330 int v = ((*volp) * audio_volume + 128) >> 8;
1331 if (v < -32768) v = -32768;
1332 if (v > 32767) v = 32767;
1338 /* frame rate emulation */
1339 if (ist->st->codec->rate_emu) {
1340 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1341 int64_t now = av_gettime() - ist->start;
1349 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1350 is the one of the next displayed one */
1351 /* XXX: add mpeg4 too ? */
1352 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1353 if (ist->st->codec->pict_type != B_TYPE) {
1355 tmp = ist->last_ip_pts;
1356 ist->last_ip_pts = ist->frac_pts.val;
1357 ist->frac_pts.val = tmp;
1361 /* if output time reached then transcode raw format,
1362 encode packets and output them */
1363 if (start_time == 0 || ist->pts >= start_time)
1364 for(i=0;i<nb_ostreams;i++) {
1368 if (ost->source_index == ist_index) {
1369 os = output_files[ost->file_index];
1372 printf("%d: got pts=%0.3f %0.3f\n", i,
1373 (double)pkt->pts / AV_TIME_BASE,
1374 ((double)ist->pts / AV_TIME_BASE) -
1375 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1377 /* set the input output pts pairs */
1378 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1380 if (ost->encoding_needed) {
1381 switch(ost->st->codec->codec_type) {
1382 case CODEC_TYPE_AUDIO:
1383 do_audio_out(os, ost, ist, data_buf, data_size);
1385 case CODEC_TYPE_VIDEO:
1386 do_video_out(os, ost, ist, &picture, &frame_size);
1387 video_size += frame_size;
1388 if (do_vstats && frame_size)
1389 do_video_stats(os, ost, frame_size);
1391 case CODEC_TYPE_SUBTITLE:
1392 do_subtitle_out(os, ost, ist, &subtitle,
1399 AVFrame avframe; //FIXME/XXX remove this
1401 av_init_packet(&opkt);
1403 /* no reencoding needed : output the packet directly */
1404 /* force the input stream PTS */
1406 avcodec_get_frame_defaults(&avframe);
1407 ost->st->codec->coded_frame= &avframe;
1408 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1410 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1411 audio_size += data_size;
1412 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1413 video_size += data_size;
1417 opkt.stream_index= ost->index;
1418 if(pkt->pts != AV_NOPTS_VALUE)
1419 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);
1421 opkt.pts= AV_NOPTS_VALUE;
1425 if (pkt->dts == AV_NOPTS_VALUE)
1426 dts = ist->next_pts;
1428 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1429 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1431 opkt.flags= pkt->flags;
1432 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1433 opkt.destruct= av_destruct_packet;
1434 av_interleaved_write_frame(os, &opkt);
1435 ost->st->codec->frame_number++;
1436 ost->frame_number++;
1437 av_free_packet(&opkt);
1441 av_free(buffer_to_free);
1442 /* XXX: allocate the subtitles in the codec ? */
1443 if (subtitle_to_free) {
1444 if (subtitle_to_free->rects != NULL) {
1445 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1446 av_free(subtitle_to_free->rects[i].bitmap);
1447 av_free(subtitle_to_free->rects[i].rgba_palette);
1449 av_freep(&subtitle_to_free->rects);
1451 subtitle_to_free->num_rects = 0;
1452 subtitle_to_free = NULL;
1459 for(i=0;i<nb_ostreams;i++) {
1461 if (ost->source_index == ist_index) {
1462 AVCodecContext *enc= ost->st->codec;
1463 os = output_files[ost->file_index];
1465 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1467 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1470 if (ost->encoding_needed) {
1473 av_init_packet(&pkt);
1474 pkt.stream_index= ost->index;
1476 switch(ost->st->codec->codec_type) {
1477 case CODEC_TYPE_AUDIO:
1478 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1480 pkt.flags |= PKT_FLAG_KEY;
1482 case CODEC_TYPE_VIDEO:
1483 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1485 if(enc->coded_frame && enc->coded_frame->key_frame)
1486 pkt.flags |= PKT_FLAG_KEY;
1487 if (ost->logfile && enc->stats_out) {
1488 fprintf(ost->logfile, "%s", enc->stats_out);
1497 pkt.data= bit_buffer;
1499 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1500 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1501 av_interleaved_write_frame(os, &pkt);
1515 * The following code is the main loop of the file converter
1517 static int av_encode(AVFormatContext **output_files,
1518 int nb_output_files,
1519 AVFormatContext **input_files,
1521 AVStreamMap *stream_maps, int nb_stream_maps)
1523 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1524 AVFormatContext *is, *os;
1525 AVCodecContext *codec, *icodec;
1526 AVOutputStream *ost, **ost_table = NULL;
1527 AVInputStream *ist, **ist_table = NULL;
1528 AVInputFile *file_table;
1529 AVFormatContext *stream_no_data;
1532 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1536 /* input stream init */
1538 for(i=0;i<nb_input_files;i++) {
1539 is = input_files[i];
1540 file_table[i].ist_index = j;
1541 file_table[i].nb_streams = is->nb_streams;
1542 j += is->nb_streams;
1546 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1550 for(i=0;i<nb_istreams;i++) {
1551 ist = av_mallocz(sizeof(AVInputStream));
1557 for(i=0;i<nb_input_files;i++) {
1558 is = input_files[i];
1559 for(k=0;k<is->nb_streams;k++) {
1560 ist = ist_table[j++];
1561 ist->st = is->streams[k];
1562 ist->file_index = i;
1564 ist->discard = 1; /* the stream is discarded by default
1567 if (ist->st->codec->rate_emu) {
1568 ist->start = av_gettime();
1574 /* output stream init */
1576 for(i=0;i<nb_output_files;i++) {
1577 os = output_files[i];
1578 nb_ostreams += os->nb_streams;
1580 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1581 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1585 /* Sanity check the mapping args -- do the input files & streams exist? */
1586 for(i=0;i<nb_stream_maps;i++) {
1587 int fi = stream_maps[i].file_index;
1588 int si = stream_maps[i].stream_index;
1590 if (fi < 0 || fi > nb_input_files - 1 ||
1591 si < 0 || si > file_table[fi].nb_streams - 1) {
1592 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1595 fi = stream_maps[i].sync_file_index;
1596 si = stream_maps[i].sync_stream_index;
1597 if (fi < 0 || fi > nb_input_files - 1 ||
1598 si < 0 || si > file_table[fi].nb_streams - 1) {
1599 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1604 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1607 for(i=0;i<nb_ostreams;i++) {
1608 ost = av_mallocz(sizeof(AVOutputStream));
1615 for(k=0;k<nb_output_files;k++) {
1616 os = output_files[k];
1617 for(i=0;i<os->nb_streams;i++) {
1619 ost = ost_table[n++];
1620 ost->file_index = k;
1622 ost->st = os->streams[i];
1623 if (nb_stream_maps > 0) {
1624 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1625 stream_maps[n-1].stream_index;
1627 /* Sanity check that the stream types match */
1628 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1629 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1630 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1631 ost->file_index, ost->index);
1636 /* get corresponding input stream index : we select the first one with the right type */
1638 for(j=0;j<nb_istreams;j++) {
1641 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1642 ost->source_index = j;
1649 /* try again and reuse existing stream */
1650 for(j=0;j<nb_istreams;j++) {
1652 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1653 ost->source_index = j;
1658 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1659 ost->file_index, ost->index);
1664 ist = ist_table[ost->source_index];
1666 ost->sync_ist = (nb_stream_maps > 0) ?
1667 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1668 stream_maps[n-1].sync_stream_index] : ist;
1672 /* for each output stream, we compute the right encoding parameters */
1673 for(i=0;i<nb_ostreams;i++) {
1675 ist = ist_table[ost->source_index];
1677 codec = ost->st->codec;
1678 icodec = ist->st->codec;
1680 if (ost->st->stream_copy) {
1681 /* if stream_copy is selected, no need to decode or encode */
1682 codec->codec_id = icodec->codec_id;
1683 codec->codec_type = icodec->codec_type;
1684 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1685 codec->bit_rate = icodec->bit_rate;
1686 codec->extradata= icodec->extradata;
1687 codec->extradata_size= icodec->extradata_size;
1688 codec->time_base = icodec->time_base;
1689 switch(codec->codec_type) {
1690 case CODEC_TYPE_AUDIO:
1691 codec->sample_rate = icodec->sample_rate;
1692 codec->channels = icodec->channels;
1693 codec->frame_size = icodec->frame_size;
1694 codec->block_align= icodec->block_align;
1696 case CODEC_TYPE_VIDEO:
1697 codec->width = icodec->width;
1698 codec->height = icodec->height;
1699 codec->has_b_frames = icodec->has_b_frames;
1701 case CODEC_TYPE_SUBTITLE:
1707 switch(codec->codec_type) {
1708 case CODEC_TYPE_AUDIO:
1709 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1712 if (codec->channels == icodec->channels &&
1713 codec->sample_rate == icodec->sample_rate) {
1714 ost->audio_resample = 0;
1716 if (codec->channels != icodec->channels &&
1717 (icodec->codec_id == CODEC_ID_AC3 ||
1718 icodec->codec_id == CODEC_ID_DTS)) {
1719 /* Special case for 5:1 AC3 and DTS input */
1720 /* and mono or stereo output */
1721 /* Request specific number of channels */
1722 icodec->channels = codec->channels;
1723 if (codec->sample_rate == icodec->sample_rate)
1724 ost->audio_resample = 0;
1726 ost->audio_resample = 1;
1729 ost->audio_resample = 1;
1732 if(audio_sync_method>1)
1733 ost->audio_resample = 1;
1735 if(ost->audio_resample){
1736 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1737 codec->sample_rate, icodec->sample_rate);
1739 printf("Can't resample. Aborting.\n");
1743 ist->decoding_needed = 1;
1744 ost->encoding_needed = 1;
1746 case CODEC_TYPE_VIDEO:
1747 if (codec->width == icodec->width &&
1748 codec->height == icodec->height &&
1749 frame_topBand == 0 &&
1750 frame_bottomBand == 0 &&
1751 frame_leftBand == 0 &&
1752 frame_rightBand == 0 &&
1753 frame_padtop == 0 &&
1754 frame_padbottom == 0 &&
1755 frame_padleft == 0 &&
1756 frame_padright == 0)
1758 ost->video_resample = 0;
1759 ost->video_crop = 0;
1761 } else if ((codec->width == icodec->width -
1762 (frame_leftBand + frame_rightBand)) &&
1763 (codec->height == icodec->height -
1764 (frame_topBand + frame_bottomBand)))
1766 ost->video_resample = 0;
1767 ost->video_crop = 1;
1768 ost->topBand = frame_topBand;
1769 ost->leftBand = frame_leftBand;
1770 } else if ((codec->width == icodec->width +
1771 (frame_padleft + frame_padright)) &&
1772 (codec->height == icodec->height +
1773 (frame_padtop + frame_padbottom))) {
1774 ost->video_resample = 0;
1775 ost->video_crop = 0;
1777 ost->padtop = frame_padtop;
1778 ost->padleft = frame_padleft;
1779 ost->padbottom = frame_padbottom;
1780 ost->padright = frame_padright;
1781 avcodec_get_frame_defaults(&ost->pict_tmp);
1782 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1783 codec->width, codec->height ) )
1786 ost->video_resample = 1;
1787 ost->video_crop = 0; // cropping is handled as part of resample
1788 avcodec_get_frame_defaults(&ost->pict_tmp);
1789 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, PIX_FMT_YUV420P,
1790 codec->width, codec->height ) )
1793 ost->img_resample_ctx = img_resample_full_init(
1794 ost->st->codec->width, ost->st->codec->height,
1795 ist->st->codec->width, ist->st->codec->height,
1796 frame_topBand, frame_bottomBand,
1797 frame_leftBand, frame_rightBand,
1798 frame_padtop, frame_padbottom,
1799 frame_padleft, frame_padright);
1801 ost->padtop = frame_padtop;
1802 ost->padleft = frame_padleft;
1803 ost->padbottom = frame_padbottom;
1804 ost->padright = frame_padright;
1807 ost->encoding_needed = 1;
1808 ist->decoding_needed = 1;
1810 case CODEC_TYPE_SUBTITLE:
1811 ost->encoding_needed = 1;
1812 ist->decoding_needed = 1;
1819 if (ost->encoding_needed &&
1820 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1821 char logfilename[1024];
1826 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1828 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1829 if (codec->flags & CODEC_FLAG_PASS1) {
1830 f = fopen(logfilename, "w");
1832 perror(logfilename);
1837 /* read the log file */
1838 f = fopen(logfilename, "r");
1840 perror(logfilename);
1843 fseek(f, 0, SEEK_END);
1845 fseek(f, 0, SEEK_SET);
1846 logbuffer = av_malloc(size + 1);
1848 fprintf(stderr, "Could not allocate log buffer\n");
1851 size = fread(logbuffer, 1, size, f);
1853 logbuffer[size] = '\0';
1854 codec->stats_in = logbuffer;
1858 if(codec->codec_type == CODEC_TYPE_VIDEO){
1859 int size= codec->width * codec->height;
1860 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1865 bit_buffer = av_malloc(bit_buffer_size);
1869 /* dump the file output parameters - cannot be done before in case
1871 for(i=0;i<nb_output_files;i++) {
1872 dump_format(output_files[i], i, output_files[i]->filename, 1);
1875 /* dump the stream mapping */
1877 fprintf(stderr, "Stream mapping:\n");
1878 for(i=0;i<nb_ostreams;i++) {
1880 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1881 ist_table[ost->source_index]->file_index,
1882 ist_table[ost->source_index]->index,
1885 if (ost->sync_ist != ist_table[ost->source_index])
1886 fprintf(stderr, " [sync #%d.%d]",
1887 ost->sync_ist->file_index,
1888 ost->sync_ist->index);
1889 fprintf(stderr, "\n");
1893 /* open each encoder */
1894 for(i=0;i<nb_ostreams;i++) {
1896 if (ost->encoding_needed) {
1898 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1900 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1901 ost->file_index, ost->index);
1904 if (avcodec_open(ost->st->codec, codec) < 0) {
1905 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1906 ost->file_index, ost->index);
1909 extra_size += ost->st->codec->extradata_size;
1913 /* open each decoder */
1914 for(i=0;i<nb_istreams;i++) {
1916 if (ist->decoding_needed) {
1918 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1920 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1921 ist->st->codec->codec_id, ist->file_index, ist->index);
1924 if (avcodec_open(ist->st->codec, codec) < 0) {
1925 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1926 ist->file_index, ist->index);
1929 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1930 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1935 for(i=0;i<nb_istreams;i++) {
1937 is = input_files[ist->file_index];
1939 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1940 if(ist->st->start_time == AV_NOPTS_VALUE)
1942 if(input_files_ts_offset[ist->file_index])
1943 ist->next_pts= AV_NOPTS_VALUE;
1947 /* compute buffer size max (should use a complete heuristic) */
1948 for(i=0;i<nb_input_files;i++) {
1949 file_table[i].buffer_size_max = 2048;
1952 /* set meta data information from input file if required */
1953 for (i=0;i<nb_meta_data_maps;i++) {
1954 AVFormatContext *out_file;
1955 AVFormatContext *in_file;
1957 int out_file_index = meta_data_maps[i].out_file;
1958 int in_file_index = meta_data_maps[i].in_file;
1959 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1960 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1964 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1965 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1970 out_file = output_files[out_file_index];
1971 in_file = input_files[in_file_index];
1973 strcpy(out_file->title, in_file->title);
1974 strcpy(out_file->author, in_file->author);
1975 strcpy(out_file->copyright, in_file->copyright);
1976 strcpy(out_file->comment, in_file->comment);
1977 strcpy(out_file->album, in_file->album);
1978 out_file->year = in_file->year;
1979 out_file->track = in_file->track;
1980 strcpy(out_file->genre, in_file->genre);
1983 /* open files and write file headers */
1984 for(i=0;i<nb_output_files;i++) {
1985 os = output_files[i];
1986 if (av_write_header(os) < 0) {
1987 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1993 #ifndef CONFIG_WIN32
1994 if ( !using_stdin && verbose >= 0) {
1995 fprintf(stderr, "Press [q] to stop encoding\n");
1996 url_set_interrupt_cb(decode_interrupt_cb);
2004 for(; received_sigterm == 0;) {
2005 int file_index, ist_index;
2013 /* if 'q' pressed, exits */
2017 /* read_key() returns 0 on EOF */
2023 /* select the stream that we must read now by looking at the
2024 smallest output pts */
2026 for(i=0;i<nb_ostreams;i++) {
2029 os = output_files[ost->file_index];
2030 ist = ist_table[ost->source_index];
2031 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2032 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2034 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2035 ipts = (double)ist->pts;
2036 if (!file_table[ist->file_index].eof_reached){
2037 if(ipts < ipts_min) {
2039 if(input_sync ) file_index = ist->file_index;
2041 if(opts < opts_min) {
2043 if(!input_sync) file_index = ist->file_index;
2046 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2051 /* if none, if is finished */
2052 if (file_index < 0) {
2056 /* finish if recording time exhausted */
2057 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
2060 /* finish if limit size exhausted */
2061 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
2064 /* read a frame from it and output it in the fifo */
2065 is = input_files[file_index];
2066 if (av_read_frame(is, &pkt) < 0) {
2067 file_table[file_index].eof_reached = 1;
2068 if (opt_shortest) break; else continue; //
2072 stream_no_data = is;
2077 av_pkt_dump(stdout, &pkt, do_hex_dump);
2079 /* the following test is needed in case new streams appear
2080 dynamically in stream : we ignore them */
2081 if (pkt.stream_index >= file_table[file_index].nb_streams)
2082 goto discard_packet;
2083 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2084 ist = ist_table[ist_index];
2086 goto discard_packet;
2088 // 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);
2089 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
2090 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
2091 if(ABS(delta) > 10LL*AV_TIME_BASE && !copy_ts){
2092 input_files_ts_offset[ist->file_index]-= delta;
2094 fprintf(stderr, "timestamp discontinuity %lld, new offset= %lld\n", delta, input_files_ts_offset[ist->file_index]);
2095 for(i=0; i<file_table[file_index].nb_streams; i++){
2096 int index= file_table[file_index].ist_index + i;
2097 ist_table[index]->next_pts += delta;
2098 ist_table[index]->is_start=1;
2103 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2104 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2107 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2108 ist->file_index, ist->index);
2110 av_free_packet(&pkt);
2115 av_free_packet(&pkt);
2117 /* dump report by using the output first video and audio streams */
2118 print_report(output_files, ost_table, nb_ostreams, 0);
2121 /* at the end of stream, we must flush the decoder buffers */
2122 for(i=0;i<nb_istreams;i++) {
2124 if (ist->decoding_needed) {
2125 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2131 /* write the trailer if needed and close file */
2132 for(i=0;i<nb_output_files;i++) {
2133 os = output_files[i];
2134 av_write_trailer(os);
2137 /* dump report by using the first video and audio streams */
2138 print_report(output_files, ost_table, nb_ostreams, 1);
2140 /* close each encoder */
2141 for(i=0;i<nb_ostreams;i++) {
2143 if (ost->encoding_needed) {
2144 av_freep(&ost->st->codec->stats_in);
2145 avcodec_close(ost->st->codec);
2149 /* close each decoder */
2150 for(i=0;i<nb_istreams;i++) {
2152 if (ist->decoding_needed) {
2153 avcodec_close(ist->st->codec);
2161 av_freep(&bit_buffer);
2162 av_free(file_table);
2165 for(i=0;i<nb_istreams;i++) {
2172 for(i=0;i<nb_ostreams;i++) {
2176 fclose(ost->logfile);
2177 ost->logfile = NULL;
2179 fifo_free(&ost->fifo); /* works even if fifo is not
2180 initialized but set to zero */
2181 av_free(ost->pict_tmp.data[0]);
2182 if (ost->video_resample)
2183 img_resample_close(ost->img_resample_ctx);
2184 if (ost->audio_resample)
2185 audio_resample_close(ost->resample);
2198 int file_read(const char *filename)
2201 unsigned char buffer[1024];
2204 if (url_open(&h, filename, O_RDONLY) < 0) {
2205 printf("could not open '%s'\n", filename);
2209 len = url_read(h, buffer, sizeof(buffer));
2212 for(i=0;i<len;i++) putchar(buffer[i]);
2219 static void opt_image_format(const char *arg)
2223 for(f = first_image_format; f != NULL; f = f->next) {
2224 if (!strcmp(arg, f->name))
2228 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2234 static void opt_format(const char *arg)
2236 /* compatibility stuff for pgmyuv */
2237 if (!strcmp(arg, "pgmyuv")) {
2238 pgmyuv_compatibility_hack=1;
2239 // opt_image_format(arg);
2243 file_iformat = av_find_input_format(arg);
2244 file_oformat = guess_format(arg, NULL, NULL);
2245 if (!file_iformat && !file_oformat) {
2246 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2251 static void opt_video_bitrate(const char *arg)
2253 video_bit_rate = atoi(arg) * 1000;
2256 static void opt_video_bitrate_tolerance(const char *arg)
2258 video_bit_rate_tolerance = atoi(arg) * 1000;
2261 static void opt_video_bitrate_max(const char *arg)
2263 video_rc_max_rate = atoi(arg) * 1000;
2266 static void opt_video_bitrate_min(const char *arg)
2268 video_rc_min_rate = atoi(arg) * 1000;
2271 static void opt_video_buffer_size(const char *arg)
2273 video_rc_buffer_size = atoi(arg) * 8*1024;
2276 static void opt_video_rc_eq(char *arg)
2281 static void opt_video_rc_override_string(char *arg)
2283 video_rc_override_string = arg;
2287 static void opt_workaround_bugs(const char *arg)
2289 workaround_bugs = atoi(arg);
2292 static void opt_dct_algo(const char *arg)
2294 dct_algo = atoi(arg);
2297 static void opt_idct_algo(const char *arg)
2299 idct_algo = atoi(arg);
2302 static void opt_me_threshold(const char *arg)
2304 me_threshold = atoi(arg);
2307 static void opt_mb_threshold(const char *arg)
2309 mb_threshold = atoi(arg);
2312 static void opt_error_resilience(const char *arg)
2314 error_resilience = atoi(arg);
2317 static void opt_error_concealment(const char *arg)
2319 error_concealment = atoi(arg);
2322 static void opt_debug(const char *arg)
2325 av_log_set_level(AV_LOG_DEBUG);
2328 static void opt_vismv(const char *arg)
2330 debug_mv = atoi(arg);
2333 static void opt_verbose(const char *arg)
2335 verbose = atoi(arg);
2336 av_log_set_level(atoi(arg));
2339 static void opt_frame_rate(const char *arg)
2341 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2342 fprintf(stderr, "Incorrect frame rate\n");
2347 static void opt_frame_crop_top(const char *arg)
2349 frame_topBand = atoi(arg);
2350 if (frame_topBand < 0) {
2351 fprintf(stderr, "Incorrect top crop size\n");
2354 if ((frame_topBand % 2) != 0) {
2355 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2358 if ((frame_topBand) >= frame_height){
2359 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2362 frame_height -= frame_topBand;
2365 static void opt_frame_crop_bottom(const char *arg)
2367 frame_bottomBand = atoi(arg);
2368 if (frame_bottomBand < 0) {
2369 fprintf(stderr, "Incorrect bottom crop size\n");
2372 if ((frame_bottomBand % 2) != 0) {
2373 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2376 if ((frame_bottomBand) >= frame_height){
2377 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2380 frame_height -= frame_bottomBand;
2383 static void opt_frame_crop_left(const char *arg)
2385 frame_leftBand = atoi(arg);
2386 if (frame_leftBand < 0) {
2387 fprintf(stderr, "Incorrect left crop size\n");
2390 if ((frame_leftBand % 2) != 0) {
2391 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2394 if ((frame_leftBand) >= frame_width){
2395 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2398 frame_width -= frame_leftBand;
2401 static void opt_frame_crop_right(const char *arg)
2403 frame_rightBand = atoi(arg);
2404 if (frame_rightBand < 0) {
2405 fprintf(stderr, "Incorrect right crop size\n");
2408 if ((frame_rightBand % 2) != 0) {
2409 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2412 if ((frame_rightBand) >= frame_width){
2413 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2416 frame_width -= frame_rightBand;
2419 static void opt_frame_size(const char *arg)
2421 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2422 fprintf(stderr, "Incorrect frame size\n");
2425 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2426 fprintf(stderr, "Frame size must be a multiple of 2\n");
2432 #define SCALEBITS 10
2433 #define ONE_HALF (1 << (SCALEBITS - 1))
2434 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2436 #define RGB_TO_Y(r, g, b) \
2437 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2438 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2440 #define RGB_TO_U(r1, g1, b1, shift)\
2441 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2442 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2444 #define RGB_TO_V(r1, g1, b1, shift)\
2445 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2446 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2448 static void opt_pad_color(const char *arg) {
2449 /* Input is expected to be six hex digits similar to
2450 how colors are expressed in html tags (but without the #) */
2451 int rgb = strtol(arg, NULL, 16);
2455 g = ((rgb >> 8) & 255);
2458 padcolor[0] = RGB_TO_Y(r,g,b);
2459 padcolor[1] = RGB_TO_U(r,g,b,0);
2460 padcolor[2] = RGB_TO_V(r,g,b,0);
2463 static void opt_frame_pad_top(const char *arg)
2465 frame_padtop = atoi(arg);
2466 if (frame_padtop < 0) {
2467 fprintf(stderr, "Incorrect top pad size\n");
2470 if ((frame_padtop % 2) != 0) {
2471 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2476 static void opt_frame_pad_bottom(const char *arg)
2478 frame_padbottom = atoi(arg);
2479 if (frame_padbottom < 0) {
2480 fprintf(stderr, "Incorrect bottom pad size\n");
2483 if ((frame_padbottom % 2) != 0) {
2484 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2490 static void opt_frame_pad_left(const char *arg)
2492 frame_padleft = atoi(arg);
2493 if (frame_padleft < 0) {
2494 fprintf(stderr, "Incorrect left pad size\n");
2497 if ((frame_padleft % 2) != 0) {
2498 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2504 static void opt_frame_pad_right(const char *arg)
2506 frame_padright = atoi(arg);
2507 if (frame_padright < 0) {
2508 fprintf(stderr, "Incorrect right pad size\n");
2511 if ((frame_padright % 2) != 0) {
2512 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2518 static void opt_frame_pix_fmt(const char *arg)
2520 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2523 static void opt_frame_aspect_ratio(const char *arg)
2529 p = strchr(arg, ':');
2531 x = strtol(arg, (char **)&arg, 10);
2533 y = strtol(arg+1, (char **)&arg, 10);
2535 ar = (double)x / (double)y;
2537 ar = strtod(arg, (char **)&arg);
2540 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2543 frame_aspect_ratio = ar;
2546 static void opt_gop_size(const char *arg)
2548 gop_size = atoi(arg);
2551 static void opt_b_frames(const char *arg)
2553 b_frames = atoi(arg);
2554 if (b_frames > FF_MAX_B_FRAMES) {
2555 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2557 } else if (b_frames < 1) {
2558 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2563 static void opt_mb_decision(const char *arg)
2565 mb_decision = atoi(arg);
2568 static void opt_mb_cmp(const char *arg)
2573 static void opt_ildct_cmp(const char *arg)
2575 ildct_cmp = atoi(arg);
2578 static void opt_sub_cmp(const char *arg)
2580 sub_cmp = atoi(arg);
2583 static void opt_cmp(const char *arg)
2588 static void opt_pre_cmp(const char *arg)
2590 pre_cmp = atoi(arg);
2593 static void opt_pre_me(const char *arg)
2598 static void opt_lumi_mask(const char *arg)
2600 lumi_mask = atof(arg);
2603 static void opt_dark_mask(const char *arg)
2605 dark_mask = atof(arg);
2608 static void opt_scplx_mask(const char *arg)
2610 scplx_mask = atof(arg);
2613 static void opt_tcplx_mask(const char *arg)
2615 tcplx_mask = atof(arg);
2618 static void opt_p_mask(const char *arg)
2623 static void opt_qscale(const char *arg)
2625 video_qscale = atof(arg);
2626 if (video_qscale < 0.01 ||
2627 video_qscale > 255) {
2628 fprintf(stderr, "qscale must be >= 0.01 and <= 255\n");
2633 static void opt_qsquish(const char *arg)
2635 video_qsquish = atof(arg);
2636 if (video_qsquish < 0.0 ||
2637 video_qsquish > 99.0) {
2638 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2643 static void opt_lmax(const char *arg)
2645 video_lmax = atof(arg)*FF_QP2LAMBDA;
2648 static void opt_lmin(const char *arg)
2650 video_lmin = atof(arg)*FF_QP2LAMBDA;
2653 static void opt_qmin(const char *arg)
2655 video_qmin = atoi(arg);
2656 if (video_qmin < 1 ||
2658 fprintf(stderr, "qmin must be >= 1 and <= 31\n");
2663 static void opt_qmax(const char *arg)
2665 video_qmax = atoi(arg);
2666 if (video_qmax < 1 ||
2668 fprintf(stderr, "qmax must be >= 1 and <= 31\n");
2673 static void opt_mb_lmin(const char *arg)
2675 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2676 if (video_mb_lmin < 1 ||
2677 video_mb_lmin > FF_LAMBDA_MAX) {
2678 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2683 static void opt_mb_lmax(const char *arg)
2685 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2686 if (video_mb_lmax < 1 ||
2687 video_mb_lmax > FF_LAMBDA_MAX) {
2688 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2693 static void opt_qdiff(const char *arg)
2695 video_qdiff = atoi(arg);
2696 if (video_qdiff < 0 ||
2698 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2703 static void opt_qblur(const char *arg)
2705 video_qblur = atof(arg);
2708 static void opt_qcomp(const char *arg)
2710 video_qcomp = atof(arg);
2713 static void opt_rc_initial_cplx(const char *arg)
2715 video_rc_initial_cplx = atof(arg);
2717 static void opt_b_qfactor(const char *arg)
2719 video_b_qfactor = atof(arg);
2721 static void opt_i_qfactor(const char *arg)
2723 video_i_qfactor = atof(arg);
2725 static void opt_b_qoffset(const char *arg)
2727 video_b_qoffset = atof(arg);
2729 static void opt_i_qoffset(const char *arg)
2731 video_i_qoffset = atof(arg);
2734 static void opt_ibias(const char *arg)
2736 video_intra_quant_bias = atoi(arg);
2738 static void opt_pbias(const char *arg)
2740 video_inter_quant_bias = atoi(arg);
2743 static void opt_packet_size(const char *arg)
2745 packet_size= atoi(arg);
2748 static void opt_error_rate(const char *arg)
2750 error_rate= atoi(arg);
2753 static void opt_strict(const char *arg)
2758 static void opt_top_field_first(const char *arg)
2760 top_field_first= atoi(arg);
2763 static void opt_noise_reduction(const char *arg)
2765 noise_reduction= atoi(arg);
2768 static void opt_qns(const char *arg)
2773 static void opt_sc_threshold(const char *arg)
2775 sc_threshold= atoi(arg);
2778 static void opt_me_range(const char *arg)
2780 me_range = atoi(arg);
2783 static void opt_thread_count(const char *arg)
2785 thread_count= atoi(arg);
2786 #if !defined(HAVE_THREADS)
2788 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2792 static void opt_audio_bitrate(const char *arg)
2794 audio_bit_rate = atoi(arg) * 1000;
2797 static void opt_audio_rate(const char *arg)
2799 audio_sample_rate = atoi(arg);
2802 static void opt_audio_channels(const char *arg)
2804 audio_channels = atoi(arg);
2807 static void opt_video_device(const char *arg)
2809 video_device = av_strdup(arg);
2812 static void opt_grab_device(const char *arg)
2814 grab_device = av_strdup(arg);
2817 static void opt_video_channel(const char *arg)
2819 video_channel = strtol(arg, NULL, 0);
2822 static void opt_video_standard(const char *arg)
2824 video_standard = av_strdup(arg);
2827 static void opt_audio_device(const char *arg)
2829 audio_device = av_strdup(arg);
2832 static void opt_codec(int *pstream_copy, int *pcodec_id,
2833 int codec_type, const char *arg)
2837 if (!strcmp(arg, "copy")) {
2842 if (!strcmp(p->name, arg) && p->type == codec_type)
2847 fprintf(stderr, "Unknown codec '%s'\n", arg);
2855 static void opt_audio_codec(const char *arg)
2857 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2860 static void opt_audio_tag(const char *arg)
2863 audio_codec_tag= strtol(arg, &tail, 0);
2866 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2869 static void opt_video_tag(const char *arg)
2872 video_codec_tag= strtol(arg, &tail, 0);
2875 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2878 static void add_frame_hooker(const char *arg)
2883 char *args = av_strdup(arg);
2887 argv[0] = strtok(args, " ");
2888 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2891 i = frame_hook_add(argc, argv);
2894 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2899 const char *motion_str[] = {
2909 static void opt_motion_estimation(const char *arg)
2915 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2918 if (!strcmp(*p, arg))
2922 me_method = (p - motion_str) + 1;
2925 static void opt_video_codec(const char *arg)
2927 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2930 static void opt_subtitle_codec(const char *arg)
2932 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2935 static void opt_map(const char *arg)
2941 m = &stream_maps[nb_stream_maps++];
2943 m->file_index = strtol(arg, (char **)&p, 0);
2947 m->stream_index = strtol(p, (char **)&p, 0);
2950 m->sync_file_index = strtol(p, (char **)&p, 0);
2953 m->sync_stream_index = strtol(p, (char **)&p, 0);
2955 m->sync_file_index = m->file_index;
2956 m->sync_stream_index = m->stream_index;
2960 static void opt_map_meta_data(const char *arg)
2966 m = &meta_data_maps[nb_meta_data_maps++];
2968 m->out_file = strtol(arg, (char **)&p, 0);
2972 m->in_file = strtol(p, (char **)&p, 0);
2975 static void opt_recording_time(const char *arg)
2977 recording_time = parse_date(arg, 1);
2980 static void opt_start_time(const char *arg)
2982 start_time = parse_date(arg, 1);
2985 static void opt_rec_timestamp(const char *arg)
2987 rec_timestamp = parse_date(arg, 0) / 1000000;
2990 static void opt_input_ts_offset(const char *arg)
2992 input_ts_offset = parse_date(arg, 1);
2995 static void opt_input_file(const char *filename)
2997 AVFormatContext *ic;
2998 AVFormatParameters params, *ap = ¶ms;
2999 int err, i, ret, rfps, rfps_base;
3002 if (!strcmp(filename, "-"))
3005 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3006 !strcmp( filename, "/dev/stdin" );
3008 /* get default parameters from command line */
3009 memset(ap, 0, sizeof(*ap));
3010 ap->sample_rate = audio_sample_rate;
3011 ap->channels = audio_channels;
3012 ap->time_base.den = frame_rate;
3013 ap->time_base.num = frame_rate_base;
3014 ap->width = frame_width + frame_padleft + frame_padright;
3015 ap->height = frame_height + frame_padtop + frame_padbottom;
3016 ap->image_format = image_format;
3017 ap->pix_fmt = frame_pix_fmt;
3018 ap->device = grab_device;
3019 ap->channel = video_channel;
3020 ap->standard = video_standard;
3021 ap->video_codec_id = video_codec_id;
3022 ap->audio_codec_id = audio_codec_id;
3023 if(pgmyuv_compatibility_hack)
3024 ap->video_codec_id= CODEC_ID_PGMYUV;
3026 /* open the input file with generic libav function */
3027 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
3029 print_error(filename, err);
3034 ic->flags|= AVFMT_FLAG_GENPTS;
3036 /* If not enough info to get the stream parameters, we decode the
3037 first frames to get it. (used in mpeg case for example) */
3038 ret = av_find_stream_info(ic);
3039 if (ret < 0 && verbose >= 0) {
3040 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3044 timestamp = start_time;
3045 /* add the stream start time */
3046 if (ic->start_time != AV_NOPTS_VALUE)
3047 timestamp += ic->start_time;
3049 /* if seeking requested, we execute it */
3050 if (start_time != 0) {
3051 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3053 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3054 filename, (double)timestamp / AV_TIME_BASE);
3056 /* reset seek info */
3060 /* update the current parameters so that they match the one of the input stream */
3061 for(i=0;i<ic->nb_streams;i++) {
3062 AVCodecContext *enc = ic->streams[i]->codec;
3063 #if defined(HAVE_THREADS)
3065 avcodec_thread_init(enc, thread_count);
3067 enc->thread_count= thread_count;
3068 switch(enc->codec_type) {
3069 case CODEC_TYPE_AUDIO:
3070 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
3071 audio_channels = enc->channels;
3072 audio_sample_rate = enc->sample_rate;
3074 ic->streams[i]->discard= AVDISCARD_ALL;
3076 case CODEC_TYPE_VIDEO:
3077 frame_height = enc->height;
3078 frame_width = enc->width;
3079 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
3080 frame_pix_fmt = enc->pix_fmt;
3081 rfps = ic->streams[i]->r_frame_rate.num;
3082 rfps_base = ic->streams[i]->r_frame_rate.den;
3083 enc->workaround_bugs = workaround_bugs;
3084 enc->error_resilience = error_resilience;
3085 enc->error_concealment = error_concealment;
3086 enc->idct_algo = idct_algo;
3088 enc->debug_mv = debug_mv;
3089 enc->lowres= lowres;
3090 if(lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
3092 enc->flags|= CODEC_FLAG_BITEXACT;
3094 enc->debug |= FF_DEBUG_MV;
3096 enc->flags |= CODEC_FLAG_GRAY;
3098 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
3101 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3102 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
3104 (float)rfps / rfps_base, rfps, rfps_base);
3106 /* update the current frame rate to match the stream frame rate */
3108 frame_rate_base = rfps_base;
3110 enc->rate_emu = rate_emu;
3112 ic->streams[i]->discard= AVDISCARD_ALL;
3113 else if(video_discard)
3114 ic->streams[i]->discard= video_discard;
3116 case CODEC_TYPE_DATA:
3118 case CODEC_TYPE_SUBTITLE:
3120 case CODEC_TYPE_UNKNOWN:
3127 input_files[nb_input_files] = ic;
3128 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
3129 /* dump the file content */
3131 dump_format(ic, nb_input_files, filename, 0);
3134 file_iformat = NULL;
3135 file_oformat = NULL;
3136 image_format = NULL;
3144 static void opt_grab(const char *arg)
3146 file_iformat = av_find_input_format(arg);
3150 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
3152 int has_video, has_audio, i, j;
3153 AVFormatContext *ic;
3157 for(j=0;j<nb_input_files;j++) {
3158 ic = input_files[j];
3159 for(i=0;i<ic->nb_streams;i++) {
3160 AVCodecContext *enc = ic->streams[i]->codec;
3161 switch(enc->codec_type) {
3162 case CODEC_TYPE_AUDIO:
3165 case CODEC_TYPE_VIDEO:
3168 case CODEC_TYPE_DATA:
3169 case CODEC_TYPE_UNKNOWN:
3170 case CODEC_TYPE_SUBTITLE:
3177 *has_video_ptr = has_video;
3178 *has_audio_ptr = has_audio;
3181 static void new_video_stream(AVFormatContext *oc)
3184 AVCodecContext *video_enc;
3187 st = av_new_stream(oc, oc->nb_streams);
3189 fprintf(stderr, "Could not alloc stream\n");
3192 #if defined(HAVE_THREADS)
3194 avcodec_thread_init(st->codec, thread_count);
3197 video_enc = st->codec;
3200 video_enc->codec_tag= video_codec_tag;
3202 if( (video_global_header&1)
3203 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER)))
3204 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3205 if(video_global_header&2)
3206 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3208 if (video_stream_copy) {
3209 st->stream_copy = 1;
3210 video_enc->codec_type = CODEC_TYPE_VIDEO;
3216 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3217 if (video_codec_id != CODEC_ID_NONE)
3218 codec_id = video_codec_id;
3220 video_enc->codec_id = codec_id;
3221 codec = avcodec_find_encoder(codec_id);
3223 for(i=0; i<opt_name_count; i++){
3225 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3226 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3227 av_set_double(video_enc, opt_names[i], d);
3230 video_enc->bit_rate = video_bit_rate;
3231 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3232 video_enc->time_base.den = frame_rate;
3233 video_enc->time_base.num = frame_rate_base;
3234 if(codec && codec->supported_framerates){
3235 const AVRational *p= codec->supported_framerates;
3236 AVRational req= (AVRational){frame_rate, frame_rate_base};
3237 const AVRational *best=NULL;
3238 AVRational best_error= (AVRational){INT_MAX, 1};
3239 for(; p->den!=0; p++){
3240 AVRational error= av_sub_q(req, *p);
3241 if(error.num <0) error.num *= -1;
3242 if(av_cmp_q(error, best_error) < 0){
3247 video_enc->time_base.den= best->num;
3248 video_enc->time_base.num= best->den;
3251 video_enc->width = frame_width + frame_padright + frame_padleft;
3252 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3253 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3254 video_enc->pix_fmt = frame_pix_fmt;
3256 if(codec && codec->pix_fmts){
3257 const enum PixelFormat *p= codec->pix_fmts;
3259 if(*p == video_enc->pix_fmt)
3263 video_enc->pix_fmt = codec->pix_fmts[0];
3267 video_enc->gop_size = gop_size;
3269 video_enc->gop_size = 0;
3270 if (video_qscale || same_quality) {
3271 video_enc->flags |= CODEC_FLAG_QSCALE;
3272 video_enc->global_quality=
3273 st->quality = FF_QP2LAMBDA * video_qscale;
3277 video_enc->intra_matrix = intra_matrix;
3279 video_enc->inter_matrix = inter_matrix;
3282 video_enc->flags |= CODEC_FLAG_BITEXACT;
3284 video_enc->mb_decision = mb_decision;
3285 video_enc->mb_cmp = mb_cmp;
3286 video_enc->ildct_cmp = ildct_cmp;
3287 video_enc->me_sub_cmp = sub_cmp;
3288 video_enc->me_cmp = cmp;
3289 video_enc->me_pre_cmp = pre_cmp;
3290 video_enc->pre_me = pre_me;
3291 video_enc->lumi_masking = lumi_mask;
3292 video_enc->dark_masking = dark_mask;
3293 video_enc->spatial_cplx_masking = scplx_mask;
3294 video_enc->temporal_cplx_masking = tcplx_mask;
3295 video_enc->p_masking = p_mask;
3296 video_enc->quantizer_noise_shaping= qns;
3299 video_enc->flags |= CODEC_FLAG_H263P_UMV;
3302 video_enc->flags |= CODEC_FLAG_H263P_SLICE_STRUCT;
3305 video_enc->flags |= CODEC_FLAG_H263P_AIC;
3308 video_enc->flags |= CODEC_FLAG_H263P_AIV;
3311 video_enc->flags |= CODEC_FLAG_4MV;
3314 video_enc->flags |= CODEC_FLAG_OBMC;
3317 video_enc->flags |= CODEC_FLAG_LOOP_FILTER;
3321 video_enc->flags |= CODEC_FLAG_PART;
3324 video_enc->flags |= CODEC_FLAG_ALT_SCAN;
3327 video_enc->flags |= CODEC_FLAG_TRELLIS_QUANT;
3330 video_enc->flags |= CODEC_FLAG_MV0;
3332 if (do_normalize_aqp) {
3333 video_enc->flags |= CODEC_FLAG_NORMALIZE_AQP;
3335 if (use_scan_offset) {
3336 video_enc->flags |= CODEC_FLAG_SVCD_SCAN_OFFSET;
3339 video_enc->flags |= CODEC_FLAG_CLOSED_GOP;
3342 video_enc->flags2 |= CODEC_FLAG2_STRICT_GOP;
3345 video_enc->flags |= CODEC_FLAG_QPEL;
3348 video_enc->flags |= CODEC_FLAG_QP_RD;
3351 video_enc->flags |= CODEC_FLAG_CBP_RD;
3354 video_enc->max_b_frames = b_frames;
3355 video_enc->b_frame_strategy = b_strategy;
3356 video_enc->b_quant_factor = 2.0;
3358 if (do_interlace_dct) {
3359 video_enc->flags |= CODEC_FLAG_INTERLACED_DCT;
3361 if (do_interlace_me) {
3362 video_enc->flags |= CODEC_FLAG_INTERLACED_ME;
3365 video_enc->flags2 |= CODEC_FLAG2_NO_OUTPUT;
3368 video_enc->flags |= CODEC_FLAG_GRAY;
3370 video_enc->qmin = video_qmin;
3371 video_enc->qmax = video_qmax;
3372 video_enc->lmin = video_lmin;
3373 video_enc->lmax = video_lmax;
3374 video_enc->rc_qsquish = video_qsquish;
3375 video_enc->mb_lmin = video_mb_lmin;
3376 video_enc->mb_lmax = video_mb_lmax;
3377 video_enc->max_qdiff = video_qdiff;
3378 video_enc->qblur = video_qblur;
3379 video_enc->qcompress = video_qcomp;
3380 video_enc->rc_eq = video_rc_eq;
3381 video_enc->debug = debug;
3382 video_enc->debug_mv = debug_mv;
3383 video_enc->workaround_bugs = workaround_bugs;
3384 video_enc->thread_count = thread_count;
3385 p= video_rc_override_string;
3388 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3390 fprintf(stderr, "error parsing rc_override\n");
3393 video_enc->rc_override=
3394 av_realloc(video_enc->rc_override,
3395 sizeof(RcOverride)*(i+1));
3396 video_enc->rc_override[i].start_frame= start;
3397 video_enc->rc_override[i].end_frame = end;
3399 video_enc->rc_override[i].qscale= q;
3400 video_enc->rc_override[i].quality_factor= 1.0;
3403 video_enc->rc_override[i].qscale= 0;
3404 video_enc->rc_override[i].quality_factor= -q/100.0;
3409 video_enc->rc_override_count=i;
3411 video_enc->rc_max_rate = video_rc_max_rate;
3412 video_enc->rc_min_rate = video_rc_min_rate;
3413 video_enc->rc_buffer_size = video_rc_buffer_size;
3414 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3415 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3416 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3417 video_enc->i_quant_factor = video_i_qfactor;
3418 video_enc->b_quant_factor = video_b_qfactor;
3419 video_enc->i_quant_offset = video_i_qoffset;
3420 video_enc->b_quant_offset = video_b_qoffset;
3421 video_enc->intra_quant_bias = video_intra_quant_bias;
3422 video_enc->inter_quant_bias = video_inter_quant_bias;
3423 video_enc->dct_algo = dct_algo;
3424 video_enc->idct_algo = idct_algo;
3425 video_enc->me_threshold= me_threshold;
3426 video_enc->mb_threshold= mb_threshold;
3427 video_enc->intra_dc_precision= intra_dc_precision - 8;
3428 video_enc->strict_std_compliance = strict;
3429 video_enc->error_rate = error_rate;
3430 video_enc->noise_reduction= noise_reduction;
3431 video_enc->scenechange_threshold= sc_threshold;
3432 video_enc->me_range = me_range;
3433 video_enc->coder_type= coder;
3434 video_enc->context_model= context;
3435 video_enc->prediction_method= predictor;
3436 video_enc->profile= video_profile;
3437 video_enc->level= video_level;
3438 video_enc->nsse_weight= nsse_weight;
3439 video_enc->me_subpel_quality= subpel_quality;
3440 video_enc->me_penalty_compensation= me_penalty_compensation;
3441 video_enc->frame_skip_threshold= frame_skip_threshold;
3442 video_enc->frame_skip_factor= frame_skip_factor;
3443 video_enc->frame_skip_exp= frame_skip_exp;
3444 video_enc->frame_skip_cmp= frame_skip_cmp;
3447 video_enc->rtp_mode= 1;
3448 video_enc->rtp_payload_size= packet_size;
3452 video_enc->flags|= CODEC_FLAG_PSNR;
3454 video_enc->me_method = me_method;
3459 video_enc->flags |= CODEC_FLAG_PASS1;
3461 video_enc->flags |= CODEC_FLAG_PASS2;
3466 /* reset some key parameters */
3468 video_codec_id = CODEC_ID_NONE;
3469 video_stream_copy = 0;
3472 static void new_audio_stream(AVFormatContext *oc)
3475 AVCodecContext *audio_enc;
3478 st = av_new_stream(oc, oc->nb_streams);
3480 fprintf(stderr, "Could not alloc stream\n");
3483 #if defined(HAVE_THREADS)
3485 avcodec_thread_init(st->codec, thread_count);
3488 audio_enc = st->codec;
3489 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3492 audio_enc->codec_tag= audio_codec_tag;
3494 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3495 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3496 if (audio_stream_copy) {
3497 st->stream_copy = 1;
3498 audio_enc->channels = audio_channels;
3500 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3502 for(i=0; i<opt_name_count; i++){
3504 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3505 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3506 av_set_double(audio_enc, opt_names[i], d);
3509 if (audio_codec_id != CODEC_ID_NONE)
3510 codec_id = audio_codec_id;
3511 audio_enc->codec_id = codec_id;
3513 audio_enc->bit_rate = audio_bit_rate;
3514 if (audio_qscale > QSCALE_NONE) {
3515 audio_enc->flags |= CODEC_FLAG_QSCALE;
3516 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3518 audio_enc->strict_std_compliance = strict;
3519 audio_enc->thread_count = thread_count;
3520 /* For audio codecs other than AC3 or DTS we limit */
3521 /* the number of coded channels to stereo */
3522 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3523 && codec_id != CODEC_ID_DTS) {
3524 audio_enc->channels = 2;
3526 audio_enc->channels = audio_channels;
3528 audio_enc->sample_rate = audio_sample_rate;
3529 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3530 if (audio_language) {
3531 pstrcpy(st->language, sizeof(st->language), audio_language);
3532 av_free(audio_language);
3533 audio_language = NULL;
3536 /* reset some key parameters */
3538 audio_codec_id = CODEC_ID_NONE;
3539 audio_stream_copy = 0;
3542 static void opt_new_subtitle_stream(void)
3544 AVFormatContext *oc;
3546 AVCodecContext *subtitle_enc;
3549 if (nb_output_files <= 0) {
3550 fprintf(stderr, "At least one output file must be specified\n");
3553 oc = output_files[nb_output_files - 1];
3555 st = av_new_stream(oc, oc->nb_streams);
3557 fprintf(stderr, "Could not alloc stream\n");
3561 subtitle_enc = st->codec;
3562 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3563 if (subtitle_stream_copy) {
3564 st->stream_copy = 1;
3566 for(i=0; i<opt_name_count; i++){
3568 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3569 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3570 av_set_double(subtitle_enc, opt_names[i], d);
3572 subtitle_enc->codec_id = subtitle_codec_id;
3575 if (subtitle_language) {
3576 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3577 av_free(subtitle_language);
3578 subtitle_language = NULL;
3581 subtitle_codec_id = CODEC_ID_NONE;
3582 subtitle_stream_copy = 0;
3585 static void opt_new_audio_stream(void)
3587 AVFormatContext *oc;
3588 if (nb_output_files <= 0) {
3589 fprintf(stderr, "At least one output file must be specified\n");
3592 oc = output_files[nb_output_files - 1];
3593 new_audio_stream(oc);
3596 static void opt_new_video_stream(void)
3598 AVFormatContext *oc;
3599 if (nb_output_files <= 0) {
3600 fprintf(stderr, "At least one output file must be specified\n");
3603 oc = output_files[nb_output_files - 1];
3604 new_video_stream(oc);
3607 static void opt_output_file(const char *filename)
3609 AVFormatContext *oc;
3610 int use_video, use_audio, input_has_video, input_has_audio;
3611 AVFormatParameters params, *ap = ¶ms;
3613 if (!strcmp(filename, "-"))
3616 oc = av_alloc_format_context();
3618 if (!file_oformat) {
3619 file_oformat = guess_format(NULL, filename, NULL);
3620 if (!file_oformat) {
3621 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3627 oc->oformat = file_oformat;
3628 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3630 if (!strcmp(file_oformat->name, "ffm") &&
3631 strstart(filename, "http:", NULL)) {
3632 /* special case for files sent to ffserver: we get the stream
3633 parameters from ffserver */
3634 if (read_ffserver_streams(oc, filename) < 0) {
3635 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3639 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3640 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3642 /* disable if no corresponding type found and at least one
3644 if (nb_input_files > 0) {
3645 check_audio_video_inputs(&input_has_video, &input_has_audio);
3646 if (!input_has_video)
3648 if (!input_has_audio)
3652 /* manual disable */
3653 if (audio_disable) {
3656 if (video_disable) {
3661 new_video_stream(oc);
3665 new_audio_stream(oc);
3668 if (!oc->nb_streams) {
3669 fprintf(stderr, "No audio or video streams available\n");
3673 oc->timestamp = rec_timestamp;
3676 pstrcpy(oc->title, sizeof(oc->title), str_title);
3678 pstrcpy(oc->author, sizeof(oc->author), str_author);
3680 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3682 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3685 output_files[nb_output_files++] = oc;
3687 /* check filename in case of an image number is expected */
3688 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3689 if (filename_number_test(oc->filename) < 0) {
3690 print_error(oc->filename, AVERROR_NUMEXPECTED);
3695 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3696 /* test if it already exists to avoid loosing precious files */
3697 if (!file_overwrite &&
3698 (strchr(filename, ':') == NULL ||
3699 strstart(filename, "file:", NULL))) {
3700 if (url_exist(filename)) {
3703 if ( !using_stdin ) {
3704 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3707 if (toupper(c) != 'Y') {
3708 fprintf(stderr, "Not overwriting - exiting\n");
3713 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3720 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3721 fprintf(stderr, "Could not open '%s'\n", filename);
3726 memset(ap, 0, sizeof(*ap));
3727 ap->image_format = image_format;
3728 if (av_set_parameters(oc, ap) < 0) {
3729 fprintf(stderr, "%s: Invalid encoding parameters\n",
3734 oc->packet_size= mux_packet_size;
3735 oc->mux_rate= mux_rate;
3736 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3737 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3738 oc->loop_output = loop_output;
3740 /* reset some options */
3741 file_oformat = NULL;
3742 file_iformat = NULL;
3743 image_format = NULL;
3746 /* prepare dummy protocols for grab */
3747 static void prepare_grab(void)
3749 int has_video, has_audio, i, j;
3750 AVFormatContext *oc;
3751 AVFormatContext *ic;
3752 AVFormatParameters vp1, *vp = &vp1;
3753 AVFormatParameters ap1, *ap = &ap1;
3755 /* see if audio/video inputs are needed */
3758 memset(ap, 0, sizeof(*ap));
3759 memset(vp, 0, sizeof(*vp));
3760 vp->time_base.num= 1;
3761 for(j=0;j<nb_output_files;j++) {
3762 oc = output_files[j];
3763 for(i=0;i<oc->nb_streams;i++) {
3764 AVCodecContext *enc = oc->streams[i]->codec;
3765 switch(enc->codec_type) {
3766 case CODEC_TYPE_AUDIO:
3767 if (enc->sample_rate > ap->sample_rate)
3768 ap->sample_rate = enc->sample_rate;
3769 if (enc->channels > ap->channels)
3770 ap->channels = enc->channels;
3773 case CODEC_TYPE_VIDEO:
3774 if (enc->width > vp->width)
3775 vp->width = enc->width;
3776 if (enc->height > vp->height)
3777 vp->height = enc->height;
3779 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3780 vp->time_base = enc->time_base;
3790 if (has_video == 0 && has_audio == 0) {
3791 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3796 AVInputFormat *fmt1;
3797 fmt1 = av_find_input_format(video_grab_format);
3798 vp->device = video_device;
3799 vp->channel = video_channel;
3800 vp->standard = video_standard;
3801 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3802 fprintf(stderr, "Could not find video grab device\n");
3805 /* If not enough info to get the stream parameters, we decode the
3806 first frames to get it. */
3807 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3808 fprintf(stderr, "Could not find video grab parameters\n");
3811 /* by now video grab has one stream */
3812 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3813 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3814 input_files[nb_input_files] = ic;
3817 dump_format(ic, nb_input_files, "", 0);
3821 if (has_audio && audio_grab_format) {
3822 AVInputFormat *fmt1;
3823 fmt1 = av_find_input_format(audio_grab_format);
3824 ap->device = audio_device;
3825 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3826 fprintf(stderr, "Could not find audio grab device\n");
3829 input_files[nb_input_files] = ic;
3832 dump_format(ic, nb_input_files, "", 0);
3838 /* same option as mencoder */
3839 static void opt_pass(const char *pass_str)
3842 pass = atoi(pass_str);
3843 if (pass != 1 && pass != 2) {
3844 fprintf(stderr, "pass number can be only 1 or 2\n");
3850 #if defined(CONFIG_WIN32) || defined(CONFIG_OS2)
3851 static int64_t getutime(void)
3853 return av_gettime();
3856 static int64_t getutime(void)
3858 struct rusage rusage;
3860 getrusage(RUSAGE_SELF, &rusage);
3861 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3865 extern int ffm_nopts;
3867 static void opt_bitexact(void)
3870 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3874 static void show_formats(void)
3876 AVInputFormat *ifmt;
3877 AVOutputFormat *ofmt;
3878 AVImageFormat *image_fmt;
3881 const char **pp, *last_name;
3883 printf("File formats:\n");
3888 const char *name=NULL;
3889 const char *long_name=NULL;
3891 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3892 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3893 strcmp(ofmt->name, last_name)>0){
3895 long_name= ofmt->long_name;
3899 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3900 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3901 strcmp(ifmt->name, last_name)>0){
3903 long_name= ifmt->long_name;
3906 if(name && strcmp(ifmt->name, name)==0)
3918 long_name ? long_name:" ");
3922 printf("Image formats (filename extensions, if any, follow):\n");
3923 for(image_fmt = first_image_format; image_fmt != NULL;
3924 image_fmt = image_fmt->next) {
3927 image_fmt->img_read ? "D":" ",
3928 image_fmt->img_write ? "E":" ",
3930 image_fmt->extensions ? image_fmt->extensions:" ");
3934 printf("Codecs:\n");
3940 const char *type_str;
3943 for(p = first_avcodec; p != NULL; p = p->next) {
3944 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3945 strcmp(p->name, last_name)>0){
3947 decode= encode= cap=0;
3949 if(p2 && strcmp(p->name, p2->name)==0){
3950 if(p->decode) decode=1;
3951 if(p->encode) encode=1;
3952 cap |= p->capabilities;
3957 last_name= p2->name;
3960 case CODEC_TYPE_VIDEO:
3963 case CODEC_TYPE_AUDIO:
3966 case CODEC_TYPE_SUBTITLE:
3975 decode ? "D": (/*p2->decoder ? "d":*/" "),
3978 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3979 cap & CODEC_CAP_DR1 ? "D":" ",
3980 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3982 /* if(p2->decoder && decode==0)
3983 printf(" use %s for decoding", p2->decoder->name);*/
3988 printf("Supported file protocols:\n");
3989 for(up = first_protocol; up != NULL; up = up->next)
3990 printf(" %s:", up->name);
3993 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3994 printf("Motion estimation methods:\n");
3998 if ((pp - motion_str + 1) == ME_ZERO)
3999 printf("(fastest)");
4000 else if ((pp - motion_str + 1) == ME_FULL)
4001 printf("(slowest)");
4002 else if ((pp - motion_str + 1) == ME_EPZS)
4003 printf("(default)");
4008 "Note, the names of encoders and decoders dont always match, so there are\n"
4009 "several cases where the above table shows encoder only or decoder only entries\n"
4010 "even though both encoding and decoding are supported for example, the h263\n"
4011 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
4016 void parse_matrix_coeffs(uint16_t *dest, const char *str)
4019 const char *p = str;
4026 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4033 void opt_inter_matrix(const char *arg)
4035 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4036 parse_matrix_coeffs(inter_matrix, arg);
4039 void opt_intra_matrix(const char *arg)
4041 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4042 parse_matrix_coeffs(intra_matrix, arg);
4045 static void opt_target(const char *arg)
4048 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4050 if(!strncmp(arg, "pal-", 4)) {
4053 } else if(!strncmp(arg, "ntsc-", 5)) {
4056 } else if(!strncmp(arg, "film-", 5)) {
4061 /* Calculate FR via float to avoid int overflow */
4062 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
4065 } else if((fr == 29970) || (fr == 23976)) {
4068 /* Try to determine PAL/NTSC by peeking in the input files */
4069 if(nb_input_files) {
4071 for(j = 0; j < nb_input_files; j++) {
4072 for(i = 0; i < input_files[j]->nb_streams; i++) {
4073 AVCodecContext *c = input_files[j]->streams[i]->codec;
4074 if(c->codec_type != CODEC_TYPE_VIDEO)
4076 fr = c->time_base.den * 1000 / c->time_base.num;
4080 } else if((fr == 29970) || (fr == 23976)) {
4090 if(verbose && norm >= 0)
4091 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
4095 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4096 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4097 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4101 if(!strcmp(arg, "vcd")) {
4103 opt_video_codec("mpeg1video");
4104 opt_audio_codec("mp2");
4107 opt_frame_size(norm ? "352x240" : "352x288");
4108 opt_frame_rate(frame_rates[norm]);
4109 opt_gop_size(norm ? "18" : "15");
4111 video_bit_rate = 1150000;
4112 video_rc_max_rate = 1150000;
4113 video_rc_min_rate = 1150000;
4114 video_rc_buffer_size = 40*1024*8;
4116 audio_bit_rate = 224000;
4117 audio_sample_rate = 44100;
4119 mux_packet_size= 2324;
4120 mux_rate= 2352 * 75 * 8;
4122 /* We have to offset the PTS, so that it is consistent with the SCR.
4123 SCR starts at 36000, but the first two packs contain only padding
4124 and the first pack from the other stream, respectively, may also have
4125 been written before.
4126 So the real data starts at SCR 36000+3*1200. */
4127 mux_preload= (36000+3*1200) / 90000.0; //0.44
4128 } else if(!strcmp(arg, "svcd")) {
4130 opt_video_codec("mpeg2video");
4131 opt_audio_codec("mp2");
4134 opt_frame_size(norm ? "480x480" : "480x576");
4135 opt_frame_rate(frame_rates[norm]);
4136 opt_gop_size(norm ? "18" : "15");
4138 video_bit_rate = 2040000;
4139 video_rc_max_rate = 2516000;
4140 video_rc_min_rate = 0; //1145000;
4141 video_rc_buffer_size = 224*1024*8;
4142 use_scan_offset = 1;
4144 audio_bit_rate = 224000;
4145 audio_sample_rate = 44100;
4147 mux_packet_size= 2324;
4149 } else if(!strcmp(arg, "dvd")) {
4151 opt_video_codec("mpeg2video");
4152 opt_audio_codec("ac3");
4155 opt_frame_size(norm ? "720x480" : "720x576");
4156 opt_frame_rate(frame_rates[norm]);
4157 opt_gop_size(norm ? "18" : "15");
4159 video_bit_rate = 6000000;
4160 video_rc_max_rate = 9000000;
4161 video_rc_min_rate = 0; //1500000;
4162 video_rc_buffer_size = 224*1024*8;
4164 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4165 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4167 audio_bit_rate = 448000;
4168 audio_sample_rate = 48000;
4170 } else if(!strcmp(arg, "dv")) {
4174 opt_frame_size(norm ? "720x480" : "720x576");
4175 opt_frame_rate(frame_rates[norm]);
4177 audio_sample_rate = 48000;
4181 fprintf(stderr, "Unknown target: %s\n", arg);
4186 static void show_version(void)
4188 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
4191 avcodec_build(), LIBAVFORMAT_BUILD);
4195 static int opt_default(const char *opt, const char *arg){
4196 AVOption *o= av_set_string(avctx_opts, opt, arg);
4200 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
4201 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
4202 opt_names[opt_name_count++]= opt;
4207 const OptionDef options[] = {
4209 { "L", 0, {(void*)show_license}, "show license" },
4210 { "h", 0, {(void*)show_help}, "show help" },
4211 { "version", 0, {(void*)show_version}, "show version" },
4212 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
4213 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4214 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
4215 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4216 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4217 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
4218 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
4219 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
4220 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
4221 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4222 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4223 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
4224 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
4225 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
4226 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
4227 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
4228 { "debug", HAS_ARG | OPT_EXPERT, {(void*)opt_debug}, "print specific debug info", "" },
4229 { "vismv", HAS_ARG | OPT_EXPERT, {(void*)opt_vismv}, "visualize motion vectors", "" },
4230 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4231 "add timings for benchmarking" },
4232 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4233 "dump each input packet" },
4234 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4235 "when dumping packets, also dump the payload" },
4236 { "bitexact", OPT_EXPERT, {(void*)opt_bitexact}, "only use bit exact algorithms (for codec testing)" },
4237 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4238 { "loop", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4239 { "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)", "" },
4240 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4241 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4242 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4243 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4244 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4245 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4246 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4247 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4250 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4251 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4252 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4253 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4254 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4255 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4256 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4257 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4258 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4259 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4260 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4261 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4262 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4263 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4264 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4265 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4266 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4267 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4268 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4269 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4270 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4271 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4272 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4273 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4274 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4275 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4276 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4277 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4278 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4279 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4280 { "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" },
4281 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4282 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4283 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4284 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4285 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4286 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4287 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4288 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4289 { "b_strategy", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&b_strategy}, "dynamic b frame selection strategy", "strategy" },
4290 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4291 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4292 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4293 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4294 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4295 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4296 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4297 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4299 { "dct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dct_algo}, "set dct algo", "algo" },
4300 { "idct_algo", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_idct_algo}, "set idct algo", "algo" },
4301 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
4302 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
4303 { "er", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_resilience}, "set error resilience", "n" },
4304 { "ec", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_error_concealment}, "set error concealment", "bit_mask" },
4305 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4306 { "hq", OPT_BOOL, {(void*)&mb_decision}, "activate high quality settings" },
4307 { "mbd", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_decision}, "macroblock decision", "mode" },
4308 { "mbcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_cmp}, "macroblock compare function", "cmp function" },
4309 { "ildctcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ildct_cmp}, "ildct compare function", "cmp function" },
4310 { "subcmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sub_cmp}, "subpel compare function", "cmp function" },
4311 { "cmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_cmp}, "fullpel compare function", "cmp function" },
4312 { "precmp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_cmp}, "pre motion estimation compare function", "cmp function" },
4313 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4314 { "lumi_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lumi_mask}, "luminance masking", "" },
4315 { "dark_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_dark_mask}, "darkness masking", "" },
4316 { "scplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_scplx_mask}, "spatial complexity masking", "" },
4317 { "tcplx_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_tcplx_mask}, "temporal complexity masking", "" },
4318 { "p_mask", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_p_mask}, "inter masking", "" },
4319 { "4mv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_4mv}, "use four motion vector by macroblock (MPEG4)" },
4320 { "obmc", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_obmc}, "use overlapped block motion compensation (h263+)" },
4321 { "lf", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_loop}, "use loop filter (h263+)" },
4322 { "part", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_part}, "use data partitioning (MPEG4)" },
4323 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4324 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4325 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4326 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4327 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4328 "use same video quality as source (implies VBR)" },
4329 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4330 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4331 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4332 "deinterlace pictures" },
4333 { "ildct", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_dct},
4334 "force interlaced dct support in encoder (MPEG2/MPEG4)" },
4335 { "ilme", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_interlace_me},
4336 "force interlaced me support in encoder (MPEG2/MPEG4)" },
4337 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4338 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4339 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4340 { "aic", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aic}, "enable Advanced intra coding (h263+)" },
4341 { "aiv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_aiv}, "enable Alternative inter vlc (h263+)" },
4342 { "umv", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_umv}, "enable Unlimited Motion Vector (h263+)" },
4343 { "ssm", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_ss}, "enable Slice Structured mode (h263+)" },
4344 { "alt", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_alt_scan}, "enable alternate scantable (MPEG2/MPEG4)" },
4345 { "qprd", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qprd}, "" },
4346 { "cbp", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_cbprd}, "" },
4347 { "trell", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_trell}, "enable trellis quantization" },
4348 { "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)" },
4349 { "naq", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_normalize_aqp}, "normalize adaptive quantization" },
4350 { "cgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&closed_gop}, "closed gop" },
4351 { "sgop", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&strict_gop}, "strict gop" },
4352 { "noout", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&no_output}, "skip bitstream encoding" },
4353 { "scan_offset", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_scan_offset}, "enable SVCD Scan Offset placeholder" },
4354 { "qpel", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&use_qpel}, "enable 1/4-pel" },
4355 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4356 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4357 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4358 { "nr", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_noise_reduction}, "noise reduction", "" },
4359 { "qns", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qns}, "quantization noise shaping", "" },
4360 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4361 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4362 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4363 { "coder", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&coder}, "coder type", "" },
4364 { "context", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&context}, "context model", "" },
4365 { "pred", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&predictor}, "prediction method", "" },
4366 { "vprofile", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_profile}, "profile", "" },
4367 { "vlevel", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_level}, "level", "" },
4368 { "nssew", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&nsse_weight}, "weight", "" },
4369 { "subq", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&subpel_quality}, "", "" },
4370 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4371 { "lowres", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&lowres}, "", "" },
4372 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4373 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4374 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4375 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4376 { "skip_cmp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_cmp}, "frame skip compare function", "compare function" },
4377 { "gray", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&gray_only }, "encode/decode grayscale" },
4378 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4379 { "genpts", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&genpts }, "generate pts" },
4382 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4383 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4384 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4385 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4386 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4387 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4388 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4389 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4390 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4391 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4393 /* subtitle options */
4394 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4395 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4396 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4399 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4400 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4401 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4402 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4404 /* G.2 grab options */
4405 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4406 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4409 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4410 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4411 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4412 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4413 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4417 static void show_banner(void)
4419 fprintf(stderr, "ffmpeg version " FFMPEG_VERSION ", build %d, Copyright (c) 2000-2004 Fabrice Bellard\n",
4421 fprintf(stderr, " configuration: %s\n", FFMPEG_CONFIGURATION);
4422 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4424 fprintf(stderr, ", gcc: %s\n", __VERSION__);
4426 fprintf(stderr, ", using a non-gcc compiler\n");
4430 static void show_license(void)
4435 "This program is free software; you can redistribute it and/or modify\n"
4436 "it under the terms of the GNU General Public License as published by\n"
4437 "the Free Software Foundation; either version 2 of the License, or\n"
4438 "(at your option) any later version.\n"
4440 "This program is distributed in the hope that it will be useful,\n"
4441 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4442 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4443 "GNU General Public License for more details.\n"
4445 "You should have received a copy of the GNU General Public License\n"
4446 "along with this program; if not, write to the Free Software\n"
4447 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4451 "This library is free software; you can redistribute it and/or\n"
4452 "modify it under the terms of the GNU Lesser General Public\n"
4453 "License as published by the Free Software Foundation; either\n"
4454 "version 2 of the License, or (at your option) any later version.\n"
4456 "This library is distributed in the hope that it will be useful,\n"
4457 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4458 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4459 "Lesser General Public License for more details.\n"
4461 "You should have received a copy of the GNU Lesser General Public\n"
4462 "License along with this library; if not, write to the Free Software\n"
4463 "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n"
4469 static void show_help(void)
4472 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4473 "Hyper fast Audio and Video encoder\n");
4475 show_help_options(options, "Main options:\n",
4476 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4477 show_help_options(options, "\nVideo options:\n",
4478 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4480 show_help_options(options, "\nAdvanced Video options:\n",
4481 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4482 OPT_VIDEO | OPT_EXPERT);
4483 show_help_options(options, "\nAudio options:\n",
4484 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4486 show_help_options(options, "\nAdvanced Audio options:\n",
4487 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4488 OPT_AUDIO | OPT_EXPERT);
4489 show_help_options(options, "\nSubtitle options:\n",
4490 OPT_SUBTITLE | OPT_GRAB,
4492 show_help_options(options, "\nAudio/Video grab options:\n",
4495 show_help_options(options, "\nAdvanced options:\n",
4496 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4498 av_opt_show(avctx_opts, NULL);
4503 void parse_arg_file(const char *filename)
4505 opt_output_file(filename);
4508 int main(int argc, char **argv)
4515 avctx_opts= avcodec_alloc_context();
4523 parse_options(argc, argv, options);
4525 /* file converter / grab */
4526 if (nb_output_files <= 0) {
4527 fprintf(stderr, "Must supply at least one output file\n");
4531 if (nb_input_files == 0) {
4537 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4538 stream_maps, nb_stream_maps);
4539 ti = getutime() - ti;
4541 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4545 for(i=0;i<nb_output_files;i++) {
4546 /* maybe av_close_output_file ??? */
4547 AVFormatContext *s = output_files[i];
4549 if (!(s->oformat->flags & AVFMT_NOFILE))
4551 for(j=0;j<s->nb_streams;j++)
4552 av_free(s->streams[j]);
4555 for(i=0;i<nb_input_files;i++)
4556 av_close_input_file(input_files[i]);
4561 av_free(intra_matrix);
4563 av_free(inter_matrix);
4565 #ifdef POWERPC_PERFORMANCE_REPORT
4566 extern void powerpc_display_perf_report(void);
4567 powerpc_display_perf_report();
4568 #endif /* POWERPC_PERFORMANCE_REPORT */
4570 #ifndef CONFIG_WIN32
4571 if (received_sigterm) {
4573 "Received signal %d: terminating.\n",
4574 (int) received_sigterm);
4578 exit(0); /* not all OS-es handle main() return value */