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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 #define HAVE_AV_CONFIG_H
23 #include "framehook.h"
30 #include <sys/ioctl.h>
33 #include <sys/resource.h>
37 #include <sys/types.h>
38 #include <sys/select.h>
41 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
50 #if !defined(INFINITY) && defined(HUGE_VAL)
51 #define INFINITY HUGE_VAL
54 /* select an input stream for an output stream */
55 typedef struct AVStreamMap {
59 int sync_stream_index;
62 /** select an input file for an output file */
63 typedef struct AVMetaDataMap {
68 extern const OptionDef options[];
70 static void show_help(void);
71 static void show_license(void);
72 static int opt_default(const char *opt, const char *arg);
76 static AVFormatContext *input_files[MAX_FILES];
77 static int64_t input_files_ts_offset[MAX_FILES];
78 static int nb_input_files = 0;
80 static AVFormatContext *output_files[MAX_FILES];
81 static int nb_output_files = 0;
83 static AVStreamMap stream_maps[MAX_FILES];
84 static int nb_stream_maps;
86 static AVMetaDataMap meta_data_maps[MAX_FILES];
87 static int nb_meta_data_maps;
89 static AVInputFormat *file_iformat;
90 static AVOutputFormat *file_oformat;
91 static AVImageFormat *image_format;
92 static int frame_width = 0;
93 static int frame_height = 0;
94 static float frame_aspect_ratio = 0;
95 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
96 static int frame_padtop = 0;
97 static int frame_padbottom = 0;
98 static int frame_padleft = 0;
99 static int frame_padright = 0;
100 static int padcolor[3] = {16,128,128}; /* default to black */
101 static int frame_topBand = 0;
102 static int frame_bottomBand = 0;
103 static int frame_leftBand = 0;
104 static int frame_rightBand = 0;
105 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
106 static int frame_rate = 25;
107 static int frame_rate_base = 1;
108 static int video_bit_rate = 200*1000;
109 static int video_bit_rate_tolerance = 4000*1000;
110 static float video_qscale = 0;
111 static int video_qmin = 2;
112 static int video_qmax = 31;
113 static int video_lmin = 2*FF_QP2LAMBDA;
114 static int video_lmax = 31*FF_QP2LAMBDA;
115 static int video_mb_lmin = 2*FF_QP2LAMBDA;
116 static int video_mb_lmax = 31*FF_QP2LAMBDA;
117 static int video_qdiff = 3;
118 static float video_qblur = 0.5;
119 static float video_qsquish = 0.0;
120 static float video_qcomp = 0.5;
121 static uint16_t *intra_matrix = NULL;
122 static uint16_t *inter_matrix = NULL;
123 #if 0 //experimental, (can be removed)
124 static float video_rc_qsquish=1.0;
125 static float video_rc_qmod_amp=0;
126 static int video_rc_qmod_freq=0;
128 static char *video_rc_override_string=NULL;
129 static char *video_rc_eq="tex^qComp";
130 static int video_rc_buffer_size=0;
131 static float video_rc_buffer_aggressivity=1.0;
132 static int video_rc_max_rate=0;
133 static int video_rc_min_rate=0;
134 static float video_rc_initial_cplx=0;
135 static float video_b_qfactor = 1.25;
136 static float video_b_qoffset = 1.25;
137 static float video_i_qfactor = -0.8;
138 static float video_i_qoffset = 0.0;
139 static int video_intra_quant_bias= FF_DEFAULT_QUANT_BIAS;
140 static int video_inter_quant_bias= FF_DEFAULT_QUANT_BIAS;
141 static int me_method = ME_EPZS;
142 static int video_disable = 0;
143 static int video_discard = 0;
144 static int video_codec_id = CODEC_ID_NONE;
145 static int video_codec_tag = 0;
146 static int same_quality = 0;
147 static int b_frames = 0;
148 static int pre_me = 0;
149 static int do_deinterlace = 0;
150 static int workaround_bugs = FF_BUG_AUTODETECT;
151 static int packet_size = 0;
152 static int error_rate = 0;
153 static int strict = 0;
154 static int top_field_first = -1;
155 static int sc_threshold = 0;
156 static int me_threshold = 0;
157 static int mb_threshold = 0;
158 static int intra_dc_precision = 8;
159 static int me_penalty_compensation= 256;
160 static int frame_skip_threshold= 0;
161 static int frame_skip_factor= 0;
162 static int frame_skip_exp= 0;
163 static int loop_input = 0;
164 static int loop_output = AVFMT_NOOUTPUTLOOP;
165 static int qp_hist = 0;
167 static int gop_size = 12;
168 static int intra_only = 0;
169 static int audio_sample_rate = 44100;
170 static int audio_bit_rate = 64000;
171 #define QSCALE_NONE -99999
172 static float audio_qscale = QSCALE_NONE;
173 static int audio_disable = 0;
174 static int audio_channels = 1;
175 static int audio_codec_id = CODEC_ID_NONE;
176 static int audio_codec_tag = 0;
177 static char *audio_language = NULL;
179 static int subtitle_codec_id = CODEC_ID_NONE;
180 static char *subtitle_language = NULL;
182 static int mux_rate= 0;
183 static int mux_packet_size= 0;
184 static float mux_preload= 0.5;
185 static float mux_max_delay= 0.7;
187 static int64_t recording_time = 0;
188 static int64_t start_time = 0;
189 static int64_t rec_timestamp = 0;
190 static int64_t input_ts_offset = 0;
191 static int file_overwrite = 0;
192 static char *str_title = NULL;
193 static char *str_author = NULL;
194 static char *str_copyright = NULL;
195 static char *str_comment = NULL;
196 static char *str_album = NULL;
197 static int do_benchmark = 0;
198 static int do_hex_dump = 0;
199 static int do_pkt_dump = 0;
200 static int do_psnr = 0;
201 static int do_vstats = 0;
202 static int do_pass = 0;
203 static char *pass_logfilename = NULL;
204 static int audio_stream_copy = 0;
205 static int video_stream_copy = 0;
206 static int subtitle_stream_copy = 0;
207 static int video_sync_method= 1;
208 static int audio_sync_method= 0;
209 static int copy_ts= 0;
210 static int opt_shortest = 0; //
211 static int video_global_header = 0;
213 static int rate_emu = 0;
216 static const char *video_grab_format = "bktr";
218 #ifdef CONFIG_VIDEO4LINUX2
219 static const char *video_grab_format = "video4linux2";
221 static const char *video_grab_format = "video4linux";
224 static char *video_device = NULL;
225 static char *grab_device = NULL;
226 static int video_channel = 0;
227 static char *video_standard = "ntsc";
229 static const char *audio_grab_format = "audio_device";
230 static char *audio_device = NULL;
231 static int audio_volume = 256;
233 static int using_stdin = 0;
234 static int using_vhook = 0;
235 static int verbose = 1;
236 static int thread_count= 1;
237 static int q_pressed = 0;
238 static int me_range = 0;
239 static int64_t video_size = 0;
240 static int64_t audio_size = 0;
241 static int64_t extra_size = 0;
242 static int nb_frames_dup = 0;
243 static int nb_frames_drop = 0;
244 static int input_sync;
245 static int limit_filesize = 0; //
247 static int pgmyuv_compatibility_hack=0;
248 static int dts_delta_threshold = 10;
250 static int sws_flags = SWS_BICUBIC;
252 const char **opt_names=NULL;
253 int opt_name_count=0;
254 AVCodecContext *avctx_opts;
255 AVFormatContext *avformat_opts;
257 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
258 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
259 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
261 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
263 struct AVInputStream;
265 typedef struct AVOutputStream {
266 int file_index; /* file index */
267 int index; /* stream index in the output file */
268 int source_index; /* AVInputStream index */
269 AVStream *st; /* stream in the output file */
270 int encoding_needed; /* true if encoding needed for this stream */
272 /* input pts and corresponding output pts
274 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
275 struct AVInputStream *sync_ist; /* input stream to sync against */
276 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
279 AVFrame pict_tmp; /* temporary image for resampling */
280 struct SwsContext *img_resample_ctx; /* for image resampling */
284 int topBand; /* cropping area sizes */
288 int padtop; /* padding area sizes */
295 ReSampleContext *resample; /* for audio resampling */
296 FifoBuffer fifo; /* for compression: one audio fifo per codec */
300 typedef struct AVInputStream {
304 int discard; /* true if stream data should be discarded */
305 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
306 int64_t sample_index; /* current sample */
308 int64_t start; /* time when read started */
309 unsigned long frame; /* current frame */
310 int64_t next_pts; /* synthetic pts for cases where pkt.pts
312 int64_t pts; /* current pts */
313 int is_start; /* is 1 at the start and after a discontinuity */
316 typedef struct AVInputFile {
317 int eof_reached; /* true if eof reached */
318 int ist_index; /* index of first stream in ist_table */
319 int buffer_size; /* current total buffer size */
320 int buffer_size_max; /* buffer size at which we consider we can stop
322 int nb_streams; /* nb streams we are aware of */
327 /* init terminal so that we can grab keys */
328 static struct termios oldtty;
330 static void term_exit(void)
332 tcsetattr (0, TCSANOW, &oldtty);
335 static volatile sig_atomic_t received_sigterm = 0;
338 sigterm_handler(int sig)
340 received_sigterm = sig;
344 static void term_init(void)
351 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
352 |INLCR|IGNCR|ICRNL|IXON);
353 tty.c_oflag |= OPOST;
354 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
355 tty.c_cflag &= ~(CSIZE|PARENB);
360 tcsetattr (0, TCSANOW, &tty);
362 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
363 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
364 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
366 register a function to be called at normal program termination
369 #ifdef CONFIG_BEOS_NETSERVER
370 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
374 /* read a key without blocking */
375 static int read_key(void)
379 #ifndef CONFIG_BEOS_NETSERVER
387 n = select(1, &rfds, NULL, NULL, &tv);
399 static int decode_interrupt_cb(void)
401 return q_pressed || (q_pressed = read_key() == 'q');
406 static volatile int received_sigterm = 0;
408 /* no interactive support */
409 static void term_exit(void)
413 static void term_init(void)
417 static int read_key(void)
424 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
429 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
432 /* copy stream format */
433 s->nb_streams = ic->nb_streams;
434 for(i=0;i<ic->nb_streams;i++) {
437 // FIXME: a more elegant solution is needed
438 st = av_mallocz(sizeof(AVStream));
439 memcpy(st, ic->streams[i], sizeof(AVStream));
440 st->codec = avcodec_alloc_context();
441 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
445 av_close_input_file(ic);
450 get_sync_ipts(const AVOutputStream *ost)
452 const AVInputStream *ist = ost->sync_ist;
453 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
456 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
458 AVPacket new_pkt= *pkt;
459 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
460 &new_pkt.data, &new_pkt.size,
461 pkt->data, pkt->size,
462 pkt->flags & PKT_FLAG_KEY);
465 new_pkt.destruct= av_destruct_packet;
472 av_interleaved_write_frame(s, pkt);
475 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
477 static void do_audio_out(AVFormatContext *s,
480 unsigned char *buf, int size)
483 static uint8_t *audio_buf = NULL;
484 static uint8_t *audio_out = NULL;
485 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
487 int size_out, frame_bytes, ret;
488 AVCodecContext *enc= ost->st->codec;
490 /* SC: dynamic allocation of buffers */
492 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
494 audio_out = av_malloc(audio_out_size);
495 if (!audio_buf || !audio_out)
496 return; /* Should signal an error ! */
498 if(audio_sync_method){
499 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
500 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
501 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
502 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
504 //FIXME resample delay
505 if(fabs(delta) > 50){
508 byte_delta= FFMAX(byte_delta, -size);
512 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
517 static uint8_t *input_tmp= NULL;
518 input_tmp= av_realloc(input_tmp, byte_delta + size);
520 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
523 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
525 memset(input_tmp, 0, byte_delta);
526 memcpy(input_tmp + byte_delta, buf, size);
530 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
532 }else if(audio_sync_method>1){
533 int comp= clip(delta, -audio_sync_method, audio_sync_method);
534 assert(ost->audio_resample);
536 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
537 // 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));
538 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
542 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
543 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
545 if (ost->audio_resample) {
547 size_out = audio_resample(ost->resample,
548 (short *)buftmp, (short *)buf,
549 size / (ist->st->codec->channels * 2));
550 size_out = size_out * enc->channels * 2;
556 /* now encode as many frames as possible */
557 if (enc->frame_size > 1) {
558 /* output resampled raw samples */
559 fifo_write(&ost->fifo, buftmp, size_out,
562 frame_bytes = enc->frame_size * 2 * enc->channels;
564 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
565 &ost->fifo.rptr) == 0) {
567 av_init_packet(&pkt);
569 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
572 pkt.stream_index= ost->index;
575 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
576 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
577 pkt.flags |= PKT_FLAG_KEY;
578 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
580 ost->sync_opts += enc->frame_size;
584 av_init_packet(&pkt);
586 ost->sync_opts += size_out / (2 * enc->channels);
588 /* output a pcm frame */
589 /* XXX: change encoding codec API to avoid this ? */
590 switch(enc->codec->id) {
591 case CODEC_ID_PCM_S32LE:
592 case CODEC_ID_PCM_S32BE:
593 case CODEC_ID_PCM_U32LE:
594 case CODEC_ID_PCM_U32BE:
595 size_out = size_out << 1;
597 case CODEC_ID_PCM_S24LE:
598 case CODEC_ID_PCM_S24BE:
599 case CODEC_ID_PCM_U24LE:
600 case CODEC_ID_PCM_U24BE:
601 case CODEC_ID_PCM_S24DAUD:
602 size_out = size_out / 2 * 3;
604 case CODEC_ID_PCM_S16LE:
605 case CODEC_ID_PCM_S16BE:
606 case CODEC_ID_PCM_U16LE:
607 case CODEC_ID_PCM_U16BE:
610 size_out = size_out >> 1;
613 ret = avcodec_encode_audio(enc, audio_out, size_out,
616 pkt.stream_index= ost->index;
619 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
620 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
621 pkt.flags |= PKT_FLAG_KEY;
622 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
626 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
630 AVPicture picture_tmp;
633 dec = ist->st->codec;
635 /* deinterlace : must be done before any resize */
636 if (do_deinterlace || using_vhook) {
639 /* create temporary picture */
640 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
641 buf = av_malloc(size);
645 picture2 = &picture_tmp;
646 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
649 if(avpicture_deinterlace(picture2, picture,
650 dec->pix_fmt, dec->width, dec->height) < 0) {
651 /* if error, do not deinterlace */
657 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
663 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
665 if (picture != picture2)
666 *picture = *picture2;
670 /* we begin to correct av delay at this threshold */
671 #define AV_DELAY_MAX 0.100
673 static void do_subtitle_out(AVFormatContext *s,
679 static uint8_t *subtitle_out = NULL;
680 int subtitle_out_max_size = 65536;
681 int subtitle_out_size, nb, i;
685 if (pts == AV_NOPTS_VALUE) {
686 fprintf(stderr, "Subtitle packets must have a pts\n");
690 enc = ost->st->codec;
693 subtitle_out = av_malloc(subtitle_out_max_size);
696 /* Note: DVB subtitle need one packet to draw them and one other
697 packet to clear them */
698 /* XXX: signal it in the codec context ? */
699 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
704 for(i = 0; i < nb; i++) {
705 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
706 subtitle_out_max_size, sub);
708 av_init_packet(&pkt);
709 pkt.stream_index = ost->index;
710 pkt.data = subtitle_out;
711 pkt.size = subtitle_out_size;
712 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);
713 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
714 /* XXX: the pts correction is handled here. Maybe handling
715 it in the codec would be better */
717 pkt.pts += 90 * sub->start_display_time;
719 pkt.pts += 90 * sub->end_display_time;
721 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
725 static int bit_buffer_size= 1024*256;
726 static uint8_t *bit_buffer= NULL;
728 static void do_video_out(AVFormatContext *s,
734 int nb_frames, i, ret;
735 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
736 AVFrame picture_crop_temp, picture_pad_temp;
737 uint8_t *buf = NULL, *buf1 = NULL;
738 AVCodecContext *enc, *dec;
740 avcodec_get_frame_defaults(&picture_crop_temp);
741 avcodec_get_frame_defaults(&picture_pad_temp);
743 enc = ost->st->codec;
744 dec = ist->st->codec;
746 /* by default, we output a single frame */
751 if(video_sync_method){
753 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
754 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
757 else if (vdelta > 1.1)
758 nb_frames = lrintf(vdelta);
759 //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);
763 fprintf(stderr, "*** drop!\n");
764 }else if (nb_frames > 1) {
765 nb_frames_dup += nb_frames;
767 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
770 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
772 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
776 if (ost->video_crop) {
777 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
778 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
781 formatted_picture = &picture_crop_temp;
783 formatted_picture = in_picture;
786 final_picture = formatted_picture;
787 padding_src = formatted_picture;
788 resampling_dst = &ost->pict_tmp;
789 if (ost->video_pad) {
790 final_picture = &ost->pict_tmp;
791 if (ost->video_resample) {
792 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
793 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
796 resampling_dst = &picture_pad_temp;
800 if (ost->video_resample) {
802 final_picture = &ost->pict_tmp;
803 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
804 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
807 if (ost->video_pad) {
808 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
809 enc->height, enc->width, enc->pix_fmt,
810 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
813 /* duplicates frame if needed */
814 for(i=0;i<nb_frames;i++) {
816 av_init_packet(&pkt);
817 pkt.stream_index= ost->index;
819 if (s->oformat->flags & AVFMT_RAWPICTURE) {
820 /* raw pictures are written as AVPicture structure to
821 avoid any copies. We support temorarily the older
823 AVFrame* old_frame = enc->coded_frame;
824 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
825 pkt.data= (uint8_t *)final_picture;
826 pkt.size= sizeof(AVPicture);
827 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
828 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
829 if(dec->coded_frame && dec->coded_frame->key_frame)
830 pkt.flags |= PKT_FLAG_KEY;
832 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
833 enc->coded_frame = old_frame;
837 big_picture= *final_picture;
838 /* better than nothing: use input picture interlaced
840 big_picture.interlaced_frame = in_picture->interlaced_frame;
841 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
842 if(top_field_first == -1)
843 big_picture.top_field_first = in_picture->top_field_first;
845 big_picture.top_field_first = top_field_first;
848 /* handles sameq here. This is not correct because it may
849 not be a global option */
851 big_picture.quality = ist->st->quality;
853 big_picture.quality = ost->st->quality;
855 big_picture.pict_type = 0;
856 // big_picture.pts = AV_NOPTS_VALUE;
857 big_picture.pts= ost->sync_opts;
858 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
859 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
860 ret = avcodec_encode_video(enc,
861 bit_buffer, bit_buffer_size,
863 //enc->frame_number = enc->real_pict_num;
865 pkt.data= bit_buffer;
867 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
868 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
869 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
870 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
871 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
873 if(enc->coded_frame && enc->coded_frame->key_frame)
874 pkt.flags |= PKT_FLAG_KEY;
875 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
877 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
878 // enc->frame_number-1, enc->real_pict_num, ret,
880 /* if two pass, output log */
881 if (ost->logfile && enc->stats_out) {
882 fprintf(ost->logfile, "%s", enc->stats_out);
894 static double psnr(double d){
895 if(d==0) return INFINITY;
896 return -10.0*log(d)/log(10.0);
899 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
902 static FILE *fvstats=NULL;
909 double ti1, bitrate, avg_bitrate;
913 today = localtime(&today2);
914 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
917 fvstats = fopen(filename,"w");
925 enc = ost->st->codec;
926 if (enc->codec_type == CODEC_TYPE_VIDEO) {
927 frame_number = ost->frame_number;
928 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
929 if (enc->flags&CODEC_FLAG_PSNR)
930 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
932 fprintf(fvstats,"f_size= %6d ", frame_size);
933 /* compute pts value */
934 ti1 = ost->sync_opts * av_q2d(enc->time_base);
938 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
939 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
940 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
941 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
942 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
946 static void print_report(AVFormatContext **output_files,
947 AVOutputStream **ost_table, int nb_ostreams,
952 AVFormatContext *oc, *os;
955 int frame_number, vid, i;
956 double bitrate, ti1, pts;
957 static int64_t last_time = -1;
958 static int qp_histogram[52];
960 if (!is_last_report) {
962 /* display the report every 0.5 seconds */
963 cur_time = av_gettime();
964 if (last_time == -1) {
965 last_time = cur_time;
968 if ((cur_time - last_time) < 500000)
970 last_time = cur_time;
974 oc = output_files[0];
976 total_size = url_ftell(&oc->pb);
981 for(i=0;i<nb_ostreams;i++) {
983 os = output_files[ost->file_index];
984 enc = ost->st->codec;
985 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
986 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
987 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
989 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
990 frame_number = ost->frame_number;
991 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
992 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
994 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
995 if(qp_hist && enc->coded_frame){
997 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
998 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1001 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1003 if (enc->flags&CODEC_FLAG_PSNR){
1005 double error, error_sum=0;
1006 double scale, scale_sum=0;
1007 char type[3]= {'Y','U','V'};
1008 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1011 error= enc->error[j];
1012 scale= enc->width*enc->height*255.0*255.0*frame_number;
1014 error= enc->coded_frame->error[j];
1015 scale= enc->width*enc->height*255.0*255.0;
1020 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1022 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1026 /* compute min output value */
1027 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1028 if ((pts < ti1) && (pts > 0))
1034 if (verbose || is_last_report) {
1035 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1037 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1038 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1039 (double)total_size / 1024, ti1, bitrate);
1042 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1043 nb_frames_dup, nb_frames_drop);
1046 fprintf(stderr, "%s \r", buf);
1051 if (is_last_report && verbose >= 0){
1052 int64_t raw= audio_size + video_size + extra_size;
1053 fprintf(stderr, "\n");
1054 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1058 100.0*(total_size - raw)/raw
1063 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1064 static int output_packet(AVInputStream *ist, int ist_index,
1065 AVOutputStream **ost_table, int nb_ostreams,
1066 const AVPacket *pkt)
1068 AVFormatContext *os;
1069 AVOutputStream *ost;
1073 int data_size, got_picture;
1075 void *buffer_to_free;
1076 static unsigned int samples_size= 0;
1077 static short *samples= NULL;
1078 AVSubtitle subtitle, *subtitle_to_free;
1082 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1083 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1084 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1086 // assert(ist->pts == ist->next_pts);
1100 /* decode the packet if needed */
1101 data_buf = NULL; /* fail safe */
1103 subtitle_to_free = NULL;
1104 if (ist->decoding_needed) {
1105 switch(ist->st->codec->codec_type) {
1106 case CODEC_TYPE_AUDIO:{
1108 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1109 /* XXX: could avoid copy if PCM 16 bits with same
1110 endianness as CPU */
1111 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1117 /* Some bug in mpeg audio decoder gives */
1118 /* data_size < 0, it seems they are overflows */
1119 if (data_size <= 0) {
1120 /* no audio frame */
1123 data_buf = (uint8_t *)samples;
1124 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1125 (ist->st->codec->sample_rate * ist->st->codec->channels);
1127 case CODEC_TYPE_VIDEO:
1128 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1129 /* XXX: allocate picture correctly */
1130 avcodec_get_frame_defaults(&picture);
1132 ret = avcodec_decode_video(ist->st->codec,
1133 &picture, &got_picture, ptr, len);
1134 ist->st->quality= picture.quality;
1138 /* no picture yet */
1139 goto discard_packet;
1141 if (ist->st->codec->time_base.num != 0) {
1142 ist->next_pts += ((int64_t)AV_TIME_BASE *
1143 ist->st->codec->time_base.num) /
1144 ist->st->codec->time_base.den;
1148 case CODEC_TYPE_SUBTITLE:
1149 ret = avcodec_decode_subtitle(ist->st->codec,
1150 &subtitle, &got_subtitle, ptr, len);
1153 if (!got_subtitle) {
1154 goto discard_packet;
1156 subtitle_to_free = &subtitle;
1163 switch(ist->st->codec->codec_type) {
1164 case CODEC_TYPE_AUDIO:
1165 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1166 (ist->st->codec->sample_rate * ist->st->codec->channels);
1168 case CODEC_TYPE_VIDEO:
1169 if (ist->st->codec->time_base.num != 0) {
1170 ist->next_pts += ((int64_t)AV_TIME_BASE *
1171 ist->st->codec->time_base.num) /
1172 ist->st->codec->time_base.den;
1182 buffer_to_free = NULL;
1183 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1184 pre_process_video_frame(ist, (AVPicture *)&picture,
1188 // preprocess audio (volume)
1189 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1190 if (audio_volume != 256) {
1193 for(i=0;i<(data_size / sizeof(short));i++) {
1194 int v = ((*volp) * audio_volume + 128) >> 8;
1195 if (v < -32768) v = -32768;
1196 if (v > 32767) v = 32767;
1202 /* frame rate emulation */
1203 if (ist->st->codec->rate_emu) {
1204 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1205 int64_t now = av_gettime() - ist->start;
1213 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1214 is the one of the next displayed one */
1215 /* XXX: add mpeg4 too ? */
1216 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1217 if (ist->st->codec->pict_type != B_TYPE) {
1219 tmp = ist->last_ip_pts;
1220 ist->last_ip_pts = ist->frac_pts.val;
1221 ist->frac_pts.val = tmp;
1225 /* if output time reached then transcode raw format,
1226 encode packets and output them */
1227 if (start_time == 0 || ist->pts >= start_time)
1228 for(i=0;i<nb_ostreams;i++) {
1232 if (ost->source_index == ist_index) {
1233 os = output_files[ost->file_index];
1236 printf("%d: got pts=%0.3f %0.3f\n", i,
1237 (double)pkt->pts / AV_TIME_BASE,
1238 ((double)ist->pts / AV_TIME_BASE) -
1239 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1241 /* set the input output pts pairs */
1242 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1244 if (ost->encoding_needed) {
1245 switch(ost->st->codec->codec_type) {
1246 case CODEC_TYPE_AUDIO:
1247 do_audio_out(os, ost, ist, data_buf, data_size);
1249 case CODEC_TYPE_VIDEO:
1250 do_video_out(os, ost, ist, &picture, &frame_size);
1251 video_size += frame_size;
1252 if (do_vstats && frame_size)
1253 do_video_stats(os, ost, frame_size);
1255 case CODEC_TYPE_SUBTITLE:
1256 do_subtitle_out(os, ost, ist, &subtitle,
1263 AVFrame avframe; //FIXME/XXX remove this
1265 av_init_packet(&opkt);
1267 /* no reencoding needed : output the packet directly */
1268 /* force the input stream PTS */
1270 avcodec_get_frame_defaults(&avframe);
1271 ost->st->codec->coded_frame= &avframe;
1272 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1274 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1275 audio_size += data_size;
1276 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1277 video_size += data_size;
1281 opkt.stream_index= ost->index;
1282 if(pkt->pts != AV_NOPTS_VALUE)
1283 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);
1285 opkt.pts= AV_NOPTS_VALUE;
1289 if (pkt->dts == AV_NOPTS_VALUE)
1290 dts = ist->next_pts;
1292 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1293 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1295 opkt.flags= pkt->flags;
1297 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1298 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1299 opkt.destruct= av_destruct_packet;
1301 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1302 ost->st->codec->frame_number++;
1303 ost->frame_number++;
1304 av_free_packet(&opkt);
1308 av_free(buffer_to_free);
1309 /* XXX: allocate the subtitles in the codec ? */
1310 if (subtitle_to_free) {
1311 if (subtitle_to_free->rects != NULL) {
1312 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1313 av_free(subtitle_to_free->rects[i].bitmap);
1314 av_free(subtitle_to_free->rects[i].rgba_palette);
1316 av_freep(&subtitle_to_free->rects);
1318 subtitle_to_free->num_rects = 0;
1319 subtitle_to_free = NULL;
1326 for(i=0;i<nb_ostreams;i++) {
1328 if (ost->source_index == ist_index) {
1329 AVCodecContext *enc= ost->st->codec;
1330 os = output_files[ost->file_index];
1332 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1334 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1337 if (ost->encoding_needed) {
1341 av_init_packet(&pkt);
1342 pkt.stream_index= ost->index;
1344 switch(ost->st->codec->codec_type) {
1345 case CODEC_TYPE_AUDIO:
1346 fifo_bytes = fifo_size(&ost->fifo, NULL);
1348 /* encode any samples remaining in fifo */
1349 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1350 int fs_tmp = enc->frame_size;
1351 enc->frame_size = fifo_bytes / (2 * enc->channels);
1352 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1353 &ost->fifo.rptr) == 0) {
1354 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1356 enc->frame_size = fs_tmp;
1359 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1362 pkt.flags |= PKT_FLAG_KEY;
1364 case CODEC_TYPE_VIDEO:
1365 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1367 if(enc->coded_frame && enc->coded_frame->key_frame)
1368 pkt.flags |= PKT_FLAG_KEY;
1369 if (ost->logfile && enc->stats_out) {
1370 fprintf(ost->logfile, "%s", enc->stats_out);
1379 pkt.data= bit_buffer;
1381 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1382 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1383 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1397 * The following code is the main loop of the file converter
1399 static int av_encode(AVFormatContext **output_files,
1400 int nb_output_files,
1401 AVFormatContext **input_files,
1403 AVStreamMap *stream_maps, int nb_stream_maps)
1405 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1406 AVFormatContext *is, *os;
1407 AVCodecContext *codec, *icodec;
1408 AVOutputStream *ost, **ost_table = NULL;
1409 AVInputStream *ist, **ist_table = NULL;
1410 AVInputFile *file_table;
1411 AVFormatContext *stream_no_data;
1414 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1418 /* input stream init */
1420 for(i=0;i<nb_input_files;i++) {
1421 is = input_files[i];
1422 file_table[i].ist_index = j;
1423 file_table[i].nb_streams = is->nb_streams;
1424 j += is->nb_streams;
1428 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1432 for(i=0;i<nb_istreams;i++) {
1433 ist = av_mallocz(sizeof(AVInputStream));
1439 for(i=0;i<nb_input_files;i++) {
1440 is = input_files[i];
1441 for(k=0;k<is->nb_streams;k++) {
1442 ist = ist_table[j++];
1443 ist->st = is->streams[k];
1444 ist->file_index = i;
1446 ist->discard = 1; /* the stream is discarded by default
1449 if (ist->st->codec->rate_emu) {
1450 ist->start = av_gettime();
1456 /* output stream init */
1458 for(i=0;i<nb_output_files;i++) {
1459 os = output_files[i];
1460 nb_ostreams += os->nb_streams;
1462 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1463 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1467 /* Sanity check the mapping args -- do the input files & streams exist? */
1468 for(i=0;i<nb_stream_maps;i++) {
1469 int fi = stream_maps[i].file_index;
1470 int si = stream_maps[i].stream_index;
1472 if (fi < 0 || fi > nb_input_files - 1 ||
1473 si < 0 || si > file_table[fi].nb_streams - 1) {
1474 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1477 fi = stream_maps[i].sync_file_index;
1478 si = stream_maps[i].sync_stream_index;
1479 if (fi < 0 || fi > nb_input_files - 1 ||
1480 si < 0 || si > file_table[fi].nb_streams - 1) {
1481 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1486 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1489 for(i=0;i<nb_ostreams;i++) {
1490 ost = av_mallocz(sizeof(AVOutputStream));
1497 for(k=0;k<nb_output_files;k++) {
1498 os = output_files[k];
1499 for(i=0;i<os->nb_streams;i++) {
1501 ost = ost_table[n++];
1502 ost->file_index = k;
1504 ost->st = os->streams[i];
1505 if (nb_stream_maps > 0) {
1506 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1507 stream_maps[n-1].stream_index;
1509 /* Sanity check that the stream types match */
1510 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1511 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1512 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1513 ost->file_index, ost->index);
1518 /* get corresponding input stream index : we select the first one with the right type */
1520 for(j=0;j<nb_istreams;j++) {
1523 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1524 ost->source_index = j;
1531 /* try again and reuse existing stream */
1532 for(j=0;j<nb_istreams;j++) {
1534 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1535 ost->source_index = j;
1540 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1541 ost->file_index, ost->index);
1546 ist = ist_table[ost->source_index];
1548 ost->sync_ist = (nb_stream_maps > 0) ?
1549 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1550 stream_maps[n-1].sync_stream_index] : ist;
1554 /* for each output stream, we compute the right encoding parameters */
1555 for(i=0;i<nb_ostreams;i++) {
1557 ist = ist_table[ost->source_index];
1559 codec = ost->st->codec;
1560 icodec = ist->st->codec;
1562 if (ost->st->stream_copy) {
1563 /* if stream_copy is selected, no need to decode or encode */
1564 codec->codec_id = icodec->codec_id;
1565 codec->codec_type = icodec->codec_type;
1566 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1567 codec->bit_rate = icodec->bit_rate;
1568 codec->extradata= icodec->extradata;
1569 codec->extradata_size= icodec->extradata_size;
1570 codec->time_base = icodec->time_base;
1571 switch(codec->codec_type) {
1572 case CODEC_TYPE_AUDIO:
1573 codec->sample_rate = icodec->sample_rate;
1574 codec->channels = icodec->channels;
1575 codec->frame_size = icodec->frame_size;
1576 codec->block_align= icodec->block_align;
1578 case CODEC_TYPE_VIDEO:
1579 codec->pix_fmt = icodec->pix_fmt;
1580 codec->width = icodec->width;
1581 codec->height = icodec->height;
1582 codec->has_b_frames = icodec->has_b_frames;
1584 case CODEC_TYPE_SUBTITLE:
1590 switch(codec->codec_type) {
1591 case CODEC_TYPE_AUDIO:
1592 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1595 if (codec->channels == icodec->channels &&
1596 codec->sample_rate == icodec->sample_rate) {
1597 ost->audio_resample = 0;
1599 if (codec->channels != icodec->channels &&
1600 (icodec->codec_id == CODEC_ID_AC3 ||
1601 icodec->codec_id == CODEC_ID_DTS)) {
1602 /* Special case for 5:1 AC3 and DTS input */
1603 /* and mono or stereo output */
1604 /* Request specific number of channels */
1605 icodec->channels = codec->channels;
1606 if (codec->sample_rate == icodec->sample_rate)
1607 ost->audio_resample = 0;
1609 ost->audio_resample = 1;
1612 ost->audio_resample = 1;
1615 if(audio_sync_method>1)
1616 ost->audio_resample = 1;
1618 if(ost->audio_resample){
1619 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1620 codec->sample_rate, icodec->sample_rate);
1622 printf("Can't resample. Aborting.\n");
1626 ist->decoding_needed = 1;
1627 ost->encoding_needed = 1;
1629 case CODEC_TYPE_VIDEO:
1630 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1631 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1632 ost->video_resample = ((codec->width != icodec->width -
1633 (frame_leftBand + frame_rightBand) +
1634 (frame_padleft + frame_padright)) ||
1635 (codec->height != icodec->height -
1636 (frame_topBand + frame_bottomBand) +
1637 (frame_padtop + frame_padbottom)) ||
1638 (codec->pix_fmt != icodec->pix_fmt));
1639 if (ost->video_crop) {
1640 ost->topBand = frame_topBand;
1641 ost->leftBand = frame_leftBand;
1643 if (ost->video_pad) {
1644 ost->padtop = frame_padtop;
1645 ost->padleft = frame_padleft;
1646 ost->padbottom = frame_padbottom;
1647 ost->padright = frame_padright;
1648 if (!ost->video_resample) {
1649 avcodec_get_frame_defaults(&ost->pict_tmp);
1650 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1651 codec->width, codec->height ) )
1655 if (ost->video_resample) {
1656 avcodec_get_frame_defaults(&ost->pict_tmp);
1657 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1658 codec->width, codec->height ) )
1661 ost->img_resample_ctx = sws_getContext(
1662 icodec->width - (frame_leftBand + frame_rightBand),
1663 icodec->height - (frame_topBand + frame_bottomBand),
1665 codec->width - (frame_padleft + frame_padright),
1666 codec->height - (frame_padtop + frame_padbottom),
1668 sws_flags, NULL, NULL, NULL);
1669 if (ost->img_resample_ctx == NULL) {
1670 fprintf(stderr, "Cannot get resampling context\n");
1673 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1675 ost->encoding_needed = 1;
1676 ist->decoding_needed = 1;
1678 case CODEC_TYPE_SUBTITLE:
1679 ost->encoding_needed = 1;
1680 ist->decoding_needed = 1;
1687 if (ost->encoding_needed &&
1688 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1689 char logfilename[1024];
1694 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1696 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1697 if (codec->flags & CODEC_FLAG_PASS1) {
1698 f = fopen(logfilename, "w");
1700 perror(logfilename);
1705 /* read the log file */
1706 f = fopen(logfilename, "r");
1708 perror(logfilename);
1711 fseek(f, 0, SEEK_END);
1713 fseek(f, 0, SEEK_SET);
1714 logbuffer = av_malloc(size + 1);
1716 fprintf(stderr, "Could not allocate log buffer\n");
1719 size = fread(logbuffer, 1, size, f);
1721 logbuffer[size] = '\0';
1722 codec->stats_in = logbuffer;
1726 if(codec->codec_type == CODEC_TYPE_VIDEO){
1727 int size= codec->width * codec->height;
1728 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1733 bit_buffer = av_malloc(bit_buffer_size);
1737 /* dump the file output parameters - cannot be done before in case
1739 for(i=0;i<nb_output_files;i++) {
1740 dump_format(output_files[i], i, output_files[i]->filename, 1);
1743 /* dump the stream mapping */
1745 fprintf(stderr, "Stream mapping:\n");
1746 for(i=0;i<nb_ostreams;i++) {
1748 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1749 ist_table[ost->source_index]->file_index,
1750 ist_table[ost->source_index]->index,
1753 if (ost->sync_ist != ist_table[ost->source_index])
1754 fprintf(stderr, " [sync #%d.%d]",
1755 ost->sync_ist->file_index,
1756 ost->sync_ist->index);
1757 fprintf(stderr, "\n");
1761 /* open each encoder */
1762 for(i=0;i<nb_ostreams;i++) {
1764 if (ost->encoding_needed) {
1766 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1768 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1769 ost->file_index, ost->index);
1772 if (avcodec_open(ost->st->codec, codec) < 0) {
1773 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1774 ost->file_index, ost->index);
1777 extra_size += ost->st->codec->extradata_size;
1781 /* open each decoder */
1782 for(i=0;i<nb_istreams;i++) {
1784 if (ist->decoding_needed) {
1786 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1788 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1789 ist->st->codec->codec_id, ist->file_index, ist->index);
1792 if (avcodec_open(ist->st->codec, codec) < 0) {
1793 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1794 ist->file_index, ist->index);
1797 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1798 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1803 for(i=0;i<nb_istreams;i++) {
1805 is = input_files[ist->file_index];
1807 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1808 if(ist->st->start_time == AV_NOPTS_VALUE)
1810 if(input_files_ts_offset[ist->file_index])
1811 ist->next_pts= AV_NOPTS_VALUE;
1815 /* compute buffer size max (should use a complete heuristic) */
1816 for(i=0;i<nb_input_files;i++) {
1817 file_table[i].buffer_size_max = 2048;
1820 /* set meta data information from input file if required */
1821 for (i=0;i<nb_meta_data_maps;i++) {
1822 AVFormatContext *out_file;
1823 AVFormatContext *in_file;
1825 int out_file_index = meta_data_maps[i].out_file;
1826 int in_file_index = meta_data_maps[i].in_file;
1827 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1828 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1832 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1833 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1838 out_file = output_files[out_file_index];
1839 in_file = input_files[in_file_index];
1841 strcpy(out_file->title, in_file->title);
1842 strcpy(out_file->author, in_file->author);
1843 strcpy(out_file->copyright, in_file->copyright);
1844 strcpy(out_file->comment, in_file->comment);
1845 strcpy(out_file->album, in_file->album);
1846 out_file->year = in_file->year;
1847 out_file->track = in_file->track;
1848 strcpy(out_file->genre, in_file->genre);
1851 /* open files and write file headers */
1852 for(i=0;i<nb_output_files;i++) {
1853 os = output_files[i];
1854 if (av_write_header(os) < 0) {
1855 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1862 if ( !using_stdin && verbose >= 0) {
1863 fprintf(stderr, "Press [q] to stop encoding\n");
1864 url_set_interrupt_cb(decode_interrupt_cb);
1872 for(; received_sigterm == 0;) {
1873 int file_index, ist_index;
1881 /* if 'q' pressed, exits */
1885 /* read_key() returns 0 on EOF */
1891 /* select the stream that we must read now by looking at the
1892 smallest output pts */
1894 for(i=0;i<nb_ostreams;i++) {
1897 os = output_files[ost->file_index];
1898 ist = ist_table[ost->source_index];
1899 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1900 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1902 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1903 ipts = (double)ist->pts;
1904 if (!file_table[ist->file_index].eof_reached){
1905 if(ipts < ipts_min) {
1907 if(input_sync ) file_index = ist->file_index;
1909 if(opts < opts_min) {
1911 if(!input_sync) file_index = ist->file_index;
1914 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1919 /* if none, if is finished */
1920 if (file_index < 0) {
1924 /* finish if recording time exhausted */
1925 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1928 /* finish if limit size exhausted */
1929 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1932 /* read a frame from it and output it in the fifo */
1933 is = input_files[file_index];
1934 if (av_read_frame(is, &pkt) < 0) {
1935 file_table[file_index].eof_reached = 1;
1936 if (opt_shortest) break; else continue; //
1940 stream_no_data = is;
1945 av_pkt_dump(stdout, &pkt, do_hex_dump);
1947 /* the following test is needed in case new streams appear
1948 dynamically in stream : we ignore them */
1949 if (pkt.stream_index >= file_table[file_index].nb_streams)
1950 goto discard_packet;
1951 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1952 ist = ist_table[ist_index];
1954 goto discard_packet;
1956 // 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);
1957 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1958 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1959 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1960 input_files_ts_offset[ist->file_index]-= delta;
1962 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1963 for(i=0; i<file_table[file_index].nb_streams; i++){
1964 int index= file_table[file_index].ist_index + i;
1965 ist_table[index]->next_pts += delta;
1966 ist_table[index]->is_start=1;
1971 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1972 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1975 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1976 ist->file_index, ist->index);
1978 av_free_packet(&pkt);
1983 av_free_packet(&pkt);
1985 /* dump report by using the output first video and audio streams */
1986 print_report(output_files, ost_table, nb_ostreams, 0);
1989 /* at the end of stream, we must flush the decoder buffers */
1990 for(i=0;i<nb_istreams;i++) {
1992 if (ist->decoding_needed) {
1993 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1999 /* write the trailer if needed and close file */
2000 for(i=0;i<nb_output_files;i++) {
2001 os = output_files[i];
2002 av_write_trailer(os);
2005 /* dump report by using the first video and audio streams */
2006 print_report(output_files, ost_table, nb_ostreams, 1);
2008 /* close each encoder */
2009 for(i=0;i<nb_ostreams;i++) {
2011 if (ost->encoding_needed) {
2012 av_freep(&ost->st->codec->stats_in);
2013 avcodec_close(ost->st->codec);
2017 /* close each decoder */
2018 for(i=0;i<nb_istreams;i++) {
2020 if (ist->decoding_needed) {
2021 avcodec_close(ist->st->codec);
2029 av_freep(&bit_buffer);
2030 av_free(file_table);
2033 for(i=0;i<nb_istreams;i++) {
2040 for(i=0;i<nb_ostreams;i++) {
2044 fclose(ost->logfile);
2045 ost->logfile = NULL;
2047 fifo_free(&ost->fifo); /* works even if fifo is not
2048 initialized but set to zero */
2049 av_free(ost->pict_tmp.data[0]);
2050 if (ost->video_resample)
2051 sws_freeContext(ost->img_resample_ctx);
2052 if (ost->audio_resample)
2053 audio_resample_close(ost->resample);
2066 int file_read(const char *filename)
2069 unsigned char buffer[1024];
2072 if (url_open(&h, filename, O_RDONLY) < 0) {
2073 printf("could not open '%s'\n", filename);
2077 len = url_read(h, buffer, sizeof(buffer));
2080 for(i=0;i<len;i++) putchar(buffer[i]);
2087 static void opt_image_format(const char *arg)
2091 for(f = first_image_format; f != NULL; f = f->next) {
2092 if (!strcmp(arg, f->name))
2096 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2102 static void opt_format(const char *arg)
2104 /* compatibility stuff for pgmyuv */
2105 if (!strcmp(arg, "pgmyuv")) {
2106 pgmyuv_compatibility_hack=1;
2107 // opt_image_format(arg);
2111 file_iformat = av_find_input_format(arg);
2112 file_oformat = guess_format(arg, NULL, NULL);
2113 if (!file_iformat && !file_oformat) {
2114 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2119 static void opt_video_bitrate(const char *arg)
2121 video_bit_rate = atoi(arg) * 1000;
2124 static void opt_video_bitrate_tolerance(const char *arg)
2126 video_bit_rate_tolerance = atoi(arg) * 1000;
2129 static void opt_video_bitrate_max(const char *arg)
2131 video_rc_max_rate = atoi(arg) * 1000;
2134 static void opt_video_bitrate_min(const char *arg)
2136 video_rc_min_rate = atoi(arg) * 1000;
2139 static void opt_video_buffer_size(const char *arg)
2141 video_rc_buffer_size = atoi(arg) * 8*1024;
2144 static void opt_video_rc_eq(char *arg)
2149 static void opt_video_rc_override_string(char *arg)
2151 video_rc_override_string = arg;
2155 static void opt_workaround_bugs(const char *arg)
2157 workaround_bugs = atoi(arg);
2160 static void opt_me_threshold(const char *arg)
2162 me_threshold = atoi(arg);
2165 static void opt_mb_threshold(const char *arg)
2167 mb_threshold = atoi(arg);
2170 static void opt_verbose(const char *arg)
2172 verbose = atoi(arg);
2173 av_log_set_level(atoi(arg));
2176 static void opt_frame_rate(const char *arg)
2178 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2179 fprintf(stderr, "Incorrect frame rate\n");
2184 static void opt_frame_crop_top(const char *arg)
2186 frame_topBand = atoi(arg);
2187 if (frame_topBand < 0) {
2188 fprintf(stderr, "Incorrect top crop size\n");
2191 if ((frame_topBand % 2) != 0) {
2192 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2195 if ((frame_topBand) >= frame_height){
2196 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2199 frame_height -= frame_topBand;
2202 static void opt_frame_crop_bottom(const char *arg)
2204 frame_bottomBand = atoi(arg);
2205 if (frame_bottomBand < 0) {
2206 fprintf(stderr, "Incorrect bottom crop size\n");
2209 if ((frame_bottomBand % 2) != 0) {
2210 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2213 if ((frame_bottomBand) >= frame_height){
2214 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2217 frame_height -= frame_bottomBand;
2220 static void opt_frame_crop_left(const char *arg)
2222 frame_leftBand = atoi(arg);
2223 if (frame_leftBand < 0) {
2224 fprintf(stderr, "Incorrect left crop size\n");
2227 if ((frame_leftBand % 2) != 0) {
2228 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2231 if ((frame_leftBand) >= frame_width){
2232 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2235 frame_width -= frame_leftBand;
2238 static void opt_frame_crop_right(const char *arg)
2240 frame_rightBand = atoi(arg);
2241 if (frame_rightBand < 0) {
2242 fprintf(stderr, "Incorrect right crop size\n");
2245 if ((frame_rightBand % 2) != 0) {
2246 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2249 if ((frame_rightBand) >= frame_width){
2250 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2253 frame_width -= frame_rightBand;
2256 static void opt_frame_size(const char *arg)
2258 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2259 fprintf(stderr, "Incorrect frame size\n");
2262 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2263 fprintf(stderr, "Frame size must be a multiple of 2\n");
2269 #define SCALEBITS 10
2270 #define ONE_HALF (1 << (SCALEBITS - 1))
2271 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2273 #define RGB_TO_Y(r, g, b) \
2274 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2275 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2277 #define RGB_TO_U(r1, g1, b1, shift)\
2278 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2279 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2281 #define RGB_TO_V(r1, g1, b1, shift)\
2282 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2283 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2285 static void opt_pad_color(const char *arg) {
2286 /* Input is expected to be six hex digits similar to
2287 how colors are expressed in html tags (but without the #) */
2288 int rgb = strtol(arg, NULL, 16);
2292 g = ((rgb >> 8) & 255);
2295 padcolor[0] = RGB_TO_Y(r,g,b);
2296 padcolor[1] = RGB_TO_U(r,g,b,0);
2297 padcolor[2] = RGB_TO_V(r,g,b,0);
2300 static void opt_frame_pad_top(const char *arg)
2302 frame_padtop = atoi(arg);
2303 if (frame_padtop < 0) {
2304 fprintf(stderr, "Incorrect top pad size\n");
2307 if ((frame_padtop % 2) != 0) {
2308 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2313 static void opt_frame_pad_bottom(const char *arg)
2315 frame_padbottom = atoi(arg);
2316 if (frame_padbottom < 0) {
2317 fprintf(stderr, "Incorrect bottom pad size\n");
2320 if ((frame_padbottom % 2) != 0) {
2321 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2327 static void opt_frame_pad_left(const char *arg)
2329 frame_padleft = atoi(arg);
2330 if (frame_padleft < 0) {
2331 fprintf(stderr, "Incorrect left pad size\n");
2334 if ((frame_padleft % 2) != 0) {
2335 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2341 static void opt_frame_pad_right(const char *arg)
2343 frame_padright = atoi(arg);
2344 if (frame_padright < 0) {
2345 fprintf(stderr, "Incorrect right pad size\n");
2348 if ((frame_padright % 2) != 0) {
2349 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2355 static void opt_frame_pix_fmt(const char *arg)
2357 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2360 static void opt_frame_aspect_ratio(const char *arg)
2366 p = strchr(arg, ':');
2368 x = strtol(arg, (char **)&arg, 10);
2370 y = strtol(arg+1, (char **)&arg, 10);
2372 ar = (double)x / (double)y;
2374 ar = strtod(arg, (char **)&arg);
2377 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2380 frame_aspect_ratio = ar;
2383 static void opt_gop_size(const char *arg)
2385 gop_size = atoi(arg);
2388 static void opt_b_frames(const char *arg)
2390 b_frames = atoi(arg);
2391 if (b_frames > FF_MAX_B_FRAMES) {
2392 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2394 } else if (b_frames < 1) {
2395 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2400 static void opt_pre_me(const char *arg)
2405 static void opt_qscale(const char *arg)
2407 video_qscale = atof(arg);
2408 if (video_qscale <= 0 ||
2409 video_qscale > 255) {
2410 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2415 static void opt_qsquish(const char *arg)
2417 video_qsquish = atof(arg);
2418 if (video_qsquish < 0.0 ||
2419 video_qsquish > 99.0) {
2420 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2425 static void opt_lmax(const char *arg)
2427 video_lmax = atof(arg)*FF_QP2LAMBDA;
2430 static void opt_lmin(const char *arg)
2432 video_lmin = atof(arg)*FF_QP2LAMBDA;
2435 static void opt_qmin(const char *arg)
2437 video_qmin = atoi(arg);
2438 if (video_qmin < 1 ||
2440 fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2445 static void opt_qmax(const char *arg)
2447 video_qmax = atoi(arg);
2448 if (video_qmax < 1 ||
2450 fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2455 static void opt_mb_lmin(const char *arg)
2457 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2458 if (video_mb_lmin < 1 ||
2459 video_mb_lmin > FF_LAMBDA_MAX) {
2460 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2465 static void opt_mb_lmax(const char *arg)
2467 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2468 if (video_mb_lmax < 1 ||
2469 video_mb_lmax > FF_LAMBDA_MAX) {
2470 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2475 static void opt_qdiff(const char *arg)
2477 video_qdiff = atoi(arg);
2478 if (video_qdiff < 0 ||
2480 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2485 static void opt_qblur(const char *arg)
2487 video_qblur = atof(arg);
2490 static void opt_qcomp(const char *arg)
2492 video_qcomp = atof(arg);
2495 static void opt_rc_initial_cplx(const char *arg)
2497 video_rc_initial_cplx = atof(arg);
2499 static void opt_b_qfactor(const char *arg)
2501 video_b_qfactor = atof(arg);
2503 static void opt_i_qfactor(const char *arg)
2505 video_i_qfactor = atof(arg);
2507 static void opt_b_qoffset(const char *arg)
2509 video_b_qoffset = atof(arg);
2511 static void opt_i_qoffset(const char *arg)
2513 video_i_qoffset = atof(arg);
2516 static void opt_ibias(const char *arg)
2518 video_intra_quant_bias = atoi(arg);
2520 static void opt_pbias(const char *arg)
2522 video_inter_quant_bias = atoi(arg);
2525 static void opt_packet_size(const char *arg)
2527 packet_size= atoi(arg);
2530 static void opt_error_rate(const char *arg)
2532 error_rate= atoi(arg);
2535 static void opt_strict(const char *arg)
2540 static void opt_top_field_first(const char *arg)
2542 top_field_first= atoi(arg);
2545 static void opt_sc_threshold(const char *arg)
2547 sc_threshold= atoi(arg);
2550 static void opt_me_range(const char *arg)
2552 me_range = atoi(arg);
2555 static void opt_thread_count(const char *arg)
2557 thread_count= atoi(arg);
2558 #if !defined(HAVE_THREADS)
2560 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2564 static void opt_audio_bitrate(const char *arg)
2566 audio_bit_rate = atoi(arg) * 1000;
2569 static void opt_audio_rate(const char *arg)
2571 audio_sample_rate = atoi(arg);
2574 static void opt_audio_channels(const char *arg)
2576 audio_channels = atoi(arg);
2579 static void opt_video_device(const char *arg)
2581 video_device = av_strdup(arg);
2584 static void opt_grab_device(const char *arg)
2586 grab_device = av_strdup(arg);
2589 static void opt_video_channel(const char *arg)
2591 video_channel = strtol(arg, NULL, 0);
2594 static void opt_video_standard(const char *arg)
2596 video_standard = av_strdup(arg);
2599 static void opt_audio_device(const char *arg)
2601 audio_device = av_strdup(arg);
2604 static void opt_codec(int *pstream_copy, int *pcodec_id,
2605 int codec_type, const char *arg)
2609 if (!strcmp(arg, "copy")) {
2614 if (!strcmp(p->name, arg) && p->type == codec_type)
2619 fprintf(stderr, "Unknown codec '%s'\n", arg);
2627 static void opt_audio_codec(const char *arg)
2629 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2632 static void opt_audio_tag(const char *arg)
2635 audio_codec_tag= strtol(arg, &tail, 0);
2638 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2641 static void opt_video_tag(const char *arg)
2644 video_codec_tag= strtol(arg, &tail, 0);
2647 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2650 static void add_frame_hooker(const char *arg)
2655 char *args = av_strdup(arg);
2659 argv[0] = strtok(args, " ");
2660 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2663 i = frame_hook_add(argc, argv);
2666 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2671 const char *motion_str[] = {
2684 static void opt_motion_estimation(const char *arg)
2690 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2693 if (!strcmp(*p, arg))
2697 me_method = (p - motion_str) + 1;
2700 static void opt_video_codec(const char *arg)
2702 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2705 static void opt_subtitle_codec(const char *arg)
2707 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2710 static void opt_map(const char *arg)
2716 m = &stream_maps[nb_stream_maps++];
2718 m->file_index = strtol(arg, (char **)&p, 0);
2722 m->stream_index = strtol(p, (char **)&p, 0);
2725 m->sync_file_index = strtol(p, (char **)&p, 0);
2728 m->sync_stream_index = strtol(p, (char **)&p, 0);
2730 m->sync_file_index = m->file_index;
2731 m->sync_stream_index = m->stream_index;
2735 static void opt_map_meta_data(const char *arg)
2741 m = &meta_data_maps[nb_meta_data_maps++];
2743 m->out_file = strtol(arg, (char **)&p, 0);
2747 m->in_file = strtol(p, (char **)&p, 0);
2750 static void opt_recording_time(const char *arg)
2752 recording_time = parse_date(arg, 1);
2755 static void opt_start_time(const char *arg)
2757 start_time = parse_date(arg, 1);
2760 static void opt_rec_timestamp(const char *arg)
2762 rec_timestamp = parse_date(arg, 0) / 1000000;
2765 static void opt_input_ts_offset(const char *arg)
2767 input_ts_offset = parse_date(arg, 1);
2770 static void opt_input_file(const char *filename)
2772 AVFormatContext *ic;
2773 AVFormatParameters params, *ap = ¶ms;
2774 int err, i, ret, rfps, rfps_base;
2777 if (!strcmp(filename, "-"))
2780 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2781 !strcmp( filename, "/dev/stdin" );
2783 /* get default parameters from command line */
2784 ic = av_alloc_format_context();
2786 memset(ap, 0, sizeof(*ap));
2787 ap->prealloced_context = 1;
2788 ap->sample_rate = audio_sample_rate;
2789 ap->channels = audio_channels;
2790 ap->time_base.den = frame_rate;
2791 ap->time_base.num = frame_rate_base;
2792 ap->width = frame_width + frame_padleft + frame_padright;
2793 ap->height = frame_height + frame_padtop + frame_padbottom;
2794 ap->image_format = image_format;
2795 ap->pix_fmt = frame_pix_fmt;
2796 ap->device = grab_device;
2797 ap->channel = video_channel;
2798 ap->standard = video_standard;
2799 ap->video_codec_id = video_codec_id;
2800 ap->audio_codec_id = audio_codec_id;
2801 if(pgmyuv_compatibility_hack)
2802 ap->video_codec_id= CODEC_ID_PGMYUV;
2804 for(i=0; i<opt_name_count; i++){
2806 double d= av_get_double(avformat_opts, opt_names[i], &opt);
2807 if(d==d && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2808 av_set_double(ic, opt_names[i], d);
2810 /* open the input file with generic libav function */
2811 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2813 print_error(filename, err);
2817 ic->loop_input = loop_input;
2819 /* If not enough info to get the stream parameters, we decode the
2820 first frames to get it. (used in mpeg case for example) */
2821 ret = av_find_stream_info(ic);
2822 if (ret < 0 && verbose >= 0) {
2823 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2827 timestamp = start_time;
2828 /* add the stream start time */
2829 if (ic->start_time != AV_NOPTS_VALUE)
2830 timestamp += ic->start_time;
2832 /* if seeking requested, we execute it */
2833 if (start_time != 0) {
2834 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2836 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2837 filename, (double)timestamp / AV_TIME_BASE);
2839 /* reset seek info */
2843 /* update the current parameters so that they match the one of the input stream */
2844 for(i=0;i<ic->nb_streams;i++) {
2846 AVCodecContext *enc = ic->streams[i]->codec;
2847 #if defined(HAVE_THREADS)
2849 avcodec_thread_init(enc, thread_count);
2851 enc->thread_count= thread_count;
2852 switch(enc->codec_type) {
2853 case CODEC_TYPE_AUDIO:
2854 for(j=0; j<opt_name_count; j++){
2856 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2857 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2858 av_set_double(enc, opt_names[j], d);
2860 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2861 audio_channels = enc->channels;
2862 audio_sample_rate = enc->sample_rate;
2864 ic->streams[i]->discard= AVDISCARD_ALL;
2866 case CODEC_TYPE_VIDEO:
2867 for(j=0; j<opt_name_count; j++){
2869 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2870 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2871 av_set_double(enc, opt_names[j], d);
2873 frame_height = enc->height;
2874 frame_width = enc->width;
2875 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2876 frame_pix_fmt = enc->pix_fmt;
2877 rfps = ic->streams[i]->r_frame_rate.num;
2878 rfps_base = ic->streams[i]->r_frame_rate.den;
2879 enc->workaround_bugs = workaround_bugs;
2880 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2882 enc->debug |= FF_DEBUG_MV;
2884 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2887 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2888 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2890 (float)rfps / rfps_base, rfps, rfps_base);
2892 /* update the current frame rate to match the stream frame rate */
2894 frame_rate_base = rfps_base;
2896 enc->rate_emu = rate_emu;
2898 ic->streams[i]->discard= AVDISCARD_ALL;
2899 else if(video_discard)
2900 ic->streams[i]->discard= video_discard;
2902 case CODEC_TYPE_DATA:
2904 case CODEC_TYPE_SUBTITLE:
2906 case CODEC_TYPE_UNKNOWN:
2913 input_files[nb_input_files] = ic;
2914 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2915 /* dump the file content */
2917 dump_format(ic, nb_input_files, filename, 0);
2920 file_iformat = NULL;
2921 file_oformat = NULL;
2922 image_format = NULL;
2930 static void opt_grab(const char *arg)
2932 file_iformat = av_find_input_format(arg);
2936 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2938 int has_video, has_audio, i, j;
2939 AVFormatContext *ic;
2943 for(j=0;j<nb_input_files;j++) {
2944 ic = input_files[j];
2945 for(i=0;i<ic->nb_streams;i++) {
2946 AVCodecContext *enc = ic->streams[i]->codec;
2947 switch(enc->codec_type) {
2948 case CODEC_TYPE_AUDIO:
2951 case CODEC_TYPE_VIDEO:
2954 case CODEC_TYPE_DATA:
2955 case CODEC_TYPE_UNKNOWN:
2956 case CODEC_TYPE_SUBTITLE:
2963 *has_video_ptr = has_video;
2964 *has_audio_ptr = has_audio;
2967 static void new_video_stream(AVFormatContext *oc)
2970 AVCodecContext *video_enc;
2973 st = av_new_stream(oc, oc->nb_streams);
2975 fprintf(stderr, "Could not alloc stream\n");
2978 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2979 video_bitstream_filters= NULL;
2981 #if defined(HAVE_THREADS)
2983 avcodec_thread_init(st->codec, thread_count);
2986 video_enc = st->codec;
2989 video_enc->codec_tag= video_codec_tag;
2991 if( (video_global_header&1)
2992 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2993 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2994 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2996 if(video_global_header&2){
2997 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2998 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3001 if (video_stream_copy) {
3002 st->stream_copy = 1;
3003 video_enc->codec_type = CODEC_TYPE_VIDEO;
3009 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3010 if (video_codec_id != CODEC_ID_NONE)
3011 codec_id = video_codec_id;
3013 video_enc->codec_id = codec_id;
3014 codec = avcodec_find_encoder(codec_id);
3016 for(i=0; i<opt_name_count; i++){
3018 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3019 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3020 av_set_double(video_enc, opt_names[i], d);
3023 video_enc->bit_rate = video_bit_rate;
3024 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3025 video_enc->time_base.den = frame_rate;
3026 video_enc->time_base.num = frame_rate_base;
3027 if(codec && codec->supported_framerates){
3028 const AVRational *p= codec->supported_framerates;
3029 AVRational req= (AVRational){frame_rate, frame_rate_base};
3030 const AVRational *best=NULL;
3031 AVRational best_error= (AVRational){INT_MAX, 1};
3032 for(; p->den!=0; p++){
3033 AVRational error= av_sub_q(req, *p);
3034 if(error.num <0) error.num *= -1;
3035 if(av_cmp_q(error, best_error) < 0){
3040 video_enc->time_base.den= best->num;
3041 video_enc->time_base.num= best->den;
3044 video_enc->width = frame_width + frame_padright + frame_padleft;
3045 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3046 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3047 video_enc->pix_fmt = frame_pix_fmt;
3049 if(codec && codec->pix_fmts){
3050 const enum PixelFormat *p= codec->pix_fmts;
3052 if(*p == video_enc->pix_fmt)
3056 video_enc->pix_fmt = codec->pix_fmts[0];
3060 video_enc->gop_size = gop_size;
3062 video_enc->gop_size = 0;
3063 if (video_qscale || same_quality) {
3064 video_enc->flags |= CODEC_FLAG_QSCALE;
3065 video_enc->global_quality=
3066 st->quality = FF_QP2LAMBDA * video_qscale;
3070 video_enc->intra_matrix = intra_matrix;
3072 video_enc->inter_matrix = inter_matrix;
3074 video_enc->pre_me = pre_me;
3077 video_enc->max_b_frames = b_frames;
3078 video_enc->b_quant_factor = 2.0;
3080 video_enc->qmin = video_qmin;
3081 video_enc->qmax = video_qmax;
3082 video_enc->lmin = video_lmin;
3083 video_enc->lmax = video_lmax;
3084 video_enc->rc_qsquish = video_qsquish;
3085 video_enc->mb_lmin = video_mb_lmin;
3086 video_enc->mb_lmax = video_mb_lmax;
3087 video_enc->max_qdiff = video_qdiff;
3088 video_enc->qblur = video_qblur;
3089 video_enc->qcompress = video_qcomp;
3090 video_enc->rc_eq = video_rc_eq;
3091 video_enc->workaround_bugs = workaround_bugs;
3092 video_enc->thread_count = thread_count;
3093 p= video_rc_override_string;
3096 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3098 fprintf(stderr, "error parsing rc_override\n");
3101 video_enc->rc_override=
3102 av_realloc(video_enc->rc_override,
3103 sizeof(RcOverride)*(i+1));
3104 video_enc->rc_override[i].start_frame= start;
3105 video_enc->rc_override[i].end_frame = end;
3107 video_enc->rc_override[i].qscale= q;
3108 video_enc->rc_override[i].quality_factor= 1.0;
3111 video_enc->rc_override[i].qscale= 0;
3112 video_enc->rc_override[i].quality_factor= -q/100.0;
3117 video_enc->rc_override_count=i;
3119 video_enc->rc_max_rate = video_rc_max_rate;
3120 video_enc->rc_min_rate = video_rc_min_rate;
3121 video_enc->rc_buffer_size = video_rc_buffer_size;
3122 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3123 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3124 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3125 video_enc->i_quant_factor = video_i_qfactor;
3126 video_enc->b_quant_factor = video_b_qfactor;
3127 video_enc->i_quant_offset = video_i_qoffset;
3128 video_enc->b_quant_offset = video_b_qoffset;
3129 video_enc->intra_quant_bias = video_intra_quant_bias;
3130 video_enc->inter_quant_bias = video_inter_quant_bias;
3131 video_enc->me_threshold= me_threshold;
3132 video_enc->mb_threshold= mb_threshold;
3133 video_enc->intra_dc_precision= intra_dc_precision - 8;
3134 video_enc->strict_std_compliance = strict;
3135 video_enc->error_rate = error_rate;
3136 video_enc->scenechange_threshold= sc_threshold;
3137 video_enc->me_range = me_range;
3138 video_enc->me_penalty_compensation= me_penalty_compensation;
3139 video_enc->frame_skip_threshold= frame_skip_threshold;
3140 video_enc->frame_skip_factor= frame_skip_factor;
3141 video_enc->frame_skip_exp= frame_skip_exp;
3144 video_enc->rtp_mode= 1;
3145 video_enc->rtp_payload_size= packet_size;
3149 video_enc->flags|= CODEC_FLAG_PSNR;
3151 video_enc->me_method = me_method;
3156 video_enc->flags |= CODEC_FLAG_PASS1;
3158 video_enc->flags |= CODEC_FLAG_PASS2;
3163 /* reset some key parameters */
3165 video_codec_id = CODEC_ID_NONE;
3166 video_stream_copy = 0;
3169 static void new_audio_stream(AVFormatContext *oc)
3172 AVCodecContext *audio_enc;
3175 st = av_new_stream(oc, oc->nb_streams);
3177 fprintf(stderr, "Could not alloc stream\n");
3181 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3182 audio_bitstream_filters= NULL;
3184 #if defined(HAVE_THREADS)
3186 avcodec_thread_init(st->codec, thread_count);
3189 audio_enc = st->codec;
3190 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3193 audio_enc->codec_tag= audio_codec_tag;
3195 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3196 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3197 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3199 if (audio_stream_copy) {
3200 st->stream_copy = 1;
3201 audio_enc->channels = audio_channels;
3203 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3205 for(i=0; i<opt_name_count; i++){
3207 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3208 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3209 av_set_double(audio_enc, opt_names[i], d);
3212 if (audio_codec_id != CODEC_ID_NONE)
3213 codec_id = audio_codec_id;
3214 audio_enc->codec_id = codec_id;
3216 audio_enc->bit_rate = audio_bit_rate;
3217 if (audio_qscale > QSCALE_NONE) {
3218 audio_enc->flags |= CODEC_FLAG_QSCALE;
3219 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3221 audio_enc->strict_std_compliance = strict;
3222 audio_enc->thread_count = thread_count;
3223 /* For audio codecs other than AC3 or DTS we limit */
3224 /* the number of coded channels to stereo */
3225 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3226 && codec_id != CODEC_ID_DTS) {
3227 audio_enc->channels = 2;
3229 audio_enc->channels = audio_channels;
3231 audio_enc->sample_rate = audio_sample_rate;
3232 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3233 if (audio_language) {
3234 pstrcpy(st->language, sizeof(st->language), audio_language);
3235 av_free(audio_language);
3236 audio_language = NULL;
3239 /* reset some key parameters */
3241 audio_codec_id = CODEC_ID_NONE;
3242 audio_stream_copy = 0;
3245 static void opt_new_subtitle_stream(void)
3247 AVFormatContext *oc;
3249 AVCodecContext *subtitle_enc;
3252 if (nb_output_files <= 0) {
3253 fprintf(stderr, "At least one output file must be specified\n");
3256 oc = output_files[nb_output_files - 1];
3258 st = av_new_stream(oc, oc->nb_streams);
3260 fprintf(stderr, "Could not alloc stream\n");
3264 subtitle_enc = st->codec;
3265 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3266 if (subtitle_stream_copy) {
3267 st->stream_copy = 1;
3269 for(i=0; i<opt_name_count; i++){
3271 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3272 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3273 av_set_double(subtitle_enc, opt_names[i], d);
3275 subtitle_enc->codec_id = subtitle_codec_id;
3278 if (subtitle_language) {
3279 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3280 av_free(subtitle_language);
3281 subtitle_language = NULL;
3284 subtitle_codec_id = CODEC_ID_NONE;
3285 subtitle_stream_copy = 0;
3288 static void opt_new_audio_stream(void)
3290 AVFormatContext *oc;
3291 if (nb_output_files <= 0) {
3292 fprintf(stderr, "At least one output file must be specified\n");
3295 oc = output_files[nb_output_files - 1];
3296 new_audio_stream(oc);
3299 static void opt_new_video_stream(void)
3301 AVFormatContext *oc;
3302 if (nb_output_files <= 0) {
3303 fprintf(stderr, "At least one output file must be specified\n");
3306 oc = output_files[nb_output_files - 1];
3307 new_video_stream(oc);
3310 static void opt_output_file(const char *filename)
3312 AVFormatContext *oc;
3313 int use_video, use_audio, input_has_video, input_has_audio, i;
3314 AVFormatParameters params, *ap = ¶ms;
3316 if (!strcmp(filename, "-"))
3319 oc = av_alloc_format_context();
3321 if (!file_oformat) {
3322 file_oformat = guess_format(NULL, filename, NULL);
3323 if (!file_oformat) {
3324 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3330 oc->oformat = file_oformat;
3331 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3333 if (!strcmp(file_oformat->name, "ffm") &&
3334 strstart(filename, "http:", NULL)) {
3335 /* special case for files sent to ffserver: we get the stream
3336 parameters from ffserver */
3337 if (read_ffserver_streams(oc, filename) < 0) {
3338 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3342 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3343 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3345 /* disable if no corresponding type found and at least one
3347 if (nb_input_files > 0) {
3348 check_audio_video_inputs(&input_has_video, &input_has_audio);
3349 if (!input_has_video)
3351 if (!input_has_audio)
3355 /* manual disable */
3356 if (audio_disable) {
3359 if (video_disable) {
3364 new_video_stream(oc);
3368 new_audio_stream(oc);
3371 if (!oc->nb_streams) {
3372 fprintf(stderr, "No audio or video streams available\n");
3376 oc->timestamp = rec_timestamp;
3379 pstrcpy(oc->title, sizeof(oc->title), str_title);
3381 pstrcpy(oc->author, sizeof(oc->author), str_author);
3383 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3385 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3387 pstrcpy(oc->album, sizeof(oc->album), str_album);
3390 output_files[nb_output_files++] = oc;
3392 /* check filename in case of an image number is expected */
3393 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3394 if (!av_filename_number_test(oc->filename)) {
3395 print_error(oc->filename, AVERROR_NUMEXPECTED);
3400 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3401 /* test if it already exists to avoid loosing precious files */
3402 if (!file_overwrite &&
3403 (strchr(filename, ':') == NULL ||
3404 strstart(filename, "file:", NULL))) {
3405 if (url_exist(filename)) {
3408 if ( !using_stdin ) {
3409 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3412 if (toupper(c) != 'Y') {
3413 fprintf(stderr, "Not overwriting - exiting\n");
3418 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3425 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3426 fprintf(stderr, "Could not open '%s'\n", filename);
3431 memset(ap, 0, sizeof(*ap));
3432 ap->image_format = image_format;
3433 if (av_set_parameters(oc, ap) < 0) {
3434 fprintf(stderr, "%s: Invalid encoding parameters\n",
3439 oc->packet_size= mux_packet_size;
3440 oc->mux_rate= mux_rate;
3441 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3442 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3443 oc->loop_output = loop_output;
3445 for(i=0; i<opt_name_count; i++){
3447 double d = av_get_double(avformat_opts, opt_names[i], &opt);
3448 if(d==d && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3449 av_set_double(oc, opt_names[i], d);
3452 /* reset some options */
3453 file_oformat = NULL;
3454 file_iformat = NULL;
3455 image_format = NULL;
3458 /* prepare dummy protocols for grab */
3459 static void prepare_grab(void)
3461 int has_video, has_audio, i, j;
3462 AVFormatContext *oc;
3463 AVFormatContext *ic;
3464 AVFormatParameters vp1, *vp = &vp1;
3465 AVFormatParameters ap1, *ap = &ap1;
3467 /* see if audio/video inputs are needed */
3470 memset(ap, 0, sizeof(*ap));
3471 memset(vp, 0, sizeof(*vp));
3472 vp->time_base.num= 1;
3473 for(j=0;j<nb_output_files;j++) {
3474 oc = output_files[j];
3475 for(i=0;i<oc->nb_streams;i++) {
3476 AVCodecContext *enc = oc->streams[i]->codec;
3477 switch(enc->codec_type) {
3478 case CODEC_TYPE_AUDIO:
3479 if (enc->sample_rate > ap->sample_rate)
3480 ap->sample_rate = enc->sample_rate;
3481 if (enc->channels > ap->channels)
3482 ap->channels = enc->channels;
3485 case CODEC_TYPE_VIDEO:
3486 if (enc->width > vp->width)
3487 vp->width = enc->width;
3488 if (enc->height > vp->height)
3489 vp->height = enc->height;
3491 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3492 vp->time_base = enc->time_base;
3493 vp->width += frame_leftBand + frame_rightBand;
3494 vp->width -= (frame_padleft + frame_padright);
3495 vp->height += frame_topBand + frame_bottomBand;
3496 vp->height -= (frame_padtop + frame_padbottom);
3506 if (has_video == 0 && has_audio == 0) {
3507 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3512 AVInputFormat *fmt1;
3513 fmt1 = av_find_input_format(video_grab_format);
3514 vp->device = video_device;
3515 vp->channel = video_channel;
3516 vp->standard = video_standard;
3517 vp->pix_fmt = frame_pix_fmt;
3518 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3519 fprintf(stderr, "Could not find video grab device\n");
3522 /* If not enough info to get the stream parameters, we decode the
3523 first frames to get it. */
3524 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3525 fprintf(stderr, "Could not find video grab parameters\n");
3528 /* by now video grab has one stream */
3529 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3530 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3531 input_files[nb_input_files] = ic;
3534 dump_format(ic, nb_input_files, "", 0);
3538 if (has_audio && audio_grab_format) {
3539 AVInputFormat *fmt1;
3540 fmt1 = av_find_input_format(audio_grab_format);
3541 ap->device = audio_device;
3542 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3543 fprintf(stderr, "Could not find audio grab device\n");
3546 input_files[nb_input_files] = ic;
3549 dump_format(ic, nb_input_files, "", 0);
3555 /* same option as mencoder */
3556 static void opt_pass(const char *pass_str)
3559 pass = atoi(pass_str);
3560 if (pass != 1 && pass != 2) {
3561 fprintf(stderr, "pass number can be only 1 or 2\n");
3567 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3568 static int64_t getutime(void)
3570 return av_gettime();
3573 static int64_t getutime(void)
3575 struct rusage rusage;
3577 getrusage(RUSAGE_SELF, &rusage);
3578 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3582 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3583 extern int ffm_nopts;
3586 static void show_formats(void)
3588 AVInputFormat *ifmt;
3589 AVOutputFormat *ofmt;
3590 AVImageFormat *image_fmt;
3593 const char **pp, *last_name;
3595 printf("File formats:\n");
3600 const char *name=NULL;
3601 const char *long_name=NULL;
3603 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3604 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3605 strcmp(ofmt->name, last_name)>0){
3607 long_name= ofmt->long_name;
3611 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3612 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3613 strcmp(ifmt->name, last_name)>0){
3615 long_name= ifmt->long_name;
3618 if(name && strcmp(ifmt->name, name)==0)
3630 long_name ? long_name:" ");
3634 printf("Image formats (filename extensions, if any, follow):\n");
3635 for(image_fmt = first_image_format; image_fmt != NULL;
3636 image_fmt = image_fmt->next) {
3639 image_fmt->img_read ? "D":" ",
3640 image_fmt->img_write ? "E":" ",
3642 image_fmt->extensions ? image_fmt->extensions:" ");
3646 printf("Codecs:\n");
3652 const char *type_str;
3655 for(p = first_avcodec; p != NULL; p = p->next) {
3656 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3657 strcmp(p->name, last_name)>0){
3659 decode= encode= cap=0;
3661 if(p2 && strcmp(p->name, p2->name)==0){
3662 if(p->decode) decode=1;
3663 if(p->encode) encode=1;
3664 cap |= p->capabilities;
3669 last_name= p2->name;
3672 case CODEC_TYPE_VIDEO:
3675 case CODEC_TYPE_AUDIO:
3678 case CODEC_TYPE_SUBTITLE:
3687 decode ? "D": (/*p2->decoder ? "d":*/" "),
3690 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3691 cap & CODEC_CAP_DR1 ? "D":" ",
3692 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3694 /* if(p2->decoder && decode==0)
3695 printf(" use %s for decoding", p2->decoder->name);*/
3700 printf("Supported file protocols:\n");
3701 for(up = first_protocol; up != NULL; up = up->next)
3702 printf(" %s:", up->name);
3705 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3706 printf("Motion estimation methods:\n");
3710 if ((pp - motion_str + 1) == ME_ZERO)
3711 printf("(fastest)");
3712 else if ((pp - motion_str + 1) == ME_FULL)
3713 printf("(slowest)");
3714 else if ((pp - motion_str + 1) == ME_EPZS)
3715 printf("(default)");
3720 "Note, the names of encoders and decoders dont always match, so there are\n"
3721 "several cases where the above table shows encoder only or decoder only entries\n"
3722 "even though both encoding and decoding are supported for example, the h263\n"
3723 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3728 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3731 const char *p = str;
3738 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3745 static void opt_inter_matrix(const char *arg)
3747 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3748 parse_matrix_coeffs(inter_matrix, arg);
3751 static void opt_intra_matrix(const char *arg)
3753 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3754 parse_matrix_coeffs(intra_matrix, arg);
3757 static void opt_target(const char *arg)
3760 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3762 if(!strncmp(arg, "pal-", 4)) {
3765 } else if(!strncmp(arg, "ntsc-", 5)) {
3768 } else if(!strncmp(arg, "film-", 5)) {
3773 /* Calculate FR via float to avoid int overflow */
3774 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3777 } else if((fr == 29970) || (fr == 23976)) {
3780 /* Try to determine PAL/NTSC by peeking in the input files */
3781 if(nb_input_files) {
3783 for(j = 0; j < nb_input_files; j++) {
3784 for(i = 0; i < input_files[j]->nb_streams; i++) {
3785 AVCodecContext *c = input_files[j]->streams[i]->codec;
3786 if(c->codec_type != CODEC_TYPE_VIDEO)
3788 fr = c->time_base.den * 1000 / c->time_base.num;
3792 } else if((fr == 29970) || (fr == 23976)) {
3802 if(verbose && norm >= 0)
3803 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3807 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3808 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3809 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3813 if(!strcmp(arg, "vcd")) {
3815 opt_video_codec("mpeg1video");
3816 opt_audio_codec("mp2");
3819 opt_frame_size(norm ? "352x240" : "352x288");
3820 opt_frame_rate(frame_rates[norm]);
3821 opt_gop_size(norm ? "18" : "15");
3823 video_bit_rate = 1150000;
3824 video_rc_max_rate = 1150000;
3825 video_rc_min_rate = 1150000;
3826 video_rc_buffer_size = 40*1024*8;
3828 audio_bit_rate = 224000;
3829 audio_sample_rate = 44100;
3831 mux_packet_size= 2324;
3832 mux_rate= 2352 * 75 * 8;
3834 /* We have to offset the PTS, so that it is consistent with the SCR.
3835 SCR starts at 36000, but the first two packs contain only padding
3836 and the first pack from the other stream, respectively, may also have
3837 been written before.
3838 So the real data starts at SCR 36000+3*1200. */
3839 mux_preload= (36000+3*1200) / 90000.0; //0.44
3840 } else if(!strcmp(arg, "svcd")) {
3842 opt_video_codec("mpeg2video");
3843 opt_audio_codec("mp2");
3846 opt_frame_size(norm ? "480x480" : "480x576");
3847 opt_frame_rate(frame_rates[norm]);
3848 opt_gop_size(norm ? "18" : "15");
3850 video_bit_rate = 2040000;
3851 video_rc_max_rate = 2516000;
3852 video_rc_min_rate = 0; //1145000;
3853 video_rc_buffer_size = 224*1024*8;
3854 opt_default("flags", "+SCAN_OFFSET");
3857 audio_bit_rate = 224000;
3858 audio_sample_rate = 44100;
3860 mux_packet_size= 2324;
3862 } else if(!strcmp(arg, "dvd")) {
3864 opt_video_codec("mpeg2video");
3865 opt_audio_codec("ac3");
3868 opt_frame_size(norm ? "720x480" : "720x576");
3869 opt_frame_rate(frame_rates[norm]);
3870 opt_gop_size(norm ? "18" : "15");
3872 video_bit_rate = 6000000;
3873 video_rc_max_rate = 9000000;
3874 video_rc_min_rate = 0; //1500000;
3875 video_rc_buffer_size = 224*1024*8;
3877 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3878 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3880 audio_bit_rate = 448000;
3881 audio_sample_rate = 48000;
3883 } else if(!strncmp(arg, "dv", 2)) {
3887 opt_frame_size(norm ? "720x480" : "720x576");
3888 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3889 (norm ? "yuv411p" : "yuv420p"));
3890 opt_frame_rate(frame_rates[norm]);
3892 audio_sample_rate = 48000;
3896 fprintf(stderr, "Unknown target: %s\n", arg);
3901 static void opt_video_bsf(const char *arg)
3903 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3904 AVBitStreamFilterContext **bsfp;
3907 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3911 bsfp= &video_bitstream_filters;
3913 bsfp= &(*bsfp)->next;
3918 //FIXME avoid audio - video code duplication
3919 static void opt_audio_bsf(const char *arg)
3921 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3922 AVBitStreamFilterContext **bsfp;
3925 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3929 bsfp= &audio_bitstream_filters;
3931 bsfp= &(*bsfp)->next;
3936 static void show_version(void)
3938 /* TODO: add function interface to avutil and avformat */
3939 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3943 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3947 static int opt_default(const char *opt, const char *arg){
3948 AVOption *o= av_set_string(avctx_opts, opt, arg);
3950 o = av_set_string(avformat_opts, opt, arg);
3954 // av_log(NULL, AV_LOG_ERROR, "%s:%s: %f 0x%0X\n", opt, arg, av_get_double(avctx_opts, opt, NULL), (int)av_get_int(avctx_opts, opt, NULL));
3956 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3957 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3958 opt_names[opt_name_count++]= o->name;
3960 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3961 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3962 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3966 if(avctx_opts->debug)
3967 av_log_set_level(AV_LOG_DEBUG);
3971 const OptionDef options[] = {
3973 { "L", 0, {(void*)show_license}, "show license" },
3974 { "h", 0, {(void*)show_help}, "show help" },
3975 { "version", 0, {(void*)show_version}, "show version" },
3976 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3977 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3978 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3979 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3980 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3981 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3982 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3983 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3984 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3985 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3986 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3987 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3988 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3989 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3990 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3991 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3992 { "album", HAS_ARG | OPT_STRING, {(void*)&str_album}, "set the album", "string" },
3993 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3994 "add timings for benchmarking" },
3995 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3996 "dump each input packet" },
3997 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3998 "when dumping packets, also dump the payload" },
3999 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4000 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
4001 { "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)", "" },
4002 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
4003 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4004 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4005 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4006 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4007 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4008 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4009 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4010 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
4013 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4014 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4015 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4016 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4017 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4018 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4019 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4020 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4021 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4022 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4023 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4024 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4025 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4026 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4027 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4028 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4029 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4030 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4031 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4032 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4033 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4034 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4035 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4036 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4037 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4038 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4039 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4040 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4041 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4042 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4043 { "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" },
4044 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4045 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4046 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4047 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4048 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4049 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4050 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4051 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4052 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4053 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4054 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4055 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4056 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4057 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4058 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4059 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4061 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
4062 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
4063 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4064 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4065 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4066 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4067 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4068 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4069 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4070 "use same video quality as source (implies VBR)" },
4071 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4072 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4073 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4074 "deinterlace pictures" },
4075 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4076 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4077 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4078 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4079 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4080 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4081 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4082 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4083 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4084 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4085 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4086 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4087 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4088 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4089 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4090 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4093 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4094 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4095 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4096 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4097 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4098 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4099 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4100 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4101 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4102 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4104 /* subtitle options */
4105 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4106 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4107 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4110 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4111 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4112 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4113 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4115 /* G.2 grab options */
4116 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4117 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4120 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4121 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4122 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4123 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4125 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
4126 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
4128 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4132 static void show_banner(void)
4134 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4135 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
4136 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4137 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4138 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4139 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4141 fprintf(stderr, ", gcc: " __VERSION__ "\n");
4143 fprintf(stderr, ", using a non-gcc compiler\n");
4147 static void show_license(void)
4152 "This program is free software; you can redistribute it and/or modify\n"
4153 "it under the terms of the GNU General Public License as published by\n"
4154 "the Free Software Foundation; either version 2 of the License, or\n"
4155 "(at your option) any later version.\n"
4157 "This program is distributed in the hope that it will be useful,\n"
4158 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4159 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4160 "GNU General Public License for more details.\n"
4162 "You should have received a copy of the GNU General Public License\n"
4163 "along with this program; if not, write to the Free Software\n"
4164 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4168 "This library is free software; you can redistribute it and/or\n"
4169 "modify it under the terms of the GNU Lesser General Public\n"
4170 "License as published by the Free Software Foundation; either\n"
4171 "version 2 of the License, or (at your option) any later version.\n"
4173 "This library is distributed in the hope that it will be useful,\n"
4174 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4175 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4176 "Lesser General Public License for more details.\n"
4178 "You should have received a copy of the GNU Lesser General Public\n"
4179 "License along with this library; if not, write to the Free Software\n"
4180 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4186 static void show_help(void)
4189 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4190 "Hyper fast Audio and Video encoder\n");
4192 show_help_options(options, "Main options:\n",
4193 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4194 show_help_options(options, "\nVideo options:\n",
4195 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4197 show_help_options(options, "\nAdvanced Video options:\n",
4198 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4199 OPT_VIDEO | OPT_EXPERT);
4200 show_help_options(options, "\nAudio options:\n",
4201 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4203 show_help_options(options, "\nAdvanced Audio options:\n",
4204 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4205 OPT_AUDIO | OPT_EXPERT);
4206 show_help_options(options, "\nSubtitle options:\n",
4207 OPT_SUBTITLE | OPT_GRAB,
4209 show_help_options(options, "\nAudio/Video grab options:\n",
4212 show_help_options(options, "\nAdvanced options:\n",
4213 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4215 av_opt_show(avctx_opts, NULL);
4216 av_opt_show(avformat_opts, NULL);
4221 void parse_arg_file(const char *filename)
4223 opt_output_file(filename);
4226 int main(int argc, char **argv)
4233 avctx_opts= avcodec_alloc_context();
4234 avformat_opts = av_alloc_format_context();
4242 parse_options(argc, argv, options);
4244 /* file converter / grab */
4245 if (nb_output_files <= 0) {
4246 fprintf(stderr, "Must supply at least one output file\n");
4250 if (nb_input_files == 0) {
4256 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4257 stream_maps, nb_stream_maps);
4258 ti = getutime() - ti;
4260 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4264 for(i=0;i<nb_output_files;i++) {
4265 /* maybe av_close_output_file ??? */
4266 AVFormatContext *s = output_files[i];
4268 if (!(s->oformat->flags & AVFMT_NOFILE))
4270 for(j=0;j<s->nb_streams;j++)
4271 av_free(s->streams[j]);
4274 for(i=0;i<nb_input_files;i++)
4275 av_close_input_file(input_files[i]);
4280 av_free(intra_matrix);
4282 av_free(inter_matrix);
4284 #ifdef POWERPC_PERFORMANCE_REPORT
4285 extern void powerpc_display_perf_report(void);
4286 powerpc_display_perf_report();
4287 #endif /* POWERPC_PERFORMANCE_REPORT */
4290 if (received_sigterm) {
4292 "Received signal %d: terminating.\n",
4293 (int) received_sigterm);
4297 exit(0); /* not all OS-es handle main() return value */