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;
256 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
257 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
258 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
260 #define DEFAULT_PASS_LOGFILENAME "ffmpeg2pass"
262 struct AVInputStream;
264 typedef struct AVOutputStream {
265 int file_index; /* file index */
266 int index; /* stream index in the output file */
267 int source_index; /* AVInputStream index */
268 AVStream *st; /* stream in the output file */
269 int encoding_needed; /* true if encoding needed for this stream */
271 /* input pts and corresponding output pts
273 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
274 struct AVInputStream *sync_ist; /* input stream to sync against */
275 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
278 AVFrame pict_tmp; /* temporary image for resampling */
279 struct SwsContext *img_resample_ctx; /* for image resampling */
283 int topBand; /* cropping area sizes */
287 int padtop; /* padding area sizes */
294 ReSampleContext *resample; /* for audio resampling */
295 FifoBuffer fifo; /* for compression: one audio fifo per codec */
299 typedef struct AVInputStream {
303 int discard; /* true if stream data should be discarded */
304 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
305 int64_t sample_index; /* current sample */
307 int64_t start; /* time when read started */
308 unsigned long frame; /* current frame */
309 int64_t next_pts; /* synthetic pts for cases where pkt.pts
311 int64_t pts; /* current pts */
312 int is_start; /* is 1 at the start and after a discontinuity */
315 typedef struct AVInputFile {
316 int eof_reached; /* true if eof reached */
317 int ist_index; /* index of first stream in ist_table */
318 int buffer_size; /* current total buffer size */
319 int buffer_size_max; /* buffer size at which we consider we can stop
321 int nb_streams; /* nb streams we are aware of */
326 /* init terminal so that we can grab keys */
327 static struct termios oldtty;
329 static void term_exit(void)
331 tcsetattr (0, TCSANOW, &oldtty);
334 static volatile sig_atomic_t received_sigterm = 0;
337 sigterm_handler(int sig)
339 received_sigterm = sig;
343 static void term_init(void)
350 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
351 |INLCR|IGNCR|ICRNL|IXON);
352 tty.c_oflag |= OPOST;
353 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
354 tty.c_cflag &= ~(CSIZE|PARENB);
359 tcsetattr (0, TCSANOW, &tty);
361 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
362 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
363 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
365 register a function to be called at normal program termination
368 #ifdef CONFIG_BEOS_NETSERVER
369 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
373 /* read a key without blocking */
374 static int read_key(void)
378 #ifndef CONFIG_BEOS_NETSERVER
386 n = select(1, &rfds, NULL, NULL, &tv);
398 static int decode_interrupt_cb(void)
400 return q_pressed || (q_pressed = read_key() == 'q');
405 static volatile int received_sigterm = 0;
407 /* no interactive support */
408 static void term_exit(void)
412 static void term_init(void)
416 static int read_key(void)
423 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
428 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
431 /* copy stream format */
432 s->nb_streams = ic->nb_streams;
433 for(i=0;i<ic->nb_streams;i++) {
436 // FIXME: a more elegant solution is needed
437 st = av_mallocz(sizeof(AVStream));
438 memcpy(st, ic->streams[i], sizeof(AVStream));
439 st->codec = avcodec_alloc_context();
440 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
444 av_close_input_file(ic);
449 get_sync_ipts(const AVOutputStream *ost)
451 const AVInputStream *ist = ost->sync_ist;
452 return (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/AV_TIME_BASE;
455 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
457 AVPacket new_pkt= *pkt;
458 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
459 &new_pkt.data, &new_pkt.size,
460 pkt->data, pkt->size,
461 pkt->flags & PKT_FLAG_KEY);
464 new_pkt.destruct= av_destruct_packet;
471 av_interleaved_write_frame(s, pkt);
474 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
476 static void do_audio_out(AVFormatContext *s,
479 unsigned char *buf, int size)
482 static uint8_t *audio_buf = NULL;
483 static uint8_t *audio_out = NULL;
484 const int audio_out_size= 4*MAX_AUDIO_PACKET_SIZE;
486 int size_out, frame_bytes, ret;
487 AVCodecContext *enc= ost->st->codec;
489 /* SC: dynamic allocation of buffers */
491 audio_buf = av_malloc(2*MAX_AUDIO_PACKET_SIZE);
493 audio_out = av_malloc(audio_out_size);
494 if (!audio_buf || !audio_out)
495 return; /* Should signal an error ! */
497 if(audio_sync_method){
498 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
499 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2);
500 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
501 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
503 //FIXME resample delay
504 if(fabs(delta) > 50){
507 byte_delta= FFMAX(byte_delta, -size);
511 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
516 static uint8_t *input_tmp= NULL;
517 input_tmp= av_realloc(input_tmp, byte_delta + size);
519 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
522 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
524 memset(input_tmp, 0, byte_delta);
525 memcpy(input_tmp + byte_delta, buf, size);
529 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
531 }else if(audio_sync_method>1){
532 int comp= clip(delta, -audio_sync_method, audio_sync_method);
533 assert(ost->audio_resample);
535 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
536 // 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));
537 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
541 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
542 - fifo_size(&ost->fifo, ost->fifo.rptr)/(ost->st->codec->channels * 2); //FIXME wrong
544 if (ost->audio_resample) {
546 size_out = audio_resample(ost->resample,
547 (short *)buftmp, (short *)buf,
548 size / (ist->st->codec->channels * 2));
549 size_out = size_out * enc->channels * 2;
555 /* now encode as many frames as possible */
556 if (enc->frame_size > 1) {
557 /* output resampled raw samples */
558 fifo_write(&ost->fifo, buftmp, size_out,
561 frame_bytes = enc->frame_size * 2 * enc->channels;
563 while (fifo_read(&ost->fifo, audio_buf, frame_bytes,
564 &ost->fifo.rptr) == 0) {
566 av_init_packet(&pkt);
568 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
571 pkt.stream_index= ost->index;
574 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
575 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
576 pkt.flags |= PKT_FLAG_KEY;
577 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
579 ost->sync_opts += enc->frame_size;
583 av_init_packet(&pkt);
585 ost->sync_opts += size_out / (2 * enc->channels);
587 /* output a pcm frame */
588 /* XXX: change encoding codec API to avoid this ? */
589 switch(enc->codec->id) {
590 case CODEC_ID_PCM_S32LE:
591 case CODEC_ID_PCM_S32BE:
592 case CODEC_ID_PCM_U32LE:
593 case CODEC_ID_PCM_U32BE:
594 size_out = size_out << 1;
596 case CODEC_ID_PCM_S24LE:
597 case CODEC_ID_PCM_S24BE:
598 case CODEC_ID_PCM_U24LE:
599 case CODEC_ID_PCM_U24BE:
600 case CODEC_ID_PCM_S24DAUD:
601 size_out = size_out / 2 * 3;
603 case CODEC_ID_PCM_S16LE:
604 case CODEC_ID_PCM_S16BE:
605 case CODEC_ID_PCM_U16LE:
606 case CODEC_ID_PCM_U16BE:
609 size_out = size_out >> 1;
612 ret = avcodec_encode_audio(enc, audio_out, size_out,
615 pkt.stream_index= ost->index;
618 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
619 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
620 pkt.flags |= PKT_FLAG_KEY;
621 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
625 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
629 AVPicture picture_tmp;
632 dec = ist->st->codec;
634 /* deinterlace : must be done before any resize */
635 if (do_deinterlace || using_vhook) {
638 /* create temporary picture */
639 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
640 buf = av_malloc(size);
644 picture2 = &picture_tmp;
645 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
648 if(avpicture_deinterlace(picture2, picture,
649 dec->pix_fmt, dec->width, dec->height) < 0) {
650 /* if error, do not deinterlace */
656 img_copy(picture2, picture, dec->pix_fmt, dec->width, dec->height);
662 frame_hook_process(picture2, dec->pix_fmt, dec->width, dec->height);
664 if (picture != picture2)
665 *picture = *picture2;
669 /* we begin to correct av delay at this threshold */
670 #define AV_DELAY_MAX 0.100
672 static void do_subtitle_out(AVFormatContext *s,
678 static uint8_t *subtitle_out = NULL;
679 int subtitle_out_max_size = 65536;
680 int subtitle_out_size, nb, i;
684 if (pts == AV_NOPTS_VALUE) {
685 fprintf(stderr, "Subtitle packets must have a pts\n");
689 enc = ost->st->codec;
692 subtitle_out = av_malloc(subtitle_out_max_size);
695 /* Note: DVB subtitle need one packet to draw them and one other
696 packet to clear them */
697 /* XXX: signal it in the codec context ? */
698 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
703 for(i = 0; i < nb; i++) {
704 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
705 subtitle_out_max_size, sub);
707 av_init_packet(&pkt);
708 pkt.stream_index = ost->index;
709 pkt.data = subtitle_out;
710 pkt.size = subtitle_out_size;
711 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);
712 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
713 /* XXX: the pts correction is handled here. Maybe handling
714 it in the codec would be better */
716 pkt.pts += 90 * sub->start_display_time;
718 pkt.pts += 90 * sub->end_display_time;
720 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
724 static int bit_buffer_size= 1024*256;
725 static uint8_t *bit_buffer= NULL;
727 static void do_video_out(AVFormatContext *s,
733 int nb_frames, i, ret;
734 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
735 AVFrame picture_crop_temp, picture_pad_temp;
736 uint8_t *buf = NULL, *buf1 = NULL;
737 AVCodecContext *enc, *dec;
739 avcodec_get_frame_defaults(&picture_crop_temp);
740 avcodec_get_frame_defaults(&picture_pad_temp);
742 enc = ost->st->codec;
743 dec = ist->st->codec;
745 /* by default, we output a single frame */
750 if(video_sync_method){
752 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
753 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
756 else if (vdelta > 1.1)
757 nb_frames = lrintf(vdelta);
758 //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);
762 fprintf(stderr, "*** drop!\n");
763 }else if (nb_frames > 1) {
764 nb_frames_dup += nb_frames;
766 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
769 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
771 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
775 if (ost->video_crop) {
776 if (img_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
777 av_log(NULL, AV_LOG_ERROR, "error cropping picture\n");
780 formatted_picture = &picture_crop_temp;
782 formatted_picture = in_picture;
785 final_picture = formatted_picture;
786 padding_src = formatted_picture;
787 resampling_dst = &ost->pict_tmp;
788 if (ost->video_pad) {
789 final_picture = &ost->pict_tmp;
790 if (ost->video_resample) {
791 if (img_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
792 av_log(NULL, AV_LOG_ERROR, "error padding picture\n");
795 resampling_dst = &picture_pad_temp;
799 if (ost->video_resample) {
801 final_picture = &ost->pict_tmp;
802 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
803 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
806 if (ost->video_pad) {
807 img_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
808 enc->height, enc->width, enc->pix_fmt,
809 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
812 /* duplicates frame if needed */
813 for(i=0;i<nb_frames;i++) {
815 av_init_packet(&pkt);
816 pkt.stream_index= ost->index;
818 if (s->oformat->flags & AVFMT_RAWPICTURE) {
819 /* raw pictures are written as AVPicture structure to
820 avoid any copies. We support temorarily the older
822 AVFrame* old_frame = enc->coded_frame;
823 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
824 pkt.data= (uint8_t *)final_picture;
825 pkt.size= sizeof(AVPicture);
826 if(dec->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
827 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
828 if(dec->coded_frame && dec->coded_frame->key_frame)
829 pkt.flags |= PKT_FLAG_KEY;
831 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
832 enc->coded_frame = old_frame;
836 big_picture= *final_picture;
837 /* better than nothing: use input picture interlaced
839 big_picture.interlaced_frame = in_picture->interlaced_frame;
840 if(avctx_opts->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
841 if(top_field_first == -1)
842 big_picture.top_field_first = in_picture->top_field_first;
844 big_picture.top_field_first = top_field_first;
847 /* handles sameq here. This is not correct because it may
848 not be a global option */
850 big_picture.quality = ist->st->quality;
852 big_picture.quality = ost->st->quality;
854 big_picture.pict_type = 0;
855 // big_picture.pts = AV_NOPTS_VALUE;
856 big_picture.pts= ost->sync_opts;
857 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
858 //av_log(NULL, AV_LOG_DEBUG, "%lld -> encoder\n", ost->sync_opts);
859 ret = avcodec_encode_video(enc,
860 bit_buffer, bit_buffer_size,
862 //enc->frame_number = enc->real_pict_num;
864 pkt.data= bit_buffer;
866 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
867 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
868 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %lld/%lld\n",
869 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
870 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
872 if(enc->coded_frame && enc->coded_frame->key_frame)
873 pkt.flags |= PKT_FLAG_KEY;
874 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
876 //fprintf(stderr,"\nFrame: %3d %3d size: %5d type: %d",
877 // enc->frame_number-1, enc->real_pict_num, ret,
879 /* if two pass, output log */
880 if (ost->logfile && enc->stats_out) {
881 fprintf(ost->logfile, "%s", enc->stats_out);
893 static double psnr(double d){
894 if(d==0) return INFINITY;
895 return -10.0*log(d)/log(10.0);
898 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
901 static FILE *fvstats=NULL;
908 double ti1, bitrate, avg_bitrate;
912 today = localtime(&today2);
913 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour,
916 fvstats = fopen(filename,"w");
924 enc = ost->st->codec;
925 if (enc->codec_type == CODEC_TYPE_VIDEO) {
926 frame_number = ost->frame_number;
927 fprintf(fvstats, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
928 if (enc->flags&CODEC_FLAG_PSNR)
929 fprintf(fvstats, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
931 fprintf(fvstats,"f_size= %6d ", frame_size);
932 /* compute pts value */
933 ti1 = ost->sync_opts * av_q2d(enc->time_base);
937 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
938 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
939 fprintf(fvstats, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
940 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
941 fprintf(fvstats,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
945 static void print_report(AVFormatContext **output_files,
946 AVOutputStream **ost_table, int nb_ostreams,
951 AVFormatContext *oc, *os;
954 int frame_number, vid, i;
955 double bitrate, ti1, pts;
956 static int64_t last_time = -1;
957 static int qp_histogram[52];
959 if (!is_last_report) {
961 /* display the report every 0.5 seconds */
962 cur_time = av_gettime();
963 if (last_time == -1) {
964 last_time = cur_time;
967 if ((cur_time - last_time) < 500000)
969 last_time = cur_time;
973 oc = output_files[0];
975 total_size = url_ftell(&oc->pb);
980 for(i=0;i<nb_ostreams;i++) {
982 os = output_files[ost->file_index];
983 enc = ost->st->codec;
984 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
985 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
986 enc->coded_frame->quality/(float)FF_QP2LAMBDA);
988 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
989 frame_number = ost->frame_number;
990 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d q=%3.1f ",
991 frame_number, enc->coded_frame ? enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
993 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
994 if(qp_hist && enc->coded_frame){
996 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
997 if(qp>=0 && qp<sizeof(qp_histogram)/sizeof(int))
1000 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1002 if (enc->flags&CODEC_FLAG_PSNR){
1004 double error, error_sum=0;
1005 double scale, scale_sum=0;
1006 char type[3]= {'Y','U','V'};
1007 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1010 error= enc->error[j];
1011 scale= enc->width*enc->height*255.0*255.0*frame_number;
1013 error= enc->coded_frame->error[j];
1014 scale= enc->width*enc->height*255.0*255.0;
1019 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1021 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1025 /* compute min output value */
1026 pts = (double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den;
1027 if ((pts < ti1) && (pts > 0))
1033 if (verbose || is_last_report) {
1034 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1036 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1037 "size=%8.0fkB time=%0.1f bitrate=%6.1fkbits/s",
1038 (double)total_size / 1024, ti1, bitrate);
1041 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1042 nb_frames_dup, nb_frames_drop);
1045 fprintf(stderr, "%s \r", buf);
1050 if (is_last_report && verbose >= 0){
1051 int64_t raw= audio_size + video_size + extra_size;
1052 fprintf(stderr, "\n");
1053 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1057 100.0*(total_size - raw)/raw
1062 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1063 static int output_packet(AVInputStream *ist, int ist_index,
1064 AVOutputStream **ost_table, int nb_ostreams,
1065 const AVPacket *pkt)
1067 AVFormatContext *os;
1068 AVOutputStream *ost;
1072 int data_size, got_picture;
1074 void *buffer_to_free;
1075 static unsigned int samples_size= 0;
1076 static short *samples= NULL;
1077 AVSubtitle subtitle, *subtitle_to_free;
1081 ist->pts= ist->next_pts; // needed for last packet if vsync=0
1082 } else if (pkt->dts != AV_NOPTS_VALUE) { //FIXME seems redundant, as libavformat does this too
1083 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1085 // assert(ist->pts == ist->next_pts);
1099 /* decode the packet if needed */
1100 data_buf = NULL; /* fail safe */
1102 subtitle_to_free = NULL;
1103 if (ist->decoding_needed) {
1104 switch(ist->st->codec->codec_type) {
1105 case CODEC_TYPE_AUDIO:{
1107 samples= av_fast_realloc(samples, &samples_size, FFMAX(pkt->size, AVCODEC_MAX_AUDIO_FRAME_SIZE));
1108 /* XXX: could avoid copy if PCM 16 bits with same
1109 endianness as CPU */
1110 ret = avcodec_decode_audio(ist->st->codec, samples, &data_size,
1116 /* Some bug in mpeg audio decoder gives */
1117 /* data_size < 0, it seems they are overflows */
1118 if (data_size <= 0) {
1119 /* no audio frame */
1122 data_buf = (uint8_t *)samples;
1123 ist->next_pts += ((int64_t)AV_TIME_BASE/2 * data_size) /
1124 (ist->st->codec->sample_rate * ist->st->codec->channels);
1126 case CODEC_TYPE_VIDEO:
1127 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1128 /* XXX: allocate picture correctly */
1129 avcodec_get_frame_defaults(&picture);
1131 ret = avcodec_decode_video(ist->st->codec,
1132 &picture, &got_picture, ptr, len);
1133 ist->st->quality= picture.quality;
1137 /* no picture yet */
1138 goto discard_packet;
1140 if (ist->st->codec->time_base.num != 0) {
1141 ist->next_pts += ((int64_t)AV_TIME_BASE *
1142 ist->st->codec->time_base.num) /
1143 ist->st->codec->time_base.den;
1147 case CODEC_TYPE_SUBTITLE:
1148 ret = avcodec_decode_subtitle(ist->st->codec,
1149 &subtitle, &got_subtitle, ptr, len);
1152 if (!got_subtitle) {
1153 goto discard_packet;
1155 subtitle_to_free = &subtitle;
1162 switch(ist->st->codec->codec_type) {
1163 case CODEC_TYPE_AUDIO:
1164 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1165 (ist->st->codec->sample_rate * ist->st->codec->channels);
1167 case CODEC_TYPE_VIDEO:
1168 if (ist->st->codec->time_base.num != 0) {
1169 ist->next_pts += ((int64_t)AV_TIME_BASE *
1170 ist->st->codec->time_base.num) /
1171 ist->st->codec->time_base.den;
1181 buffer_to_free = NULL;
1182 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1183 pre_process_video_frame(ist, (AVPicture *)&picture,
1187 // preprocess audio (volume)
1188 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1189 if (audio_volume != 256) {
1192 for(i=0;i<(data_size / sizeof(short));i++) {
1193 int v = ((*volp) * audio_volume + 128) >> 8;
1194 if (v < -32768) v = -32768;
1195 if (v > 32767) v = 32767;
1201 /* frame rate emulation */
1202 if (ist->st->codec->rate_emu) {
1203 int64_t pts = av_rescale((int64_t) ist->frame * ist->st->codec->time_base.num, 1000000, ist->st->codec->time_base.den);
1204 int64_t now = av_gettime() - ist->start;
1212 /* mpeg PTS deordering : if it is a P or I frame, the PTS
1213 is the one of the next displayed one */
1214 /* XXX: add mpeg4 too ? */
1215 if (ist->st->codec->codec_id == CODEC_ID_MPEG1VIDEO) {
1216 if (ist->st->codec->pict_type != B_TYPE) {
1218 tmp = ist->last_ip_pts;
1219 ist->last_ip_pts = ist->frac_pts.val;
1220 ist->frac_pts.val = tmp;
1224 /* if output time reached then transcode raw format,
1225 encode packets and output them */
1226 if (start_time == 0 || ist->pts >= start_time)
1227 for(i=0;i<nb_ostreams;i++) {
1231 if (ost->source_index == ist_index) {
1232 os = output_files[ost->file_index];
1235 printf("%d: got pts=%0.3f %0.3f\n", i,
1236 (double)pkt->pts / AV_TIME_BASE,
1237 ((double)ist->pts / AV_TIME_BASE) -
1238 ((double)ost->st->pts.val * ost->st->time_base.num / ost->st->time_base.den));
1240 /* set the input output pts pairs */
1241 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1243 if (ost->encoding_needed) {
1244 switch(ost->st->codec->codec_type) {
1245 case CODEC_TYPE_AUDIO:
1246 do_audio_out(os, ost, ist, data_buf, data_size);
1248 case CODEC_TYPE_VIDEO:
1249 do_video_out(os, ost, ist, &picture, &frame_size);
1250 video_size += frame_size;
1251 if (do_vstats && frame_size)
1252 do_video_stats(os, ost, frame_size);
1254 case CODEC_TYPE_SUBTITLE:
1255 do_subtitle_out(os, ost, ist, &subtitle,
1262 AVFrame avframe; //FIXME/XXX remove this
1264 av_init_packet(&opkt);
1266 /* no reencoding needed : output the packet directly */
1267 /* force the input stream PTS */
1269 avcodec_get_frame_defaults(&avframe);
1270 ost->st->codec->coded_frame= &avframe;
1271 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1273 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1274 audio_size += data_size;
1275 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1276 video_size += data_size;
1280 opkt.stream_index= ost->index;
1281 if(pkt->pts != AV_NOPTS_VALUE)
1282 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);
1284 opkt.pts= AV_NOPTS_VALUE;
1288 if (pkt->dts == AV_NOPTS_VALUE)
1289 dts = ist->next_pts;
1291 dts= av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1292 opkt.dts= av_rescale_q(dts + input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ost->st->time_base);
1294 opkt.flags= pkt->flags;
1296 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1297 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1298 opkt.destruct= av_destruct_packet;
1300 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][pkt->stream_index]);
1301 ost->st->codec->frame_number++;
1302 ost->frame_number++;
1303 av_free_packet(&opkt);
1307 av_free(buffer_to_free);
1308 /* XXX: allocate the subtitles in the codec ? */
1309 if (subtitle_to_free) {
1310 if (subtitle_to_free->rects != NULL) {
1311 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1312 av_free(subtitle_to_free->rects[i].bitmap);
1313 av_free(subtitle_to_free->rects[i].rgba_palette);
1315 av_freep(&subtitle_to_free->rects);
1317 subtitle_to_free->num_rects = 0;
1318 subtitle_to_free = NULL;
1325 for(i=0;i<nb_ostreams;i++) {
1327 if (ost->source_index == ist_index) {
1328 AVCodecContext *enc= ost->st->codec;
1329 os = output_files[ost->file_index];
1331 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1333 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1336 if (ost->encoding_needed) {
1340 av_init_packet(&pkt);
1341 pkt.stream_index= ost->index;
1343 switch(ost->st->codec->codec_type) {
1344 case CODEC_TYPE_AUDIO:
1345 fifo_bytes = fifo_size(&ost->fifo, NULL);
1347 /* encode any samples remaining in fifo */
1348 if(fifo_bytes > 0 && enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1349 int fs_tmp = enc->frame_size;
1350 enc->frame_size = fifo_bytes / (2 * enc->channels);
1351 if(fifo_read(&ost->fifo, (uint8_t *)samples, fifo_bytes,
1352 &ost->fifo.rptr) == 0) {
1353 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1355 enc->frame_size = fs_tmp;
1358 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1361 pkt.flags |= PKT_FLAG_KEY;
1363 case CODEC_TYPE_VIDEO:
1364 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1366 if(enc->coded_frame && enc->coded_frame->key_frame)
1367 pkt.flags |= PKT_FLAG_KEY;
1368 if (ost->logfile && enc->stats_out) {
1369 fprintf(ost->logfile, "%s", enc->stats_out);
1378 pkt.data= bit_buffer;
1380 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1381 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1382 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1396 * The following code is the main loop of the file converter
1398 static int av_encode(AVFormatContext **output_files,
1399 int nb_output_files,
1400 AVFormatContext **input_files,
1402 AVStreamMap *stream_maps, int nb_stream_maps)
1404 int ret, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1405 AVFormatContext *is, *os;
1406 AVCodecContext *codec, *icodec;
1407 AVOutputStream *ost, **ost_table = NULL;
1408 AVInputStream *ist, **ist_table = NULL;
1409 AVInputFile *file_table;
1410 AVFormatContext *stream_no_data;
1413 file_table= (AVInputFile*) av_mallocz(nb_input_files * sizeof(AVInputFile));
1417 /* input stream init */
1419 for(i=0;i<nb_input_files;i++) {
1420 is = input_files[i];
1421 file_table[i].ist_index = j;
1422 file_table[i].nb_streams = is->nb_streams;
1423 j += is->nb_streams;
1427 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1431 for(i=0;i<nb_istreams;i++) {
1432 ist = av_mallocz(sizeof(AVInputStream));
1438 for(i=0;i<nb_input_files;i++) {
1439 is = input_files[i];
1440 for(k=0;k<is->nb_streams;k++) {
1441 ist = ist_table[j++];
1442 ist->st = is->streams[k];
1443 ist->file_index = i;
1445 ist->discard = 1; /* the stream is discarded by default
1448 if (ist->st->codec->rate_emu) {
1449 ist->start = av_gettime();
1455 /* output stream init */
1457 for(i=0;i<nb_output_files;i++) {
1458 os = output_files[i];
1459 nb_ostreams += os->nb_streams;
1461 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1462 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1466 /* Sanity check the mapping args -- do the input files & streams exist? */
1467 for(i=0;i<nb_stream_maps;i++) {
1468 int fi = stream_maps[i].file_index;
1469 int si = stream_maps[i].stream_index;
1471 if (fi < 0 || fi > nb_input_files - 1 ||
1472 si < 0 || si > file_table[fi].nb_streams - 1) {
1473 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1476 fi = stream_maps[i].sync_file_index;
1477 si = stream_maps[i].sync_stream_index;
1478 if (fi < 0 || fi > nb_input_files - 1 ||
1479 si < 0 || si > file_table[fi].nb_streams - 1) {
1480 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1485 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1488 for(i=0;i<nb_ostreams;i++) {
1489 ost = av_mallocz(sizeof(AVOutputStream));
1496 for(k=0;k<nb_output_files;k++) {
1497 os = output_files[k];
1498 for(i=0;i<os->nb_streams;i++) {
1500 ost = ost_table[n++];
1501 ost->file_index = k;
1503 ost->st = os->streams[i];
1504 if (nb_stream_maps > 0) {
1505 ost->source_index = file_table[stream_maps[n-1].file_index].ist_index +
1506 stream_maps[n-1].stream_index;
1508 /* Sanity check that the stream types match */
1509 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1510 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1511 stream_maps[n-1].file_index, stream_maps[n-1].stream_index,
1512 ost->file_index, ost->index);
1517 /* get corresponding input stream index : we select the first one with the right type */
1519 for(j=0;j<nb_istreams;j++) {
1522 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1523 ost->source_index = j;
1530 /* try again and reuse existing stream */
1531 for(j=0;j<nb_istreams;j++) {
1533 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1534 ost->source_index = j;
1539 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1540 ost->file_index, ost->index);
1545 ist = ist_table[ost->source_index];
1547 ost->sync_ist = (nb_stream_maps > 0) ?
1548 ist_table[file_table[stream_maps[n-1].sync_file_index].ist_index +
1549 stream_maps[n-1].sync_stream_index] : ist;
1553 /* for each output stream, we compute the right encoding parameters */
1554 for(i=0;i<nb_ostreams;i++) {
1556 ist = ist_table[ost->source_index];
1558 codec = ost->st->codec;
1559 icodec = ist->st->codec;
1561 if (ost->st->stream_copy) {
1562 /* if stream_copy is selected, no need to decode or encode */
1563 codec->codec_id = icodec->codec_id;
1564 codec->codec_type = icodec->codec_type;
1565 if(!codec->codec_tag) codec->codec_tag = icodec->codec_tag;
1566 codec->bit_rate = icodec->bit_rate;
1567 codec->extradata= icodec->extradata;
1568 codec->extradata_size= icodec->extradata_size;
1569 codec->time_base = icodec->time_base;
1570 switch(codec->codec_type) {
1571 case CODEC_TYPE_AUDIO:
1572 codec->sample_rate = icodec->sample_rate;
1573 codec->channels = icodec->channels;
1574 codec->frame_size = icodec->frame_size;
1575 codec->block_align= icodec->block_align;
1577 case CODEC_TYPE_VIDEO:
1578 codec->pix_fmt = icodec->pix_fmt;
1579 codec->width = icodec->width;
1580 codec->height = icodec->height;
1581 codec->has_b_frames = icodec->has_b_frames;
1583 case CODEC_TYPE_SUBTITLE:
1589 switch(codec->codec_type) {
1590 case CODEC_TYPE_AUDIO:
1591 if (fifo_init(&ost->fifo, 2 * MAX_AUDIO_PACKET_SIZE))
1594 if (codec->channels == icodec->channels &&
1595 codec->sample_rate == icodec->sample_rate) {
1596 ost->audio_resample = 0;
1598 if (codec->channels != icodec->channels &&
1599 (icodec->codec_id == CODEC_ID_AC3 ||
1600 icodec->codec_id == CODEC_ID_DTS)) {
1601 /* Special case for 5:1 AC3 and DTS input */
1602 /* and mono or stereo output */
1603 /* Request specific number of channels */
1604 icodec->channels = codec->channels;
1605 if (codec->sample_rate == icodec->sample_rate)
1606 ost->audio_resample = 0;
1608 ost->audio_resample = 1;
1611 ost->audio_resample = 1;
1614 if(audio_sync_method>1)
1615 ost->audio_resample = 1;
1617 if(ost->audio_resample){
1618 ost->resample = audio_resample_init(codec->channels, icodec->channels,
1619 codec->sample_rate, icodec->sample_rate);
1621 printf("Can't resample. Aborting.\n");
1625 ist->decoding_needed = 1;
1626 ost->encoding_needed = 1;
1628 case CODEC_TYPE_VIDEO:
1629 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1630 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1631 ost->video_resample = ((codec->width != icodec->width -
1632 (frame_leftBand + frame_rightBand) +
1633 (frame_padleft + frame_padright)) ||
1634 (codec->height != icodec->height -
1635 (frame_topBand + frame_bottomBand) +
1636 (frame_padtop + frame_padbottom)) ||
1637 (codec->pix_fmt != icodec->pix_fmt));
1638 if (ost->video_crop) {
1639 ost->topBand = frame_topBand;
1640 ost->leftBand = frame_leftBand;
1642 if (ost->video_pad) {
1643 ost->padtop = frame_padtop;
1644 ost->padleft = frame_padleft;
1645 ost->padbottom = frame_padbottom;
1646 ost->padright = frame_padright;
1647 if (!ost->video_resample) {
1648 avcodec_get_frame_defaults(&ost->pict_tmp);
1649 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1650 codec->width, codec->height ) )
1654 if (ost->video_resample) {
1655 avcodec_get_frame_defaults(&ost->pict_tmp);
1656 if( avpicture_alloc( (AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1657 codec->width, codec->height ) )
1660 ost->img_resample_ctx = sws_getContext(
1661 icodec->width - (frame_leftBand + frame_rightBand),
1662 icodec->height - (frame_topBand + frame_bottomBand),
1664 codec->width - (frame_padleft + frame_padright),
1665 codec->height - (frame_padtop + frame_padbottom),
1667 sws_flags, NULL, NULL, NULL);
1668 if (ost->img_resample_ctx == NULL) {
1669 fprintf(stderr, "Cannot get resampling context\n");
1672 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1674 ost->encoding_needed = 1;
1675 ist->decoding_needed = 1;
1677 case CODEC_TYPE_SUBTITLE:
1678 ost->encoding_needed = 1;
1679 ist->decoding_needed = 1;
1686 if (ost->encoding_needed &&
1687 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1688 char logfilename[1024];
1693 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1695 pass_logfilename : DEFAULT_PASS_LOGFILENAME, i);
1696 if (codec->flags & CODEC_FLAG_PASS1) {
1697 f = fopen(logfilename, "w");
1699 perror(logfilename);
1704 /* read the log file */
1705 f = fopen(logfilename, "r");
1707 perror(logfilename);
1710 fseek(f, 0, SEEK_END);
1712 fseek(f, 0, SEEK_SET);
1713 logbuffer = av_malloc(size + 1);
1715 fprintf(stderr, "Could not allocate log buffer\n");
1718 size = fread(logbuffer, 1, size, f);
1720 logbuffer[size] = '\0';
1721 codec->stats_in = logbuffer;
1725 if(codec->codec_type == CODEC_TYPE_VIDEO){
1726 int size= codec->width * codec->height;
1727 bit_buffer_size= FFMAX(bit_buffer_size, 4*size);
1732 bit_buffer = av_malloc(bit_buffer_size);
1736 /* dump the file output parameters - cannot be done before in case
1738 for(i=0;i<nb_output_files;i++) {
1739 dump_format(output_files[i], i, output_files[i]->filename, 1);
1742 /* dump the stream mapping */
1744 fprintf(stderr, "Stream mapping:\n");
1745 for(i=0;i<nb_ostreams;i++) {
1747 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
1748 ist_table[ost->source_index]->file_index,
1749 ist_table[ost->source_index]->index,
1752 if (ost->sync_ist != ist_table[ost->source_index])
1753 fprintf(stderr, " [sync #%d.%d]",
1754 ost->sync_ist->file_index,
1755 ost->sync_ist->index);
1756 fprintf(stderr, "\n");
1760 /* open each encoder */
1761 for(i=0;i<nb_ostreams;i++) {
1763 if (ost->encoding_needed) {
1765 codec = avcodec_find_encoder(ost->st->codec->codec_id);
1767 fprintf(stderr, "Unsupported codec for output stream #%d.%d\n",
1768 ost->file_index, ost->index);
1771 if (avcodec_open(ost->st->codec, codec) < 0) {
1772 fprintf(stderr, "Error while opening codec for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height\n",
1773 ost->file_index, ost->index);
1776 extra_size += ost->st->codec->extradata_size;
1780 /* open each decoder */
1781 for(i=0;i<nb_istreams;i++) {
1783 if (ist->decoding_needed) {
1785 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1787 fprintf(stderr, "Unsupported codec (id=%d) for input stream #%d.%d\n",
1788 ist->st->codec->codec_id, ist->file_index, ist->index);
1791 if (avcodec_open(ist->st->codec, codec) < 0) {
1792 fprintf(stderr, "Error while opening codec for input stream #%d.%d\n",
1793 ist->file_index, ist->index);
1796 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
1797 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
1802 for(i=0;i<nb_istreams;i++) {
1804 is = input_files[ist->file_index];
1806 ist->next_pts = av_rescale_q(ist->st->start_time, ist->st->time_base, AV_TIME_BASE_Q);
1807 if(ist->st->start_time == AV_NOPTS_VALUE)
1809 if(input_files_ts_offset[ist->file_index])
1810 ist->next_pts= AV_NOPTS_VALUE;
1814 /* compute buffer size max (should use a complete heuristic) */
1815 for(i=0;i<nb_input_files;i++) {
1816 file_table[i].buffer_size_max = 2048;
1819 /* set meta data information from input file if required */
1820 for (i=0;i<nb_meta_data_maps;i++) {
1821 AVFormatContext *out_file;
1822 AVFormatContext *in_file;
1824 int out_file_index = meta_data_maps[i].out_file;
1825 int in_file_index = meta_data_maps[i].in_file;
1826 if ( out_file_index < 0 || out_file_index >= nb_output_files ) {
1827 fprintf(stderr, "Invalid output file index %d map_meta_data(%d,%d)\n", out_file_index, out_file_index, in_file_index);
1831 if ( in_file_index < 0 || in_file_index >= nb_input_files ) {
1832 fprintf(stderr, "Invalid input file index %d map_meta_data(%d,%d)\n", in_file_index, out_file_index, in_file_index);
1837 out_file = output_files[out_file_index];
1838 in_file = input_files[in_file_index];
1840 strcpy(out_file->title, in_file->title);
1841 strcpy(out_file->author, in_file->author);
1842 strcpy(out_file->copyright, in_file->copyright);
1843 strcpy(out_file->comment, in_file->comment);
1844 strcpy(out_file->album, in_file->album);
1845 out_file->year = in_file->year;
1846 out_file->track = in_file->track;
1847 strcpy(out_file->genre, in_file->genre);
1850 /* open files and write file headers */
1851 for(i=0;i<nb_output_files;i++) {
1852 os = output_files[i];
1853 if (av_write_header(os) < 0) {
1854 fprintf(stderr, "Could not write header for output file #%d (incorrect codec parameters ?)\n", i);
1861 if ( !using_stdin && verbose >= 0) {
1862 fprintf(stderr, "Press [q] to stop encoding\n");
1863 url_set_interrupt_cb(decode_interrupt_cb);
1871 for(; received_sigterm == 0;) {
1872 int file_index, ist_index;
1880 /* if 'q' pressed, exits */
1884 /* read_key() returns 0 on EOF */
1890 /* select the stream that we must read now by looking at the
1891 smallest output pts */
1893 for(i=0;i<nb_ostreams;i++) {
1896 os = output_files[ost->file_index];
1897 ist = ist_table[ost->source_index];
1898 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
1899 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
1901 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
1902 ipts = (double)ist->pts;
1903 if (!file_table[ist->file_index].eof_reached){
1904 if(ipts < ipts_min) {
1906 if(input_sync ) file_index = ist->file_index;
1908 if(opts < opts_min) {
1910 if(!input_sync) file_index = ist->file_index;
1913 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
1918 /* if none, if is finished */
1919 if (file_index < 0) {
1923 /* finish if recording time exhausted */
1924 if (recording_time > 0 && opts_min >= (recording_time / 1000000.0))
1927 /* finish if limit size exhausted */
1928 if (limit_filesize != 0 && (limit_filesize * 1024) < url_ftell(&output_files[0]->pb))
1931 /* read a frame from it and output it in the fifo */
1932 is = input_files[file_index];
1933 if (av_read_frame(is, &pkt) < 0) {
1934 file_table[file_index].eof_reached = 1;
1935 if (opt_shortest) break; else continue; //
1939 stream_no_data = is;
1944 av_pkt_dump(stdout, &pkt, do_hex_dump);
1946 /* the following test is needed in case new streams appear
1947 dynamically in stream : we ignore them */
1948 if (pkt.stream_index >= file_table[file_index].nb_streams)
1949 goto discard_packet;
1950 ist_index = file_table[file_index].ist_index + pkt.stream_index;
1951 ist = ist_table[ist_index];
1953 goto discard_packet;
1955 // 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);
1956 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE) {
1957 int64_t delta= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q) - ist->next_pts;
1958 if(ABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE && !copy_ts){
1959 input_files_ts_offset[ist->file_index]-= delta;
1961 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
1962 for(i=0; i<file_table[file_index].nb_streams; i++){
1963 int index= file_table[file_index].ist_index + i;
1964 ist_table[index]->next_pts += delta;
1965 ist_table[index]->is_start=1;
1970 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
1971 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
1974 fprintf(stderr, "Error while decoding stream #%d.%d\n",
1975 ist->file_index, ist->index);
1977 av_free_packet(&pkt);
1982 av_free_packet(&pkt);
1984 /* dump report by using the output first video and audio streams */
1985 print_report(output_files, ost_table, nb_ostreams, 0);
1988 /* at the end of stream, we must flush the decoder buffers */
1989 for(i=0;i<nb_istreams;i++) {
1991 if (ist->decoding_needed) {
1992 output_packet(ist, i, ost_table, nb_ostreams, NULL);
1998 /* write the trailer if needed and close file */
1999 for(i=0;i<nb_output_files;i++) {
2000 os = output_files[i];
2001 av_write_trailer(os);
2004 /* dump report by using the first video and audio streams */
2005 print_report(output_files, ost_table, nb_ostreams, 1);
2007 /* close each encoder */
2008 for(i=0;i<nb_ostreams;i++) {
2010 if (ost->encoding_needed) {
2011 av_freep(&ost->st->codec->stats_in);
2012 avcodec_close(ost->st->codec);
2016 /* close each decoder */
2017 for(i=0;i<nb_istreams;i++) {
2019 if (ist->decoding_needed) {
2020 avcodec_close(ist->st->codec);
2028 av_freep(&bit_buffer);
2029 av_free(file_table);
2032 for(i=0;i<nb_istreams;i++) {
2039 for(i=0;i<nb_ostreams;i++) {
2043 fclose(ost->logfile);
2044 ost->logfile = NULL;
2046 fifo_free(&ost->fifo); /* works even if fifo is not
2047 initialized but set to zero */
2048 av_free(ost->pict_tmp.data[0]);
2049 if (ost->video_resample)
2050 sws_freeContext(ost->img_resample_ctx);
2051 if (ost->audio_resample)
2052 audio_resample_close(ost->resample);
2065 int file_read(const char *filename)
2068 unsigned char buffer[1024];
2071 if (url_open(&h, filename, O_RDONLY) < 0) {
2072 printf("could not open '%s'\n", filename);
2076 len = url_read(h, buffer, sizeof(buffer));
2079 for(i=0;i<len;i++) putchar(buffer[i]);
2086 static void opt_image_format(const char *arg)
2090 for(f = first_image_format; f != NULL; f = f->next) {
2091 if (!strcmp(arg, f->name))
2095 fprintf(stderr, "Unknown image format: '%s'\n", arg);
2101 static void opt_format(const char *arg)
2103 /* compatibility stuff for pgmyuv */
2104 if (!strcmp(arg, "pgmyuv")) {
2105 pgmyuv_compatibility_hack=1;
2106 // opt_image_format(arg);
2110 file_iformat = av_find_input_format(arg);
2111 file_oformat = guess_format(arg, NULL, NULL);
2112 if (!file_iformat && !file_oformat) {
2113 fprintf(stderr, "Unknown input or output format: %s\n", arg);
2118 static void opt_video_bitrate(const char *arg)
2120 video_bit_rate = atoi(arg) * 1000;
2123 static void opt_video_bitrate_tolerance(const char *arg)
2125 video_bit_rate_tolerance = atoi(arg) * 1000;
2128 static void opt_video_bitrate_max(const char *arg)
2130 video_rc_max_rate = atoi(arg) * 1000;
2133 static void opt_video_bitrate_min(const char *arg)
2135 video_rc_min_rate = atoi(arg) * 1000;
2138 static void opt_video_buffer_size(const char *arg)
2140 video_rc_buffer_size = atoi(arg) * 8*1024;
2143 static void opt_video_rc_eq(char *arg)
2148 static void opt_video_rc_override_string(char *arg)
2150 video_rc_override_string = arg;
2154 static void opt_workaround_bugs(const char *arg)
2156 workaround_bugs = atoi(arg);
2159 static void opt_me_threshold(const char *arg)
2161 me_threshold = atoi(arg);
2164 static void opt_mb_threshold(const char *arg)
2166 mb_threshold = atoi(arg);
2169 static void opt_verbose(const char *arg)
2171 verbose = atoi(arg);
2172 av_log_set_level(atoi(arg));
2175 static void opt_frame_rate(const char *arg)
2177 if (parse_frame_rate(&frame_rate, &frame_rate_base, arg) < 0) {
2178 fprintf(stderr, "Incorrect frame rate\n");
2183 static void opt_frame_crop_top(const char *arg)
2185 frame_topBand = atoi(arg);
2186 if (frame_topBand < 0) {
2187 fprintf(stderr, "Incorrect top crop size\n");
2190 if ((frame_topBand % 2) != 0) {
2191 fprintf(stderr, "Top crop size must be a multiple of 2\n");
2194 if ((frame_topBand) >= frame_height){
2195 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2198 frame_height -= frame_topBand;
2201 static void opt_frame_crop_bottom(const char *arg)
2203 frame_bottomBand = atoi(arg);
2204 if (frame_bottomBand < 0) {
2205 fprintf(stderr, "Incorrect bottom crop size\n");
2208 if ((frame_bottomBand % 2) != 0) {
2209 fprintf(stderr, "Bottom crop size must be a multiple of 2\n");
2212 if ((frame_bottomBand) >= frame_height){
2213 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2216 frame_height -= frame_bottomBand;
2219 static void opt_frame_crop_left(const char *arg)
2221 frame_leftBand = atoi(arg);
2222 if (frame_leftBand < 0) {
2223 fprintf(stderr, "Incorrect left crop size\n");
2226 if ((frame_leftBand % 2) != 0) {
2227 fprintf(stderr, "Left crop size must be a multiple of 2\n");
2230 if ((frame_leftBand) >= frame_width){
2231 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2234 frame_width -= frame_leftBand;
2237 static void opt_frame_crop_right(const char *arg)
2239 frame_rightBand = atoi(arg);
2240 if (frame_rightBand < 0) {
2241 fprintf(stderr, "Incorrect right crop size\n");
2244 if ((frame_rightBand % 2) != 0) {
2245 fprintf(stderr, "Right crop size must be a multiple of 2\n");
2248 if ((frame_rightBand) >= frame_width){
2249 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2252 frame_width -= frame_rightBand;
2255 static void opt_frame_size(const char *arg)
2257 if (parse_image_size(&frame_width, &frame_height, arg) < 0) {
2258 fprintf(stderr, "Incorrect frame size\n");
2261 if ((frame_width % 2) != 0 || (frame_height % 2) != 0) {
2262 fprintf(stderr, "Frame size must be a multiple of 2\n");
2268 #define SCALEBITS 10
2269 #define ONE_HALF (1 << (SCALEBITS - 1))
2270 #define FIX(x) ((int) ((x) * (1<<SCALEBITS) + 0.5))
2272 #define RGB_TO_Y(r, g, b) \
2273 ((FIX(0.29900) * (r) + FIX(0.58700) * (g) + \
2274 FIX(0.11400) * (b) + ONE_HALF) >> SCALEBITS)
2276 #define RGB_TO_U(r1, g1, b1, shift)\
2277 (((- FIX(0.16874) * r1 - FIX(0.33126) * g1 + \
2278 FIX(0.50000) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2280 #define RGB_TO_V(r1, g1, b1, shift)\
2281 (((FIX(0.50000) * r1 - FIX(0.41869) * g1 - \
2282 FIX(0.08131) * b1 + (ONE_HALF << shift) - 1) >> (SCALEBITS + shift)) + 128)
2284 static void opt_pad_color(const char *arg) {
2285 /* Input is expected to be six hex digits similar to
2286 how colors are expressed in html tags (but without the #) */
2287 int rgb = strtol(arg, NULL, 16);
2291 g = ((rgb >> 8) & 255);
2294 padcolor[0] = RGB_TO_Y(r,g,b);
2295 padcolor[1] = RGB_TO_U(r,g,b,0);
2296 padcolor[2] = RGB_TO_V(r,g,b,0);
2299 static void opt_frame_pad_top(const char *arg)
2301 frame_padtop = atoi(arg);
2302 if (frame_padtop < 0) {
2303 fprintf(stderr, "Incorrect top pad size\n");
2306 if ((frame_padtop % 2) != 0) {
2307 fprintf(stderr, "Top pad size must be a multiple of 2\n");
2312 static void opt_frame_pad_bottom(const char *arg)
2314 frame_padbottom = atoi(arg);
2315 if (frame_padbottom < 0) {
2316 fprintf(stderr, "Incorrect bottom pad size\n");
2319 if ((frame_padbottom % 2) != 0) {
2320 fprintf(stderr, "Bottom pad size must be a multiple of 2\n");
2326 static void opt_frame_pad_left(const char *arg)
2328 frame_padleft = atoi(arg);
2329 if (frame_padleft < 0) {
2330 fprintf(stderr, "Incorrect left pad size\n");
2333 if ((frame_padleft % 2) != 0) {
2334 fprintf(stderr, "Left pad size must be a multiple of 2\n");
2340 static void opt_frame_pad_right(const char *arg)
2342 frame_padright = atoi(arg);
2343 if (frame_padright < 0) {
2344 fprintf(stderr, "Incorrect right pad size\n");
2347 if ((frame_padright % 2) != 0) {
2348 fprintf(stderr, "Right pad size must be a multiple of 2\n");
2354 static void opt_frame_pix_fmt(const char *arg)
2356 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2359 static void opt_frame_aspect_ratio(const char *arg)
2365 p = strchr(arg, ':');
2367 x = strtol(arg, (char **)&arg, 10);
2369 y = strtol(arg+1, (char **)&arg, 10);
2371 ar = (double)x / (double)y;
2373 ar = strtod(arg, (char **)&arg);
2376 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2379 frame_aspect_ratio = ar;
2382 static void opt_gop_size(const char *arg)
2384 gop_size = atoi(arg);
2387 static void opt_b_frames(const char *arg)
2389 b_frames = atoi(arg);
2390 if (b_frames > FF_MAX_B_FRAMES) {
2391 fprintf(stderr, "\nCannot have more than %d B frames, increase FF_MAX_B_FRAMES.\n", FF_MAX_B_FRAMES);
2393 } else if (b_frames < 1) {
2394 fprintf(stderr, "\nNumber of B frames must be higher than 0\n");
2399 static void opt_pre_me(const char *arg)
2404 static void opt_qscale(const char *arg)
2406 video_qscale = atof(arg);
2407 if (video_qscale <= 0 ||
2408 video_qscale > 255) {
2409 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2414 static void opt_qsquish(const char *arg)
2416 video_qsquish = atof(arg);
2417 if (video_qsquish < 0.0 ||
2418 video_qsquish > 99.0) {
2419 fprintf(stderr, "qsquish must be >= 0.0 and <= 99.0\n");
2424 static void opt_lmax(const char *arg)
2426 video_lmax = atof(arg)*FF_QP2LAMBDA;
2429 static void opt_lmin(const char *arg)
2431 video_lmin = atof(arg)*FF_QP2LAMBDA;
2434 static void opt_qmin(const char *arg)
2436 video_qmin = atoi(arg);
2437 if (video_qmin < 1 ||
2439 fprintf(stderr, "qmin must be >= 1 and <= 51\n");
2444 static void opt_qmax(const char *arg)
2446 video_qmax = atoi(arg);
2447 if (video_qmax < 1 ||
2449 fprintf(stderr, "qmax must be >= 1 and <= 51\n");
2454 static void opt_mb_lmin(const char *arg)
2456 video_mb_lmin = atof(arg)*FF_QP2LAMBDA;
2457 if (video_mb_lmin < 1 ||
2458 video_mb_lmin > FF_LAMBDA_MAX) {
2459 fprintf(stderr, "mblmin must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2464 static void opt_mb_lmax(const char *arg)
2466 video_mb_lmax = atof(arg)*FF_QP2LAMBDA;
2467 if (video_mb_lmax < 1 ||
2468 video_mb_lmax > FF_LAMBDA_MAX) {
2469 fprintf(stderr, "mblmax must be >= 1 and <= %d\n", FF_LAMBDA_MAX / FF_QP2LAMBDA);
2474 static void opt_qdiff(const char *arg)
2476 video_qdiff = atoi(arg);
2477 if (video_qdiff < 0 ||
2479 fprintf(stderr, "qdiff must be >= 1 and <= 31\n");
2484 static void opt_qblur(const char *arg)
2486 video_qblur = atof(arg);
2489 static void opt_qcomp(const char *arg)
2491 video_qcomp = atof(arg);
2494 static void opt_rc_initial_cplx(const char *arg)
2496 video_rc_initial_cplx = atof(arg);
2498 static void opt_b_qfactor(const char *arg)
2500 video_b_qfactor = atof(arg);
2502 static void opt_i_qfactor(const char *arg)
2504 video_i_qfactor = atof(arg);
2506 static void opt_b_qoffset(const char *arg)
2508 video_b_qoffset = atof(arg);
2510 static void opt_i_qoffset(const char *arg)
2512 video_i_qoffset = atof(arg);
2515 static void opt_ibias(const char *arg)
2517 video_intra_quant_bias = atoi(arg);
2519 static void opt_pbias(const char *arg)
2521 video_inter_quant_bias = atoi(arg);
2524 static void opt_packet_size(const char *arg)
2526 packet_size= atoi(arg);
2529 static void opt_error_rate(const char *arg)
2531 error_rate= atoi(arg);
2534 static void opt_strict(const char *arg)
2539 static void opt_top_field_first(const char *arg)
2541 top_field_first= atoi(arg);
2544 static void opt_sc_threshold(const char *arg)
2546 sc_threshold= atoi(arg);
2549 static void opt_me_range(const char *arg)
2551 me_range = atoi(arg);
2554 static void opt_thread_count(const char *arg)
2556 thread_count= atoi(arg);
2557 #if !defined(HAVE_THREADS)
2559 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2563 static void opt_audio_bitrate(const char *arg)
2565 audio_bit_rate = atoi(arg) * 1000;
2568 static void opt_audio_rate(const char *arg)
2570 audio_sample_rate = atoi(arg);
2573 static void opt_audio_channels(const char *arg)
2575 audio_channels = atoi(arg);
2578 static void opt_video_device(const char *arg)
2580 video_device = av_strdup(arg);
2583 static void opt_grab_device(const char *arg)
2585 grab_device = av_strdup(arg);
2588 static void opt_video_channel(const char *arg)
2590 video_channel = strtol(arg, NULL, 0);
2593 static void opt_video_standard(const char *arg)
2595 video_standard = av_strdup(arg);
2598 static void opt_audio_device(const char *arg)
2600 audio_device = av_strdup(arg);
2603 static void opt_codec(int *pstream_copy, int *pcodec_id,
2604 int codec_type, const char *arg)
2608 if (!strcmp(arg, "copy")) {
2613 if (!strcmp(p->name, arg) && p->type == codec_type)
2618 fprintf(stderr, "Unknown codec '%s'\n", arg);
2626 static void opt_audio_codec(const char *arg)
2628 opt_codec(&audio_stream_copy, &audio_codec_id, CODEC_TYPE_AUDIO, arg);
2631 static void opt_audio_tag(const char *arg)
2634 audio_codec_tag= strtol(arg, &tail, 0);
2637 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2640 static void opt_video_tag(const char *arg)
2643 video_codec_tag= strtol(arg, &tail, 0);
2646 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2649 static void add_frame_hooker(const char *arg)
2654 char *args = av_strdup(arg);
2658 argv[0] = strtok(args, " ");
2659 while (argc < 62 && (argv[++argc] = strtok(NULL, " "))) {
2662 i = frame_hook_add(argc, argv);
2665 fprintf(stderr, "Failed to add video hook function: %s\n", arg);
2670 const char *motion_str[] = {
2683 static void opt_motion_estimation(const char *arg)
2689 fprintf(stderr, "Unknown motion estimation method '%s'\n", arg);
2692 if (!strcmp(*p, arg))
2696 me_method = (p - motion_str) + 1;
2699 static void opt_video_codec(const char *arg)
2701 opt_codec(&video_stream_copy, &video_codec_id, CODEC_TYPE_VIDEO, arg);
2704 static void opt_subtitle_codec(const char *arg)
2706 opt_codec(&subtitle_stream_copy, &subtitle_codec_id, CODEC_TYPE_SUBTITLE, arg);
2709 static void opt_map(const char *arg)
2715 m = &stream_maps[nb_stream_maps++];
2717 m->file_index = strtol(arg, (char **)&p, 0);
2721 m->stream_index = strtol(p, (char **)&p, 0);
2724 m->sync_file_index = strtol(p, (char **)&p, 0);
2727 m->sync_stream_index = strtol(p, (char **)&p, 0);
2729 m->sync_file_index = m->file_index;
2730 m->sync_stream_index = m->stream_index;
2734 static void opt_map_meta_data(const char *arg)
2740 m = &meta_data_maps[nb_meta_data_maps++];
2742 m->out_file = strtol(arg, (char **)&p, 0);
2746 m->in_file = strtol(p, (char **)&p, 0);
2749 static void opt_recording_time(const char *arg)
2751 recording_time = parse_date(arg, 1);
2754 static void opt_start_time(const char *arg)
2756 start_time = parse_date(arg, 1);
2759 static void opt_rec_timestamp(const char *arg)
2761 rec_timestamp = parse_date(arg, 0) / 1000000;
2764 static void opt_input_ts_offset(const char *arg)
2766 input_ts_offset = parse_date(arg, 1);
2769 static void opt_input_file(const char *filename)
2771 AVFormatContext *ic;
2772 AVFormatParameters params, *ap = ¶ms;
2773 int err, i, ret, rfps, rfps_base;
2776 if (!strcmp(filename, "-"))
2779 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2780 !strcmp( filename, "/dev/stdin" );
2782 /* get default parameters from command line */
2783 memset(ap, 0, sizeof(*ap));
2784 ap->sample_rate = audio_sample_rate;
2785 ap->channels = audio_channels;
2786 ap->time_base.den = frame_rate;
2787 ap->time_base.num = frame_rate_base;
2788 ap->width = frame_width + frame_padleft + frame_padright;
2789 ap->height = frame_height + frame_padtop + frame_padbottom;
2790 ap->image_format = image_format;
2791 ap->pix_fmt = frame_pix_fmt;
2792 ap->device = grab_device;
2793 ap->channel = video_channel;
2794 ap->standard = video_standard;
2795 ap->video_codec_id = video_codec_id;
2796 ap->audio_codec_id = audio_codec_id;
2797 if(pgmyuv_compatibility_hack)
2798 ap->video_codec_id= CODEC_ID_PGMYUV;
2800 /* open the input file with generic libav function */
2801 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2803 print_error(filename, err);
2807 ic->loop_input = loop_input;
2810 ic->flags|= AVFMT_FLAG_GENPTS;
2812 /* If not enough info to get the stream parameters, we decode the
2813 first frames to get it. (used in mpeg case for example) */
2814 ret = av_find_stream_info(ic);
2815 if (ret < 0 && verbose >= 0) {
2816 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2820 timestamp = start_time;
2821 /* add the stream start time */
2822 if (ic->start_time != AV_NOPTS_VALUE)
2823 timestamp += ic->start_time;
2825 /* if seeking requested, we execute it */
2826 if (start_time != 0) {
2827 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2829 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2830 filename, (double)timestamp / AV_TIME_BASE);
2832 /* reset seek info */
2836 /* update the current parameters so that they match the one of the input stream */
2837 for(i=0;i<ic->nb_streams;i++) {
2839 AVCodecContext *enc = ic->streams[i]->codec;
2840 #if defined(HAVE_THREADS)
2842 avcodec_thread_init(enc, thread_count);
2844 enc->thread_count= thread_count;
2845 switch(enc->codec_type) {
2846 case CODEC_TYPE_AUDIO:
2847 for(j=0; j<opt_name_count; j++){
2849 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2850 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2851 av_set_double(enc, opt_names[j], d);
2853 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2854 audio_channels = enc->channels;
2855 audio_sample_rate = enc->sample_rate;
2857 ic->streams[i]->discard= AVDISCARD_ALL;
2859 case CODEC_TYPE_VIDEO:
2860 for(j=0; j<opt_name_count; j++){
2862 double d= av_get_double(avctx_opts, opt_names[j], &opt);
2863 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_DECODING_PARAM))
2864 av_set_double(enc, opt_names[j], d);
2866 frame_height = enc->height;
2867 frame_width = enc->width;
2868 frame_aspect_ratio = av_q2d(enc->sample_aspect_ratio) * enc->width / enc->height;
2869 frame_pix_fmt = enc->pix_fmt;
2870 rfps = ic->streams[i]->r_frame_rate.num;
2871 rfps_base = ic->streams[i]->r_frame_rate.den;
2872 enc->workaround_bugs = workaround_bugs;
2873 if(enc->lowres) enc->flags |= CODEC_FLAG_EMU_EDGE;
2875 enc->debug |= FF_DEBUG_MV;
2877 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2880 fprintf(stderr,"\nSeems that stream %d comes from film source: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2881 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2883 (float)rfps / rfps_base, rfps, rfps_base);
2885 /* update the current frame rate to match the stream frame rate */
2887 frame_rate_base = rfps_base;
2889 enc->rate_emu = rate_emu;
2891 ic->streams[i]->discard= AVDISCARD_ALL;
2892 else if(video_discard)
2893 ic->streams[i]->discard= video_discard;
2895 case CODEC_TYPE_DATA:
2897 case CODEC_TYPE_SUBTITLE:
2899 case CODEC_TYPE_UNKNOWN:
2906 input_files[nb_input_files] = ic;
2907 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2908 /* dump the file content */
2910 dump_format(ic, nb_input_files, filename, 0);
2913 file_iformat = NULL;
2914 file_oformat = NULL;
2915 image_format = NULL;
2923 static void opt_grab(const char *arg)
2925 file_iformat = av_find_input_format(arg);
2929 static void check_audio_video_inputs(int *has_video_ptr, int *has_audio_ptr)
2931 int has_video, has_audio, i, j;
2932 AVFormatContext *ic;
2936 for(j=0;j<nb_input_files;j++) {
2937 ic = input_files[j];
2938 for(i=0;i<ic->nb_streams;i++) {
2939 AVCodecContext *enc = ic->streams[i]->codec;
2940 switch(enc->codec_type) {
2941 case CODEC_TYPE_AUDIO:
2944 case CODEC_TYPE_VIDEO:
2947 case CODEC_TYPE_DATA:
2948 case CODEC_TYPE_UNKNOWN:
2949 case CODEC_TYPE_SUBTITLE:
2956 *has_video_ptr = has_video;
2957 *has_audio_ptr = has_audio;
2960 static void new_video_stream(AVFormatContext *oc)
2963 AVCodecContext *video_enc;
2966 st = av_new_stream(oc, oc->nb_streams);
2968 fprintf(stderr, "Could not alloc stream\n");
2971 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
2972 video_bitstream_filters= NULL;
2974 #if defined(HAVE_THREADS)
2976 avcodec_thread_init(st->codec, thread_count);
2979 video_enc = st->codec;
2982 video_enc->codec_tag= video_codec_tag;
2984 if( (video_global_header&1)
2985 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
2986 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
2987 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
2989 if(video_global_header&2){
2990 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
2991 avctx_opts->flags2|= CODEC_FLAG2_LOCAL_HEADER;
2994 if (video_stream_copy) {
2995 st->stream_copy = 1;
2996 video_enc->codec_type = CODEC_TYPE_VIDEO;
3002 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3003 if (video_codec_id != CODEC_ID_NONE)
3004 codec_id = video_codec_id;
3006 video_enc->codec_id = codec_id;
3007 codec = avcodec_find_encoder(codec_id);
3009 for(i=0; i<opt_name_count; i++){
3011 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3012 if(d==d && (opt->flags&AV_OPT_FLAG_VIDEO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3013 av_set_double(video_enc, opt_names[i], d);
3016 video_enc->bit_rate = video_bit_rate;
3017 video_enc->bit_rate_tolerance = video_bit_rate_tolerance;
3018 video_enc->time_base.den = frame_rate;
3019 video_enc->time_base.num = frame_rate_base;
3020 if(codec && codec->supported_framerates){
3021 const AVRational *p= codec->supported_framerates;
3022 AVRational req= (AVRational){frame_rate, frame_rate_base};
3023 const AVRational *best=NULL;
3024 AVRational best_error= (AVRational){INT_MAX, 1};
3025 for(; p->den!=0; p++){
3026 AVRational error= av_sub_q(req, *p);
3027 if(error.num <0) error.num *= -1;
3028 if(av_cmp_q(error, best_error) < 0){
3033 video_enc->time_base.den= best->num;
3034 video_enc->time_base.num= best->den;
3037 video_enc->width = frame_width + frame_padright + frame_padleft;
3038 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3039 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3040 video_enc->pix_fmt = frame_pix_fmt;
3042 if(codec && codec->pix_fmts){
3043 const enum PixelFormat *p= codec->pix_fmts;
3045 if(*p == video_enc->pix_fmt)
3049 video_enc->pix_fmt = codec->pix_fmts[0];
3053 video_enc->gop_size = gop_size;
3055 video_enc->gop_size = 0;
3056 if (video_qscale || same_quality) {
3057 video_enc->flags |= CODEC_FLAG_QSCALE;
3058 video_enc->global_quality=
3059 st->quality = FF_QP2LAMBDA * video_qscale;
3063 video_enc->intra_matrix = intra_matrix;
3065 video_enc->inter_matrix = inter_matrix;
3067 video_enc->pre_me = pre_me;
3070 video_enc->max_b_frames = b_frames;
3071 video_enc->b_quant_factor = 2.0;
3073 video_enc->qmin = video_qmin;
3074 video_enc->qmax = video_qmax;
3075 video_enc->lmin = video_lmin;
3076 video_enc->lmax = video_lmax;
3077 video_enc->rc_qsquish = video_qsquish;
3078 video_enc->mb_lmin = video_mb_lmin;
3079 video_enc->mb_lmax = video_mb_lmax;
3080 video_enc->max_qdiff = video_qdiff;
3081 video_enc->qblur = video_qblur;
3082 video_enc->qcompress = video_qcomp;
3083 video_enc->rc_eq = video_rc_eq;
3084 video_enc->workaround_bugs = workaround_bugs;
3085 video_enc->thread_count = thread_count;
3086 p= video_rc_override_string;
3089 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3091 fprintf(stderr, "error parsing rc_override\n");
3094 video_enc->rc_override=
3095 av_realloc(video_enc->rc_override,
3096 sizeof(RcOverride)*(i+1));
3097 video_enc->rc_override[i].start_frame= start;
3098 video_enc->rc_override[i].end_frame = end;
3100 video_enc->rc_override[i].qscale= q;
3101 video_enc->rc_override[i].quality_factor= 1.0;
3104 video_enc->rc_override[i].qscale= 0;
3105 video_enc->rc_override[i].quality_factor= -q/100.0;
3110 video_enc->rc_override_count=i;
3112 video_enc->rc_max_rate = video_rc_max_rate;
3113 video_enc->rc_min_rate = video_rc_min_rate;
3114 video_enc->rc_buffer_size = video_rc_buffer_size;
3115 video_enc->rc_initial_buffer_occupancy = video_rc_buffer_size*3/4;
3116 video_enc->rc_buffer_aggressivity= video_rc_buffer_aggressivity;
3117 video_enc->rc_initial_cplx= video_rc_initial_cplx;
3118 video_enc->i_quant_factor = video_i_qfactor;
3119 video_enc->b_quant_factor = video_b_qfactor;
3120 video_enc->i_quant_offset = video_i_qoffset;
3121 video_enc->b_quant_offset = video_b_qoffset;
3122 video_enc->intra_quant_bias = video_intra_quant_bias;
3123 video_enc->inter_quant_bias = video_inter_quant_bias;
3124 video_enc->me_threshold= me_threshold;
3125 video_enc->mb_threshold= mb_threshold;
3126 video_enc->intra_dc_precision= intra_dc_precision - 8;
3127 video_enc->strict_std_compliance = strict;
3128 video_enc->error_rate = error_rate;
3129 video_enc->scenechange_threshold= sc_threshold;
3130 video_enc->me_range = me_range;
3131 video_enc->me_penalty_compensation= me_penalty_compensation;
3132 video_enc->frame_skip_threshold= frame_skip_threshold;
3133 video_enc->frame_skip_factor= frame_skip_factor;
3134 video_enc->frame_skip_exp= frame_skip_exp;
3137 video_enc->rtp_mode= 1;
3138 video_enc->rtp_payload_size= packet_size;
3142 video_enc->flags|= CODEC_FLAG_PSNR;
3144 video_enc->me_method = me_method;
3149 video_enc->flags |= CODEC_FLAG_PASS1;
3151 video_enc->flags |= CODEC_FLAG_PASS2;
3156 /* reset some key parameters */
3158 video_codec_id = CODEC_ID_NONE;
3159 video_stream_copy = 0;
3162 static void new_audio_stream(AVFormatContext *oc)
3165 AVCodecContext *audio_enc;
3168 st = av_new_stream(oc, oc->nb_streams);
3170 fprintf(stderr, "Could not alloc stream\n");
3174 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3175 audio_bitstream_filters= NULL;
3177 #if defined(HAVE_THREADS)
3179 avcodec_thread_init(st->codec, thread_count);
3182 audio_enc = st->codec;
3183 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3186 audio_enc->codec_tag= audio_codec_tag;
3188 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3189 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3190 avctx_opts->flags|= CODEC_FLAG_GLOBAL_HEADER;
3192 if (audio_stream_copy) {
3193 st->stream_copy = 1;
3194 audio_enc->channels = audio_channels;
3196 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3198 for(i=0; i<opt_name_count; i++){
3200 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3201 if(d==d && (opt->flags&AV_OPT_FLAG_AUDIO_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3202 av_set_double(audio_enc, opt_names[i], d);
3205 if (audio_codec_id != CODEC_ID_NONE)
3206 codec_id = audio_codec_id;
3207 audio_enc->codec_id = codec_id;
3209 audio_enc->bit_rate = audio_bit_rate;
3210 if (audio_qscale > QSCALE_NONE) {
3211 audio_enc->flags |= CODEC_FLAG_QSCALE;
3212 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3214 audio_enc->strict_std_compliance = strict;
3215 audio_enc->thread_count = thread_count;
3216 /* For audio codecs other than AC3 or DTS we limit */
3217 /* the number of coded channels to stereo */
3218 if (audio_channels > 2 && codec_id != CODEC_ID_AC3
3219 && codec_id != CODEC_ID_DTS) {
3220 audio_enc->channels = 2;
3222 audio_enc->channels = audio_channels;
3224 audio_enc->sample_rate = audio_sample_rate;
3225 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3226 if (audio_language) {
3227 pstrcpy(st->language, sizeof(st->language), audio_language);
3228 av_free(audio_language);
3229 audio_language = NULL;
3232 /* reset some key parameters */
3234 audio_codec_id = CODEC_ID_NONE;
3235 audio_stream_copy = 0;
3238 static void opt_new_subtitle_stream(void)
3240 AVFormatContext *oc;
3242 AVCodecContext *subtitle_enc;
3245 if (nb_output_files <= 0) {
3246 fprintf(stderr, "At least one output file must be specified\n");
3249 oc = output_files[nb_output_files - 1];
3251 st = av_new_stream(oc, oc->nb_streams);
3253 fprintf(stderr, "Could not alloc stream\n");
3257 subtitle_enc = st->codec;
3258 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3259 if (subtitle_stream_copy) {
3260 st->stream_copy = 1;
3262 for(i=0; i<opt_name_count; i++){
3264 double d= av_get_double(avctx_opts, opt_names[i], &opt);
3265 if(d==d && (opt->flags&AV_OPT_FLAG_SUBTITLE_PARAM) && (opt->flags&AV_OPT_FLAG_ENCODING_PARAM))
3266 av_set_double(subtitle_enc, opt_names[i], d);
3268 subtitle_enc->codec_id = subtitle_codec_id;
3271 if (subtitle_language) {
3272 pstrcpy(st->language, sizeof(st->language), subtitle_language);
3273 av_free(subtitle_language);
3274 subtitle_language = NULL;
3277 subtitle_codec_id = CODEC_ID_NONE;
3278 subtitle_stream_copy = 0;
3281 static void opt_new_audio_stream(void)
3283 AVFormatContext *oc;
3284 if (nb_output_files <= 0) {
3285 fprintf(stderr, "At least one output file must be specified\n");
3288 oc = output_files[nb_output_files - 1];
3289 new_audio_stream(oc);
3292 static void opt_new_video_stream(void)
3294 AVFormatContext *oc;
3295 if (nb_output_files <= 0) {
3296 fprintf(stderr, "At least one output file must be specified\n");
3299 oc = output_files[nb_output_files - 1];
3300 new_video_stream(oc);
3303 static void opt_output_file(const char *filename)
3305 AVFormatContext *oc;
3306 int use_video, use_audio, input_has_video, input_has_audio;
3307 AVFormatParameters params, *ap = ¶ms;
3309 if (!strcmp(filename, "-"))
3312 oc = av_alloc_format_context();
3314 if (!file_oformat) {
3315 file_oformat = guess_format(NULL, filename, NULL);
3316 if (!file_oformat) {
3317 fprintf(stderr, "Unable for find a suitable output format for '%s'\n",
3323 oc->oformat = file_oformat;
3324 pstrcpy(oc->filename, sizeof(oc->filename), filename);
3326 if (!strcmp(file_oformat->name, "ffm") &&
3327 strstart(filename, "http:", NULL)) {
3328 /* special case for files sent to ffserver: we get the stream
3329 parameters from ffserver */
3330 if (read_ffserver_streams(oc, filename) < 0) {
3331 fprintf(stderr, "Could not read stream parameters from '%s'\n", filename);
3335 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_id != CODEC_ID_NONE;
3336 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_id != CODEC_ID_NONE;
3338 /* disable if no corresponding type found and at least one
3340 if (nb_input_files > 0) {
3341 check_audio_video_inputs(&input_has_video, &input_has_audio);
3342 if (!input_has_video)
3344 if (!input_has_audio)
3348 /* manual disable */
3349 if (audio_disable) {
3352 if (video_disable) {
3357 new_video_stream(oc);
3361 new_audio_stream(oc);
3364 if (!oc->nb_streams) {
3365 fprintf(stderr, "No audio or video streams available\n");
3369 oc->timestamp = rec_timestamp;
3372 pstrcpy(oc->title, sizeof(oc->title), str_title);
3374 pstrcpy(oc->author, sizeof(oc->author), str_author);
3376 pstrcpy(oc->copyright, sizeof(oc->copyright), str_copyright);
3378 pstrcpy(oc->comment, sizeof(oc->comment), str_comment);
3381 output_files[nb_output_files++] = oc;
3383 /* check filename in case of an image number is expected */
3384 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3385 if (filename_number_test(oc->filename) < 0) {
3386 print_error(oc->filename, AVERROR_NUMEXPECTED);
3391 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3392 /* test if it already exists to avoid loosing precious files */
3393 if (!file_overwrite &&
3394 (strchr(filename, ':') == NULL ||
3395 strstart(filename, "file:", NULL))) {
3396 if (url_exist(filename)) {
3399 if ( !using_stdin ) {
3400 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3403 if (toupper(c) != 'Y') {
3404 fprintf(stderr, "Not overwriting - exiting\n");
3409 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3416 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3417 fprintf(stderr, "Could not open '%s'\n", filename);
3422 memset(ap, 0, sizeof(*ap));
3423 ap->image_format = image_format;
3424 if (av_set_parameters(oc, ap) < 0) {
3425 fprintf(stderr, "%s: Invalid encoding parameters\n",
3430 oc->packet_size= mux_packet_size;
3431 oc->mux_rate= mux_rate;
3432 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3433 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3434 oc->loop_output = loop_output;
3436 /* reset some options */
3437 file_oformat = NULL;
3438 file_iformat = NULL;
3439 image_format = NULL;
3442 /* prepare dummy protocols for grab */
3443 static void prepare_grab(void)
3445 int has_video, has_audio, i, j;
3446 AVFormatContext *oc;
3447 AVFormatContext *ic;
3448 AVFormatParameters vp1, *vp = &vp1;
3449 AVFormatParameters ap1, *ap = &ap1;
3451 /* see if audio/video inputs are needed */
3454 memset(ap, 0, sizeof(*ap));
3455 memset(vp, 0, sizeof(*vp));
3456 vp->time_base.num= 1;
3457 for(j=0;j<nb_output_files;j++) {
3458 oc = output_files[j];
3459 for(i=0;i<oc->nb_streams;i++) {
3460 AVCodecContext *enc = oc->streams[i]->codec;
3461 switch(enc->codec_type) {
3462 case CODEC_TYPE_AUDIO:
3463 if (enc->sample_rate > ap->sample_rate)
3464 ap->sample_rate = enc->sample_rate;
3465 if (enc->channels > ap->channels)
3466 ap->channels = enc->channels;
3469 case CODEC_TYPE_VIDEO:
3470 if (enc->width > vp->width)
3471 vp->width = enc->width;
3472 if (enc->height > vp->height)
3473 vp->height = enc->height;
3475 if (vp->time_base.num*(int64_t)enc->time_base.den > enc->time_base.num*(int64_t)vp->time_base.den){
3476 vp->time_base = enc->time_base;
3477 vp->width += frame_leftBand + frame_rightBand;
3478 vp->width -= (frame_padleft + frame_padright);
3479 vp->height += frame_topBand + frame_bottomBand;
3480 vp->height -= (frame_padtop + frame_padbottom);
3490 if (has_video == 0 && has_audio == 0) {
3491 fprintf(stderr, "Output file must have at least one audio or video stream\n");
3496 AVInputFormat *fmt1;
3497 fmt1 = av_find_input_format(video_grab_format);
3498 vp->device = video_device;
3499 vp->channel = video_channel;
3500 vp->standard = video_standard;
3501 vp->pix_fmt = frame_pix_fmt;
3502 if (av_open_input_file(&ic, "", fmt1, 0, vp) < 0) {
3503 fprintf(stderr, "Could not find video grab device\n");
3506 /* If not enough info to get the stream parameters, we decode the
3507 first frames to get it. */
3508 if ((ic->ctx_flags & AVFMTCTX_NOHEADER) && av_find_stream_info(ic) < 0) {
3509 fprintf(stderr, "Could not find video grab parameters\n");
3512 /* by now video grab has one stream */
3513 ic->streams[0]->r_frame_rate.num = vp->time_base.den;
3514 ic->streams[0]->r_frame_rate.den = vp->time_base.num;
3515 input_files[nb_input_files] = ic;
3518 dump_format(ic, nb_input_files, "", 0);
3522 if (has_audio && audio_grab_format) {
3523 AVInputFormat *fmt1;
3524 fmt1 = av_find_input_format(audio_grab_format);
3525 ap->device = audio_device;
3526 if (av_open_input_file(&ic, "", fmt1, 0, ap) < 0) {
3527 fprintf(stderr, "Could not find audio grab device\n");
3530 input_files[nb_input_files] = ic;
3533 dump_format(ic, nb_input_files, "", 0);
3539 /* same option as mencoder */
3540 static void opt_pass(const char *pass_str)
3543 pass = atoi(pass_str);
3544 if (pass != 1 && pass != 2) {
3545 fprintf(stderr, "pass number can be only 1 or 2\n");
3551 #if defined(__MINGW32__) || defined(CONFIG_OS2)
3552 static int64_t getutime(void)
3554 return av_gettime();
3557 static int64_t getutime(void)
3559 struct rusage rusage;
3561 getrusage(RUSAGE_SELF, &rusage);
3562 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3566 extern int ffm_nopts;
3568 static void show_formats(void)
3570 AVInputFormat *ifmt;
3571 AVOutputFormat *ofmt;
3572 AVImageFormat *image_fmt;
3575 const char **pp, *last_name;
3577 printf("File formats:\n");
3582 const char *name=NULL;
3583 const char *long_name=NULL;
3585 for(ofmt = first_oformat; ofmt != NULL; ofmt = ofmt->next) {
3586 if((name == NULL || strcmp(ofmt->name, name)<0) &&
3587 strcmp(ofmt->name, last_name)>0){
3589 long_name= ofmt->long_name;
3593 for(ifmt = first_iformat; ifmt != NULL; ifmt = ifmt->next) {
3594 if((name == NULL || strcmp(ifmt->name, name)<0) &&
3595 strcmp(ifmt->name, last_name)>0){
3597 long_name= ifmt->long_name;
3600 if(name && strcmp(ifmt->name, name)==0)
3612 long_name ? long_name:" ");
3616 printf("Image formats (filename extensions, if any, follow):\n");
3617 for(image_fmt = first_image_format; image_fmt != NULL;
3618 image_fmt = image_fmt->next) {
3621 image_fmt->img_read ? "D":" ",
3622 image_fmt->img_write ? "E":" ",
3624 image_fmt->extensions ? image_fmt->extensions:" ");
3628 printf("Codecs:\n");
3634 const char *type_str;
3637 for(p = first_avcodec; p != NULL; p = p->next) {
3638 if((p2==NULL || strcmp(p->name, p2->name)<0) &&
3639 strcmp(p->name, last_name)>0){
3641 decode= encode= cap=0;
3643 if(p2 && strcmp(p->name, p2->name)==0){
3644 if(p->decode) decode=1;
3645 if(p->encode) encode=1;
3646 cap |= p->capabilities;
3651 last_name= p2->name;
3654 case CODEC_TYPE_VIDEO:
3657 case CODEC_TYPE_AUDIO:
3660 case CODEC_TYPE_SUBTITLE:
3669 decode ? "D": (/*p2->decoder ? "d":*/" "),
3672 cap & CODEC_CAP_DRAW_HORIZ_BAND ? "S":" ",
3673 cap & CODEC_CAP_DR1 ? "D":" ",
3674 cap & CODEC_CAP_TRUNCATED ? "T":" ",
3676 /* if(p2->decoder && decode==0)
3677 printf(" use %s for decoding", p2->decoder->name);*/
3682 printf("Supported file protocols:\n");
3683 for(up = first_protocol; up != NULL; up = up->next)
3684 printf(" %s:", up->name);
3687 printf("Frame size, frame rate abbreviations:\n ntsc pal qntsc qpal sntsc spal film ntsc-film sqcif qcif cif 4cif\n");
3688 printf("Motion estimation methods:\n");
3692 if ((pp - motion_str + 1) == ME_ZERO)
3693 printf("(fastest)");
3694 else if ((pp - motion_str + 1) == ME_FULL)
3695 printf("(slowest)");
3696 else if ((pp - motion_str + 1) == ME_EPZS)
3697 printf("(default)");
3702 "Note, the names of encoders and decoders dont always match, so there are\n"
3703 "several cases where the above table shows encoder only or decoder only entries\n"
3704 "even though both encoding and decoding are supported for example, the h263\n"
3705 "decoder corresponds to the h263 and h263p encoders, for file formats its even\n"
3710 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3713 const char *p = str;
3720 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3727 static void opt_inter_matrix(const char *arg)
3729 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3730 parse_matrix_coeffs(inter_matrix, arg);
3733 static void opt_intra_matrix(const char *arg)
3735 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3736 parse_matrix_coeffs(intra_matrix, arg);
3739 static void opt_target(const char *arg)
3742 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3744 if(!strncmp(arg, "pal-", 4)) {
3747 } else if(!strncmp(arg, "ntsc-", 5)) {
3750 } else if(!strncmp(arg, "film-", 5)) {
3755 /* Calculate FR via float to avoid int overflow */
3756 fr = (int)(frame_rate * 1000.0 / frame_rate_base);
3759 } else if((fr == 29970) || (fr == 23976)) {
3762 /* Try to determine PAL/NTSC by peeking in the input files */
3763 if(nb_input_files) {
3765 for(j = 0; j < nb_input_files; j++) {
3766 for(i = 0; i < input_files[j]->nb_streams; i++) {
3767 AVCodecContext *c = input_files[j]->streams[i]->codec;
3768 if(c->codec_type != CODEC_TYPE_VIDEO)
3770 fr = c->time_base.den * 1000 / c->time_base.num;
3774 } else if((fr == 29970) || (fr == 23976)) {
3784 if(verbose && norm >= 0)
3785 fprintf(stderr, "Assuming %s for target.\n", norm ? "NTSC" : "PAL");
3789 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3790 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3791 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3795 if(!strcmp(arg, "vcd")) {
3797 opt_video_codec("mpeg1video");
3798 opt_audio_codec("mp2");
3801 opt_frame_size(norm ? "352x240" : "352x288");
3802 opt_frame_rate(frame_rates[norm]);
3803 opt_gop_size(norm ? "18" : "15");
3805 video_bit_rate = 1150000;
3806 video_rc_max_rate = 1150000;
3807 video_rc_min_rate = 1150000;
3808 video_rc_buffer_size = 40*1024*8;
3810 audio_bit_rate = 224000;
3811 audio_sample_rate = 44100;
3813 mux_packet_size= 2324;
3814 mux_rate= 2352 * 75 * 8;
3816 /* We have to offset the PTS, so that it is consistent with the SCR.
3817 SCR starts at 36000, but the first two packs contain only padding
3818 and the first pack from the other stream, respectively, may also have
3819 been written before.
3820 So the real data starts at SCR 36000+3*1200. */
3821 mux_preload= (36000+3*1200) / 90000.0; //0.44
3822 } else if(!strcmp(arg, "svcd")) {
3824 opt_video_codec("mpeg2video");
3825 opt_audio_codec("mp2");
3828 opt_frame_size(norm ? "480x480" : "480x576");
3829 opt_frame_rate(frame_rates[norm]);
3830 opt_gop_size(norm ? "18" : "15");
3832 video_bit_rate = 2040000;
3833 video_rc_max_rate = 2516000;
3834 video_rc_min_rate = 0; //1145000;
3835 video_rc_buffer_size = 224*1024*8;
3836 opt_default("flags", "+SCAN_OFFSET");
3839 audio_bit_rate = 224000;
3840 audio_sample_rate = 44100;
3842 mux_packet_size= 2324;
3844 } else if(!strcmp(arg, "dvd")) {
3846 opt_video_codec("mpeg2video");
3847 opt_audio_codec("ac3");
3850 opt_frame_size(norm ? "720x480" : "720x576");
3851 opt_frame_rate(frame_rates[norm]);
3852 opt_gop_size(norm ? "18" : "15");
3854 video_bit_rate = 6000000;
3855 video_rc_max_rate = 9000000;
3856 video_rc_min_rate = 0; //1500000;
3857 video_rc_buffer_size = 224*1024*8;
3859 mux_packet_size= 2048; // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3860 mux_rate = 10080000; // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3862 audio_bit_rate = 448000;
3863 audio_sample_rate = 48000;
3865 } else if(!strncmp(arg, "dv", 2)) {
3869 opt_frame_size(norm ? "720x480" : "720x576");
3870 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3871 (norm ? "yuv411p" : "yuv420p"));
3872 opt_frame_rate(frame_rates[norm]);
3874 audio_sample_rate = 48000;
3878 fprintf(stderr, "Unknown target: %s\n", arg);
3883 static void opt_video_bsf(const char *arg)
3885 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3886 AVBitStreamFilterContext **bsfp;
3889 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3893 bsfp= &video_bitstream_filters;
3895 bsfp= &(*bsfp)->next;
3900 //FIXME avoid audio - video code duplication
3901 static void opt_audio_bsf(const char *arg)
3903 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3904 AVBitStreamFilterContext **bsfp;
3907 fprintf(stderr, "Unkown bitstream filter %s\n", arg);
3911 bsfp= &audio_bitstream_filters;
3913 bsfp= &(*bsfp)->next;
3918 static void show_version(void)
3920 /* TODO: add function interface to avutil and avformat */
3921 fprintf(stderr, "ffmpeg " FFMPEG_VERSION "\n"
3925 LIBAVUTIL_BUILD, avcodec_build(), LIBAVFORMAT_BUILD);
3929 static int opt_default(const char *opt, const char *arg){
3930 AVOption *o= av_set_string(avctx_opts, opt, arg);
3934 // 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));
3936 //FIXME we should always use avctx_opts, ... for storing options so there wont be any need to keep track of whats set over this
3937 opt_names= av_realloc(opt_names, sizeof(void*)*(opt_name_count+1));
3938 opt_names[opt_name_count++]= o->name;
3940 /* disable generate of real time pts in ffm (need to be supressed anyway) */
3941 if(avctx_opts->flags & CODEC_FLAG_BITEXACT)
3944 if(avctx_opts->debug)
3945 av_log_set_level(AV_LOG_DEBUG);
3949 const OptionDef options[] = {
3951 { "L", 0, {(void*)show_license}, "show license" },
3952 { "h", 0, {(void*)show_help}, "show help" },
3953 { "version", 0, {(void*)show_version}, "show version" },
3954 { "formats", 0, {(void*)show_formats}, "show available formats, codecs, protocols, ..." },
3955 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3956 { "img", HAS_ARG, {(void*)opt_image_format}, "force image format", "img_fmt" },
3957 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3958 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3959 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3960 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3961 { "t", HAS_ARG, {(void*)opt_recording_time}, "set the recording time", "duration" },
3962 { "fs", HAS_ARG | OPT_INT, {(void*)&limit_filesize}, "set the limit file size", "limit_size" }, //
3963 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3964 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3965 { "title", HAS_ARG | OPT_STRING, {(void*)&str_title}, "set the title", "string" },
3966 { "timestamp", HAS_ARG, {(void*)&opt_rec_timestamp}, "set the timestamp", "time" },
3967 { "author", HAS_ARG | OPT_STRING, {(void*)&str_author}, "set the author", "string" },
3968 { "copyright", HAS_ARG | OPT_STRING, {(void*)&str_copyright}, "set the copyright", "string" },
3969 { "comment", HAS_ARG | OPT_STRING, {(void*)&str_comment}, "set the comment", "string" },
3970 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3971 "add timings for benchmarking" },
3972 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3973 "dump each input packet" },
3974 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3975 "when dumping packets, also dump the payload" },
3976 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3977 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3978 { "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)", "" },
3979 { "v", HAS_ARG, {(void*)opt_verbose}, "control amount of logging", "verbose" },
3980 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3981 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3982 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3983 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3984 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3985 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3986 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3987 { "dts_delta_threshold", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "" },
3990 { "b", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate}, "set video bitrate (in kbit/s)", "bitrate" },
3991 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3992 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3993 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3994 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3995 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3996 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3997 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format", "format" },
3998 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3999 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
4000 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
4001 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
4002 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
4003 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
4004 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
4005 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
4006 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
4007 { "g", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_gop_size}, "set the group of picture size", "gop_size" },
4008 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4009 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4010 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4011 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantiser scale (VBR)", "q" },
4012 { "qmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmin}, "min video quantiser scale (VBR)", "q" },
4013 { "qmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qmax}, "max video quantiser scale (VBR)", "q" },
4014 { "lmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmin}, "min video lagrange factor (VBR)", "lambda" },
4015 { "lmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_lmax}, "max video lagrange factor (VBR)", "lambda" },
4016 { "mblmin", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmin}, "min macroblock quantiser scale (VBR)", "q" },
4017 { "mblmax", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_lmax}, "max macroblock quantiser scale (VBR)", "q" },
4018 { "qdiff", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qdiff}, "max difference between the quantiser scale (VBR)", "q" },
4019 { "qblur", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qblur}, "video quantiser scale blur (VBR)", "blur" },
4020 { "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" },
4021 { "qcomp", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qcomp}, "video quantiser scale compression (VBR)", "compression" },
4022 { "rc_init_cplx", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_rc_initial_cplx}, "initial complexity for 1-pass encoding", "complexity" },
4023 { "b_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qfactor}, "qp factor between p and b frames", "factor" },
4024 { "i_qfactor", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qfactor}, "qp factor between p and i frames", "factor" },
4025 { "b_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_qoffset}, "qp offset between p and b frames", "offset" },
4026 { "i_qoffset", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_i_qoffset}, "qp offset between p and i frames", "offset" },
4027 { "ibias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_ibias}, "intra quant bias", "bias" },
4028 { "pbias", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pbias}, "inter quant bias", "bias" },
4029 { "rc_eq", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_eq}, "set rate control equation", "equation" },
4030 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4031 { "bt", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_tolerance}, "set video bitrate tolerance (in kbit/s)", "tolerance" },
4032 { "maxrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_max}, "set max video bitrate tolerance (in kbit/s)", "bitrate" },
4033 { "minrate", HAS_ARG | OPT_VIDEO, {(void*)opt_video_bitrate_min}, "set min video bitrate tolerance (in kbit/s)", "bitrate" },
4034 { "bufsize", HAS_ARG | OPT_VIDEO, {(void*)opt_video_buffer_size}, "set ratecontrol buffer size (in kByte)", "size" },
4035 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4036 { "me", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_motion_estimation}, "set motion estimation method",
4038 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "" },
4039 { "mb_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_mb_threshold}, "macroblock threshold", "" },
4040 { "bf", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_b_frames}, "use 'frames' B frames", "frames" },
4041 { "preme", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_pre_me}, "pre motion estimation", "" },
4042 { "bug", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_workaround_bugs}, "workaround not auto detected encoder bugs", "param" },
4043 { "ps", HAS_ARG | OPT_EXPERT, {(void*)opt_packet_size}, "set packet size in bits", "size" },
4044 { "error", HAS_ARG | OPT_EXPERT, {(void*)opt_error_rate}, "error rate", "rate" },
4045 { "strict", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_strict}, "how strictly to follow the standards", "strictness" },
4046 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
4047 "use same video quality as source (implies VBR)" },
4048 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
4049 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename}, "select two pass log file name", "file" },
4050 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4051 "deinterlace pictures" },
4052 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4053 { "vstats", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_vstats}, "dump video coding statistics to file" },
4054 { "vhook", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)add_frame_hooker}, "insert video processing module", "module" },
4055 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4056 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4057 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4058 { "sc_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_sc_threshold}, "scene change threshold", "threshold" },
4059 { "me_range", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_range}, "limit motion vectors range (1023 for DivX player)", "range" },
4060 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4061 { "mepc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&me_penalty_compensation}, "motion estimation bitrate penalty compensation", "factor (1.0 = 256)" },
4062 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4063 { "skip_threshold", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_threshold}, "frame skip threshold", "threshold" },
4064 { "skip_factor", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_factor}, "frame skip factor", "factor" },
4065 { "skip_exp", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&frame_skip_exp}, "frame skip exponent", "exponent" },
4066 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
4067 { "genpts", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&genpts }, "generate pts" },
4068 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4071 { "ab", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_bitrate}, "set audio bitrate (in kbit/s)", "bitrate", },
4072 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4073 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4074 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4075 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4076 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4077 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4078 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4079 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
4080 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4082 /* subtitle options */
4083 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4084 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
4085 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4088 { "vd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_device}, "set video grab device", "device" },
4089 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
4090 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
4091 { "ad", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_GRAB, {(void*)opt_audio_device}, "set audio device", "device" },
4093 /* G.2 grab options */
4094 { "grab", HAS_ARG | OPT_EXPERT | OPT_GRAB, {(void*)opt_grab}, "request grabbing using", "format" },
4095 { "gd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_grab_device}, "set grab device", "device" },
4098 { "muxrate", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_rate}, "set mux rate", "rate" },
4099 { "packetsize", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&mux_packet_size}, "set packet size", "size" },
4100 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4101 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4103 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_audio_bsf}, "", "bitstream filter" },
4104 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_video_bsf}, "", "bitstream filter" },
4106 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4110 static void show_banner(void)
4112 fprintf(stderr, "FFmpeg version " FFMPEG_VERSION ", Copyright (c) 2000-2004 Fabrice Bellard\n");
4113 fprintf(stderr, " configuration: " FFMPEG_CONFIGURATION "\n");
4114 fprintf(stderr, " libavutil version: " AV_STRINGIFY(LIBAVUTIL_VERSION) "\n");
4115 fprintf(stderr, " libavcodec version: " AV_STRINGIFY(LIBAVCODEC_VERSION) "\n");
4116 fprintf(stderr, " libavformat version: " AV_STRINGIFY(LIBAVFORMAT_VERSION) "\n");
4117 fprintf(stderr, " built on " __DATE__ " " __TIME__);
4119 fprintf(stderr, ", gcc: " __VERSION__ "\n");
4121 fprintf(stderr, ", using a non-gcc compiler\n");
4125 static void show_license(void)
4130 "This program is free software; you can redistribute it and/or modify\n"
4131 "it under the terms of the GNU General Public License as published by\n"
4132 "the Free Software Foundation; either version 2 of the License, or\n"
4133 "(at your option) any later version.\n"
4135 "This program is distributed in the hope that it will be useful,\n"
4136 "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
4137 "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n"
4138 "GNU General Public License for more details.\n"
4140 "You should have received a copy of the GNU General Public License\n"
4141 "along with this program; if not, write to the Free Software\n"
4142 "Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA\n"
4146 "This library is free software; you can redistribute it and/or\n"
4147 "modify it under the terms of the GNU Lesser General Public\n"
4148 "License as published by the Free Software Foundation; either\n"
4149 "version 2 of the License, or (at your option) any later version.\n"
4151 "This library 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 GNU\n"
4154 "Lesser General Public License for more details.\n"
4156 "You should have received a copy of the GNU Lesser General Public\n"
4157 "License along with this library; if not, write to the Free Software\n"
4158 "Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA\n"
4164 static void show_help(void)
4167 printf("usage: ffmpeg [[infile options] -i infile]... {[outfile options] outfile}...\n"
4168 "Hyper fast Audio and Video encoder\n");
4170 show_help_options(options, "Main options:\n",
4171 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO, 0);
4172 show_help_options(options, "\nVideo options:\n",
4173 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4175 show_help_options(options, "\nAdvanced Video options:\n",
4176 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4177 OPT_VIDEO | OPT_EXPERT);
4178 show_help_options(options, "\nAudio options:\n",
4179 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4181 show_help_options(options, "\nAdvanced Audio options:\n",
4182 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4183 OPT_AUDIO | OPT_EXPERT);
4184 show_help_options(options, "\nSubtitle options:\n",
4185 OPT_SUBTITLE | OPT_GRAB,
4187 show_help_options(options, "\nAudio/Video grab options:\n",
4190 show_help_options(options, "\nAdvanced options:\n",
4191 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4193 av_opt_show(avctx_opts, NULL);
4198 void parse_arg_file(const char *filename)
4200 opt_output_file(filename);
4203 int main(int argc, char **argv)
4210 avctx_opts= avcodec_alloc_context();
4218 parse_options(argc, argv, options);
4220 /* file converter / grab */
4221 if (nb_output_files <= 0) {
4222 fprintf(stderr, "Must supply at least one output file\n");
4226 if (nb_input_files == 0) {
4232 av_encode(output_files, nb_output_files, input_files, nb_input_files,
4233 stream_maps, nb_stream_maps);
4234 ti = getutime() - ti;
4236 printf("bench: utime=%0.3fs\n", ti / 1000000.0);
4240 for(i=0;i<nb_output_files;i++) {
4241 /* maybe av_close_output_file ??? */
4242 AVFormatContext *s = output_files[i];
4244 if (!(s->oformat->flags & AVFMT_NOFILE))
4246 for(j=0;j<s->nb_streams;j++)
4247 av_free(s->streams[j]);
4250 for(i=0;i<nb_input_files;i++)
4251 av_close_input_file(input_files[i]);
4256 av_free(intra_matrix);
4258 av_free(inter_matrix);
4260 #ifdef POWERPC_PERFORMANCE_REPORT
4261 extern void powerpc_display_perf_report(void);
4262 powerpc_display_perf_report();
4263 #endif /* POWERPC_PERFORMANCE_REPORT */
4266 if (received_sigterm) {
4268 "Received signal %d: terminating.\n",
4269 (int) received_sigterm);
4273 exit(0); /* not all OS-es handle main() return value */