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 genpts = 0;
166 static int qp_hist = 0;
168 static int gop_size = 12;
169 static int intra_only = 0;
170 static int audio_sample_rate = 44100;
171 static int audio_bit_rate = 64000;
172 #define QSCALE_NONE -99999
173 static float audio_qscale = QSCALE_NONE;
174 static int audio_disable = 0;
175 static int audio_channels = 1;
176 static int audio_codec_id = CODEC_ID_NONE;
177 static int audio_codec_tag = 0;
178 static char *audio_language = NULL;
180 static int subtitle_codec_id = CODEC_ID_NONE;
181 static char *subtitle_language = NULL;
183 static int mux_rate= 0;
184 static int mux_packet_size= 0;
185 static float mux_preload= 0.5;
186 static float mux_max_delay= 0.7;
188 static int64_t recording_time = 0;
189 static int64_t start_time = 0;
190 static int64_t rec_timestamp = 0;
191 static int64_t input_ts_offset = 0;
192 static int file_overwrite = 0;
193 static char *str_title = NULL;
194 static char *str_author = NULL;
195 static char *str_copyright = NULL;
196 static char *str_comment = 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;
2820 ic->flags|= AVFMT_FLAG_GENPTS;
2822 /* If not enough info to get the stream parameters, we decode the
2823 first frames to get it. (used in mpeg case for example) */
2824 ret = av_find_stream_info(ic);
2825 if (ret < 0 && verbose >= 0) {
2826 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2830 timestamp = start_time;
2831 /* add the stream start time */
2832 if (ic->start_time != AV_NOPTS_VALUE)
2833 timestamp += ic->start_time;
2835 /* if seeking requested, we execute it */
2836 if (start_time != 0) {
2837 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2839 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2840 filename, (double)timestamp / AV_TIME_BASE);
2842 /* reset seek info */
2846 /* update the current parameters so that they match the one of the input stream */
2847 for(i=0;i<ic->nb_streams;i++) {
2849 AVCodecContext *enc = ic->streams[i]->codec;
2850 #if defined(HAVE_THREADS)
2852 avcodec_thread_init(enc, thread_count);
2854 enc->thread_count= thread_count;
2855 switch(enc->codec_type) {
2856 case CODEC_TYPE_AUDIO:
2857 for(j=0; j<opt_name_count; j++){
2859 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2860 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2861 av_set_double(enc, opt_names[j], d);
2863 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2864 audio_channels = enc->channels;
2865 audio_sample_rate = enc->sample_rate;
2867 ic->streams[i]->discard= AVDISCARD_ALL;
2869 case CODEC_TYPE_VIDEO:
2870 for(j=0; j<opt_name_count; j++){
2872 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2873 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2874 av_set_double(enc, opt_names[j], d);
2876 frame_height = enc->height;
2877 frame_width = enc->width;
2878 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2879 frame_pix_fmt = enc->pix_fmt;
2880 rfps = ic->streams[i]->r_frame_rate.num;
2881 rfps_base = ic->streams[i]->r_frame_rate.den;
2882 enc->workaround_bugs = workaround_bugs;
2883 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2885 enc->debug |= FF_DEBUG_MV;
2887 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2890 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2891 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2893 (float)rfps / rfps_base, rfps, rfps_base);
2895 /* update the current frame rate to match the stream frame rate */
2897 frame_rate_base = rfps_base;
2899 enc->rate_emu = rate_emu;
2901 ic->streams[i]->discard= AVDISCARD_ALL;
2902 else if(video_discard)
2903 ic->streams[i]->discard= video_discard;
2905 case CODEC_TYPE_DATA:
2907 case CODEC_TYPE_SUBTITLE:
2909 case CODEC_TYPE_UNKNOWN:
2916 input_files[nb_input_files] = ic;
2917 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2918 /* dump the file content */
2920 dump_format(ic, nb_input_files, filename, 0);
2923 file_iformat = NULL;
2924 file_oformat = NULL;
2925 image_format = NULL;
2933 static void opt_grab(const char *arg)
2935 file_iformat = av_find_input_format(arg);
2939 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2941 int has_video, has_audio, i, j;
2942 AVFormatContext *ic;
2946 for(j=0;j<nb_input_files;j++) {
2947 ic = input_files[j];
2948 for(i=0;i<ic->nb_streams;i++) {
2949 AVCodecContext *enc = ic->streams[i]->codec;
2950 switch(enc->codec_type) {
2951 case CODEC_TYPE_AUDIO:
2954 case CODEC_TYPE_VIDEO:
2957 case CODEC_TYPE_DATA:
2958 case CODEC_TYPE_UNKNOWN:
2959 case CODEC_TYPE_SUBTITLE:
2966 *has_video_ptr = has_video;
2967 *has_audio_ptr = has_audio;
2970 static void new_video_stream(AVFormatContext *oc)
2973 AVCodecContext *video_enc;
2976 st = av_new_stream(oc, oc->nb_streams);
2978 fprintf(stderr, "Could not alloc stream\n");
2981 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2982 video_bitstream_filters= NULL;
2984 #if defined(HAVE_THREADS)
2986 avcodec_thread_init(st->codec, thread_count);
2989 video_enc = st->codec;
2992 video_enc->codec_tag= video_codec_tag;
2994 if( (video_global_header&1)
2995 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2996 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2997 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2999 if(video_global_header&2){
3000 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3001 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3004 if (video_stream_copy) {
3005 st->stream_copy = 1;
3006 video_enc->codec_type = CODEC_TYPE_VIDEO;
3012 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3013 if (video_codec_id != CODEC_ID_NONE)
3014 codec_id = video_codec_id;
3016 video_enc->codec_id = codec_id;
3017 codec = avcodec_find_encoder(codec_id);
3019 for(i=0; i<opt_name_count; i++){
3021 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3022 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3023 av_set_double(video_enc, opt_names[i], d);
3026 video_enc->bit_rate = video_bit_rate;
3027 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3028 video_enc->time_base.den = frame_rate;
3029 video_enc->time_base.num = frame_rate_base;
3030 if(codec && codec->supported_framerates){
3031 const AVRational *p= codec->supported_framerates;
3032 AVRational req= (AVRational){frame_rate, frame_rate_base};
3033 const AVRational *best=NULL;
3034 AVRational best_error= (AVRational){INT_MAX, 1};
3035 for(; p->den!=0; p++){
3036 AVRational error= av_sub_q(req, *p);
3037 if(error.num <0) error.num *= -1;
3038 if(av_cmp_q(error, best_error) < 0){
3043 video_enc->time_base.den= best->num;
3044 video_enc->time_base.num= best->den;
3047 video_enc->width = frame_width + frame_padright + frame_padleft;
3048 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3049 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3050 video_enc->pix_fmt = frame_pix_fmt;
3052 if(codec && codec->pix_fmts){
3053 const enum PixelFormat *p= codec->pix_fmts;
3055 if(*p == video_enc->pix_fmt)
3059 video_enc->pix_fmt = codec->pix_fmts[0];
3063 video_enc->gop_size = gop_size;
3065 video_enc->gop_size = 0;
3066 if (video_qscale || same_quality) {
3067 video_enc->flags |= CODEC_FLAG_QSCALE;
3068 video_enc->global_quality=
3069 st->quality = FF_QP2LAMBDA * video_qscale;
3073 video_enc->intra_matrix = intra_matrix;
3075 video_enc->inter_matrix = inter_matrix;
3077 video_enc->pre_me = pre_me;
3080 video_enc->max_b_frames = b_frames;
3081 video_enc->b_quant_factor = 2.0;
3083 video_enc->qmin = video_qmin;
3084 video_enc->qmax = video_qmax;
3085 video_enc->lmin = video_lmin;
3086 video_enc->lmax = video_lmax;
3087 video_enc->rc_qsquish = video_qsquish;
3088 video_enc->mb_lmin = video_mb_lmin;
3089 video_enc->mb_lmax = video_mb_lmax;
3090 video_enc->max_qdiff = video_qdiff;
3091 video_enc->qblur = video_qblur;
3092 video_enc->qcompress = video_qcomp;
3093 video_enc->rc_eq = video_rc_eq;
3094 video_enc->workaround_bugs = workaround_bugs;
3095 video_enc->thread_count = thread_count;
3096 p= video_rc_override_string;
3099 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3101 fprintf(stderr, "error parsing rc_override\n");
3104 video_enc->rc_override=
3105 av_realloc(video_enc->rc_override,
3106 sizeof(RcOverride)*(i+1));
3107 video_enc->rc_override[i].start_frame= start;
3108 video_enc->rc_override[i].end_frame = end;
3110 video_enc->rc_override[i].qscale= q;
3111 video_enc->rc_override[i].quality_factor= 1.0;
3114 video_enc->rc_override[i].qscale= 0;
3115 video_enc->rc_override[i].quality_factor= -q/100.0;
3120 video_enc->rc_override_count=i;
3122 video_enc->rc_max_rate = video_rc_max_rate;
3123 video_enc->rc_min_rate = video_rc_min_rate;
3124 video_enc->rc_buffer_size = video_rc_buffer_size;
3125 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3126 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3127 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3128 video_enc->i_quant_factor = video_i_qfactor;
3129 video_enc->b_quant_factor = video_b_qfactor;
3130 video_enc->i_quant_offset = video_i_qoffset;
3131 video_enc->b_quant_offset = video_b_qoffset;
3132 video_enc->intra_quant_bias = video_intra_quant_bias;
3133 video_enc->inter_quant_bias = video_inter_quant_bias;
3134 video_enc->me_threshold= me_threshold;
3135 video_enc->mb_threshold= mb_threshold;
3136 video_enc->intra_dc_precision= intra_dc_precision - 8;
3137 video_enc->strict_std_compliance = strict;
3138 video_enc->error_rate = error_rate;
3139 video_enc->scenechange_threshold= sc_threshold;
3140 video_enc->me_range = me_range;
3141 video_enc->me_penalty_compensation= me_penalty_compensation;
3142 video_enc->frame_skip_threshold= frame_skip_threshold;
3143 video_enc->frame_skip_factor= frame_skip_factor;
3144 video_enc->frame_skip_exp= frame_skip_exp;
3147 video_enc->rtp_mode= 1;
3148 video_enc->rtp_payload_size= packet_size;
3152 video_enc->flags|= CODEC_FLAG_PSNR;
3154 video_enc->me_method = me_method;
3159 video_enc->flags |= CODEC_FLAG_PASS1;
3161 video_enc->flags |= CODEC_FLAG_PASS2;
3166 /* reset some key parameters */
3168 video_codec_id = CODEC_ID_NONE;
3169 video_stream_copy = 0;
3172 static void new_audio_stream(AVFormatContext *oc)
3175 AVCodecContext *audio_enc;
3178 st = av_new_stream(oc, oc->nb_streams);
3180 fprintf(stderr, "Could not alloc stream\n");
3184 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3185 audio_bitstream_filters= NULL;
3187 #if defined(HAVE_THREADS)
3189 avcodec_thread_init(st->codec, thread_count);
3192 audio_enc = st->codec;
3193 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3196 audio_enc->codec_tag= audio_codec_tag;
3198 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3199 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3200 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3202 if (audio_stream_copy) {
3203 st->stream_copy = 1;
3204 audio_enc->channels = audio_channels;
3206 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3208 for(i=0; i<opt_name_count; i++){
3210 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3211 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3212 av_set_double(audio_enc, opt_names[i], d);
3215 if (audio_codec_id != CODEC_ID_NONE)
3216 codec_id = audio_codec_id;
3217 audio_enc->codec_id = codec_id;
3219 audio_enc->bit_rate = audio_bit_rate;
3220 if (audio_qscale > QSCALE_NONE) {
3221 audio_enc->flags |= CODEC_FLAG_QSCALE;
3222 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3224 audio_enc->strict_std_compliance = strict;
3225 audio_enc->thread_count = thread_count;
3226 /* For audio codecs other than AC3 or DTS we limit */
3227 /* the number of coded channels to stereo */
3228 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3229 && codec_id != CODEC_ID_DTS) {
3230 audio_enc->channels = 2;
3232 audio_enc->channels = audio_channels;
3234 audio_enc->sample_rate = audio_sample_rate;
3235 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3236 if (audio_language) {
3237 pstrcpy(st->language, sizeof(st->language), audio_language);
3238 av_free(audio_language);
3239 audio_language = NULL;
3242 /* reset some key parameters */
3244 audio_codec_id = CODEC_ID_NONE;
3245 audio_stream_copy = 0;
3248 static void opt_new_subtitle_stream(void)
3250 AVFormatContext *oc;
3252 AVCodecContext *subtitle_enc;
3255 if (nb_output_files <= 0) {
3256 fprintf(stderr, "At least one output file must be specified\n");
3259 oc = output_files[nb_output_files - 1];
3261 st = av_new_stream(oc, oc->nb_streams);
3263 fprintf(stderr, "Could not alloc stream\n");
3267 subtitle_enc = st->codec;
3268 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3269 if (subtitle_stream_copy) {
3270 st->stream_copy = 1;
3272 for(i=0; i<opt_name_count; i++){
3274 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3275 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3276 av_set_double(subtitle_enc, opt_names[i], d);
3278 subtitle_enc->codec_id = subtitle_codec_id;
3281 if (subtitle_language) {
3282 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3283 av_free(subtitle_language);
3284 subtitle_language = NULL;
3287 subtitle_codec_id = CODEC_ID_NONE;
3288 subtitle_stream_copy = 0;
3291 static void opt_new_audio_stream(void)
3293 AVFormatContext *oc;
3294 if (nb_output_files <= 0) {
3295 fprintf(stderr, "At least one output file must be specified\n");
3298 oc = output_files[nb_output_files - 1];
3299 new_audio_stream(oc);
3302 static void opt_new_video_stream(void)
3304 AVFormatContext *oc;
3305 if (nb_output_files <= 0) {
3306 fprintf(stderr, "At least one output file must be specified\n");
3309 oc = output_files[nb_output_files - 1];
3310 new_video_stream(oc);
3313 static void opt_output_file(const char *filename)
3315 AVFormatContext *oc;
3316 int use_video, use_audio, input_has_video, input_has_audio;
3317 AVFormatParameters params, *ap = ¶ms;
3319 if (!strcmp(filename, "-"))
3322 oc = av_alloc_format_context();
3324 if (!file_oformat) {
3325 file_oformat = guess_format(NULL, filename, NULL);
3326 if (!file_oformat) {
3327 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3333 oc->oformat = file_oformat;
3334 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3336 if (!strcmp(file_oformat->name, "ffm") &&
3337 strstart(filename, "http:", NULL)) {
3338 /* special case for files sent to ffserver: we get the stream
3339 parameters from ffserver */
3340 if (read_ffserver_streams(oc, filename) < 0) {
3341 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3345 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3346 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3348 /* disable if no corresponding type found and at least one
3350 if (nb_input_files > 0) {
3351 check_audio_video_inputs(&input_has_video, &input_has_audio);
3352 if (!input_has_video)
3354 if (!input_has_audio)
3358 /* manual disable */
3359 if (audio_disable) {
3362 if (video_disable) {
3367 new_video_stream(oc);
3371 new_audio_stream(oc);
3374 if (!oc->nb_streams) {
3375 fprintf(stderr, "No audio or video streams available\n");
3379 oc->timestamp = rec_timestamp;
3382 pstrcpy(oc->title, sizeof(oc->title), str_title);
3384 pstrcpy(oc->author, sizeof(oc->author), str_author);
3386 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3388 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3391 output_files[nb_output_files++] = oc;
3393 /* check filename in case of an image number is expected */
3394 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3395 if (filename_number_test(oc->filename) < 0) {
3396 print_error(oc->filename, AVERROR_NUMEXPECTED);
3401 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3402 /* test if it already exists to avoid loosing precious files */
3403 if (!file_overwrite &&
3404 (strchr(filename, ':') == NULL ||
3405 strstart(filename, "file:", NULL))) {
3406 if (url_exist(filename)) {
3409 if ( !using_stdin ) {
3410 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3413 if (toupper(c) != 'Y') {
3414 fprintf(stderr, "Not overwriting - exiting\n");
3419 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3426 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3427 fprintf(stderr, "Could not open '%s'\n", filename);
3432 memset(ap, 0, sizeof(*ap));
3433 ap->image_format = image_format;
3434 if (av_set_parameters(oc, ap) < 0) {
3435 fprintf(stderr, "%s: Invalid encoding parameters\n",
3440 oc->packet_size= mux_packet_size;
3441 oc->mux_rate= mux_rate;
3442 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3443 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3444 oc->loop_output = loop_output;
3446 /* reset some options */
3447 file_oformat = NULL;
3448 file_iformat = NULL;
3449 image_format = NULL;
3452 /* prepare dummy protocols for grab */
3453 static void prepare_grab(void)
3455 int has_video, has_audio, i, j;
3456 AVFormatContext *oc;
3457 AVFormatContext *ic;
3458 AVFormatParameters vp1, *vp = &vp1;
3459 AVFormatParameters ap1, *ap = &ap1;
3461 /* see if audio/video inputs are needed */
3464 memset(ap, 0, sizeof(*ap));
3465 memset(vp, 0, sizeof(*vp));
3466 vp->time_base.num= 1;
3467 for(j=0;j<nb_output_files;j++) {
3468 oc = output_files[j];
3469 for(i=0;i<oc->nb_streams;i++) {
3470 AVCodecContext *enc = oc->streams[i]->codec;
3471 switch(enc->codec_type) {
3472 case CODEC_TYPE_AUDIO:
3473 if (enc->sample_rate > ap->sample_rate)
3474 ap->sample_rate = enc->sample_rate;
3475 if (enc->channels > ap->channels)
3476 ap->channels = enc->channels;
3479 case CODEC_TYPE_VIDEO:
3480 if (enc->width > vp->width)
3481 vp->width = enc->width;
3482 if (enc->height > vp->height)
3483 vp->height = enc->height;
3485 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3486 vp->time_base = enc->time_base;
3487 vp->width += frame_leftBand + frame_rightBand;
3488 vp->width -= (frame_padleft + frame_padright);
3489 vp->height += frame_topBand + frame_bottomBand;
3490 vp->height -= (frame_padtop + frame_padbottom);
3500 if (has_video == 0 && has_audio == 0) {
3501 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3506 AVInputFormat *fmt1;
3507 fmt1 = av_find_input_format(video_grab_format);
3508 vp->device = video_device;
3509 vp->channel = video_channel;
3510 vp->standard = video_standard;
3511 vp->pix_fmt = frame_pix_fmt;
3512 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3513 fprintf(stderr, "Could not find video grab device\n");
3516 /* If not enough info to get the stream parameters, we decode the
3517 first frames to get it. */
3518 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3519 fprintf(stderr, "Could not find video grab parameters\n");
3522 /* by now video grab has one stream */
3523 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3524 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3525 input_files[nb_input_files] = ic;
3528 dump_format(ic, nb_input_files, "", 0);
3532 if (has_audio && audio_grab_format) {
3533 AVInputFormat *fmt1;
3534 fmt1 = av_find_input_format(audio_grab_format);
3535 ap->device = audio_device;
3536 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3537 fprintf(stderr, "Could not find audio grab device\n");
3540 input_files[nb_input_files] = ic;
3543 dump_format(ic, nb_input_files, "", 0);
3549 /* same option as mencoder */
3550 static void opt_pass(const char *pass_str)
3553 pass = atoi(pass_str);
3554 if (pass != 1 && pass != 2) {
3555 fprintf(stderr, "pass number can be only 1 or 2\n");
3561 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3562 static int64_t getutime(void)
3564 return av_gettime();
3567 static int64_t getutime(void)
3569 struct rusage rusage;
3571 getrusage(RUSAGE_SELF, &rusage);
3572 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3576 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3577 extern int ffm_nopts;
3580 static void show_formats(void)
3582 AVInputFormat *ifmt;
3583 AVOutputFormat *ofmt;
3584 AVImageFormat *image_fmt;
3587 const char **pp, *last_name;
3589 printf("File formats:\n");
3594 const char *name=NULL;
3595 const char *long_name=NULL;
3597 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3598 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3599 strcmp(ofmt->name, last_name)>0){
3601 long_name= ofmt->long_name;
3605 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3606 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3607 strcmp(ifmt->name, last_name)>0){
3609 long_name= ifmt->long_name;
3612 if(name && strcmp(ifmt->name, name)==0)
3624 long_name ? long_name:" ");
3628 printf("Image formats (filename extensions, if any, follow):\n");
3629 for(image_fmt = first_image_format; image_fmt != NULL;
3630 image_fmt = image_fmt->next) {
3633 image_fmt->img_read ? "D":" ",
3634 image_fmt->img_write ? "E":" ",
3636 image_fmt->extensions ? image_fmt->extensions:" ");
3640 printf("Codecs:\n");
3646 const char *type_str;
3649 for(p = first_avcodec; p != NULL; p = p->next) {
3650 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3651 strcmp(p->name, last_name)>0){
3653 decode= encode= cap=0;
3655 if(p2 && strcmp(p->name, p2->name)==0){
3656 if(p->decode) decode=1;
3657 if(p->encode) encode=1;
3658 cap |= p->capabilities;
3663 last_name= p2->name;
3666 case CODEC_TYPE_VIDEO:
3669 case CODEC_TYPE_AUDIO:
3672 case CODEC_TYPE_SUBTITLE:
3681 decode ? "D": (/*p2->decoder ? "d":*/" "),
3684 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3685 cap & CODEC_CAP_DR1 ? "D":" ",
3686 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3688 /* if(p2->decoder && decode==0)
3689 printf(" use %s for decoding", p2->decoder->name);*/
3694 printf("Supported file protocols:\n");
3695 for(up = first_protocol; up != NULL; up = up->next)
3696 printf(" %s:", up->name);
3699 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3700 printf("Motion estimation methods:\n");
3704 if ((pp - motion_str + 1) == ME_ZERO)
3705 printf("(fastest)");
3706 else if ((pp - motion_str + 1) == ME_FULL)
3707 printf("(slowest)");
3708 else if ((pp - motion_str + 1) == ME_EPZS)
3709 printf("(default)");
3714 "Note, the names of encoders and decoders dont always match, so there are\n"
3715 "several cases where the above table shows encoder only or decoder only entries\n"
3716 "even though both encoding and decoding are supported for example, the h263\n"
3717 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3722 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3725 const char *p = str;
3732 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3739 static void opt_inter_matrix(const char *arg)
3741 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3742 parse_matrix_coeffs(inter_matrix, arg);
3745 static void opt_intra_matrix(const char *arg)
3747 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3748 parse_matrix_coeffs(intra_matrix, arg);
3751 static void opt_target(const char *arg)
3754 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3756 if(!strncmp(arg, "pal-", 4)) {
3759 } else if(!strncmp(arg, "ntsc-", 5)) {
3762 } else if(!strncmp(arg, "film-", 5)) {
3767 /* Calculate FR via float to avoid int overflow */
3768 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3771 } else if((fr == 29970) || (fr == 23976)) {
3774 /* Try to determine PAL/NTSC by peeking in the input files */
3775 if(nb_input_files) {
3777 for(j = 0; j < nb_input_files; j++) {
3778 for(i = 0; i < input_files[j]->nb_streams; i++) {
3779 AVCodecContext *c = input_files[j]->streams[i]->codec;
3780 if(c->codec_type != CODEC_TYPE_VIDEO)
3782 fr = c->time_base.den * 1000 / c->time_base.num;
3786 } else if((fr == 29970) || (fr == 23976)) {
3796 if(verbose && norm >= 0)
3797 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3801 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3802 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3803 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3807 if(!strcmp(arg, "vcd")) {
3809 opt_video_codec("mpeg1video");
3810 opt_audio_codec("mp2");
3813 opt_frame_size(norm ? "352x240" : "352x288");
3814 opt_frame_rate(frame_rates[norm]);
3815 opt_gop_size(norm ? "18" : "15");
3817 video_bit_rate = 1150000;
3818 video_rc_max_rate = 1150000;
3819 video_rc_min_rate = 1150000;
3820 video_rc_buffer_size = 40*1024*8;
3822 audio_bit_rate = 224000;
3823 audio_sample_rate = 44100;
3825 mux_packet_size= 2324;
3826 mux_rate= 2352 * 75 * 8;
3828 /* We have to offset the PTS, so that it is consistent with the SCR.
3829 SCR starts at 36000, but the first two packs contain only padding
3830 and the first pack from the other stream, respectively, may also have
3831 been written before.
3832 So the real data starts at SCR 36000+3*1200. */
3833 mux_preload= (36000+3*1200) / 90000.0; //0.44
3834 } else if(!strcmp(arg, "svcd")) {
3836 opt_video_codec("mpeg2video");
3837 opt_audio_codec("mp2");
3840 opt_frame_size(norm ? "480x480" : "480x576");
3841 opt_frame_rate(frame_rates[norm]);
3842 opt_gop_size(norm ? "18" : "15");
3844 video_bit_rate = 2040000;
3845 video_rc_max_rate = 2516000;
3846 video_rc_min_rate = 0; //1145000;
3847 video_rc_buffer_size = 224*1024*8;
3848 opt_default("flags", "+SCAN_OFFSET");
3851 audio_bit_rate = 224000;
3852 audio_sample_rate = 44100;
3854 mux_packet_size= 2324;
3856 } else if(!strcmp(arg, "dvd")) {
3858 opt_video_codec("mpeg2video");
3859 opt_audio_codec("ac3");
3862 opt_frame_size(norm ? "720x480" : "720x576");
3863 opt_frame_rate(frame_rates[norm]);
3864 opt_gop_size(norm ? "18" : "15");
3866 video_bit_rate = 6000000;
3867 video_rc_max_rate = 9000000;
3868 video_rc_min_rate = 0; //1500000;
3869 video_rc_buffer_size = 224*1024*8;
3871 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3872 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3874 audio_bit_rate = 448000;
3875 audio_sample_rate = 48000;
3877 } else if(!strncmp(arg, "dv", 2)) {
3881 opt_frame_size(norm ? "720x480" : "720x576");
3882 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3883 (norm ? "yuv411p" : "yuv420p"));
3884 opt_frame_rate(frame_rates[norm]);
3886 audio_sample_rate = 48000;
3890 fprintf(stderr, "Unknown target: %s\n", arg);
3895 static void opt_video_bsf(const char *arg)
3897 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3898 AVBitStreamFilterContext **bsfp;
3901 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3905 bsfp= &video_bitstream_filters;
3907 bsfp= &(*bsfp)->next;
3912 //FIXME avoid audio - video code duplication
3913 static void opt_audio_bsf(const char *arg)
3915 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3916 AVBitStreamFilterContext **bsfp;
3919 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3923 bsfp= &audio_bitstream_filters;
3925 bsfp= &(*bsfp)->next;
3930 static void show_version(void)
3932 /* TODO: add function interface to avutil and avformat */
3933 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3937 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3941 static int opt_default(const char *opt, const char *arg){
3942 AVOption *o= av_set_string(avctx_opts, opt, arg);
3944 o = av_set_string(avformat_opts, opt, arg);
3948 // 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));
3950 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3951 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3952 opt_names[opt_name_count++]= o->name;
3954 #if defined(CONFIG_FFM_DEMUXER) || defined(CONFIG_FFM_MUXER)
3955 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3956 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3960 if(avctx_opts->debug)
3961 av_log_set_level(AV_LOG_DEBUG);
3965 const OptionDef options[] = {
3967 { "L", 0, {(void*)show_license}, "show license" },
3968 { "h", 0, {(void*)show_help}, "show help" },
3969 { "version", 0, {(void*)show_version}, "show version" },
3970 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3971 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3972 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3973 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3974 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3975 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3976 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3977 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3978 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3979 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3980 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3981 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3982 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3983 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3984 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3985 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3986 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3987 "add timings for benchmarking" },
3988 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3989 "dump each input packet" },
3990 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3991 "when dumping packets, also dump the payload" },
3992 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3993 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3994 { "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)", "" },
3995 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3996 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3997 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3998 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3999 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4000 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
4001 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4002 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4003 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
4006 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
4007 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4008 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4009 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
4010 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4011 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4012 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4013 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
4014 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
4015 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4016 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4017 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4018 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4019 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4020 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4021 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4022 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4023 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4024 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4025 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4026 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4027 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4028 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4029 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4030 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4031 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4032 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4033 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4034 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4035 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4036 { "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" },
4037 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4038 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4039 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4040 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4041 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4042 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4043 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4044 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4045 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4046 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4047 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4048 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4049 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4050 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4051 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4052 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4054 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
4055 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
4056 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4057 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4058 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4059 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4060 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4061 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4062 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4063 "use same video quality as source (implies VBR)" },
4064 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4065 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4066 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4067 "deinterlace pictures" },
4068 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4069 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4070 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4071 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4072 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4073 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4074 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4075 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4076 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4077 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4078 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4079 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4080 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4081 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4082 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4083 { "genpts", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&genpts }, "generate pts" },
4084 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4087 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4088 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4089 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4090 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4091 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4092 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4093 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4094 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4095 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4096 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4098 /* subtitle options */
4099 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4100 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4101 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4104 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4105 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4106 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4107 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4109 /* G.2 grab options */
4110 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4111 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4114 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4115 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4116 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4117 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4119 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
4120 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
4122 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4126 static void show_banner(void)
4128 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4129 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
4130 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4131 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4132 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4133 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4135 fprintf(stderr, ", gcc: " __VERSION__ "\n");
4137 fprintf(stderr, ", using a non-gcc compiler\n");
4141 static void show_license(void)
4146 "This program is free software; you can redistribute it and/or modify\n"
4147 "it under the terms of the GNU General Public License as published by\n"
4148 "the Free Software Foundation; either version 2 of the License, or\n"
4149 "(at your option) any later version.\n"
4151 "This program is distributed in the hope that it will be useful,\n"
4152 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4153 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4154 "GNU General Public License for more details.\n"
4156 "You should have received a copy of the GNU General Public License\n"
4157 "along with this program; if not, write to the Free Software\n"
4158 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4162 "This library is free software; you can redistribute it and/or\n"
4163 "modify it under the terms of the GNU Lesser General Public\n"
4164 "License as published by the Free Software Foundation; either\n"
4165 "version 2 of the License, or (at your option) any later version.\n"
4167 "This library is distributed in the hope that it will be useful,\n"
4168 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4169 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU\n"
4170 "Lesser General Public License for more details.\n"
4172 "You should have received a copy of the GNU Lesser General Public\n"
4173 "License along with this library; if not, write to the Free Software\n"
4174 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4180 static void show_help(void)
4183 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4184 "Hyper fast Audio and Video encoder\n");
4186 show_help_options(options, "Main options:\n",
4187 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4188 show_help_options(options, "\nVideo options:\n",
4189 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4191 show_help_options(options, "\nAdvanced Video options:\n",
4192 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4193 OPT_VIDEO | OPT_EXPERT);
4194 show_help_options(options, "\nAudio options:\n",
4195 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4197 show_help_options(options, "\nAdvanced Audio options:\n",
4198 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4199 OPT_AUDIO | OPT_EXPERT);
4200 show_help_options(options, "\nSubtitle options:\n",
4201 OPT_SUBTITLE | OPT_GRAB,
4203 show_help_options(options, "\nAudio/Video grab options:\n",
4206 show_help_options(options, "\nAdvanced options:\n",
4207 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4209 av_opt_show(avctx_opts, NULL);
4210 av_opt_show(avformat_opts, NULL);
4215 void parse_arg_file(const char *filename)
4217 opt_output_file(filename);
4220 int main(int argc, char **argv)
4227 avctx_opts= avcodec_alloc_context();
4228 avformat_opts = av_alloc_format_context();
4236 parse_options(argc, argv, options);
4238 /* file converter / grab */
4239 if (nb_output_files <= 0) {
4240 fprintf(stderr, "Must supply at least one output file\n");
4244 if (nb_input_files == 0) {
4250 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4251 stream_maps, nb_stream_maps);
4252 ti = getutime() - ti;
4254 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4258 for(i=0;i<nb_output_files;i++) {
4259 /* maybe av_close_output_file ??? */
4260 AVFormatContext *s = output_files[i];
4262 if (!(s->oformat->flags & AVFMT_NOFILE))
4264 for(j=0;j<s->nb_streams;j++)
4265 av_free(s->streams[j]);
4268 for(i=0;i<nb_input_files;i++)
4269 av_close_input_file(input_files[i]);
4274 av_free(intra_matrix);
4276 av_free(inter_matrix);
4278 #ifdef POWERPC_PERFORMANCE_REPORT
4279 extern void powerpc_display_perf_report(void);
4280 powerpc_display_perf_report();
4281 #endif /* POWERPC_PERFORMANCE_REPORT */
4284 if (received_sigterm) {
4286 "Received signal %d: terminating.\n",
4287 (int) received_sigterm);
4291 exit(0); /* not all OS-es handle main() return value */