3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
22 /* needed for usleep() */
23 #define _XOPEN_SOURCE 600
34 #include "libavformat/avformat.h"
35 #include "libavdevice/avdevice.h"
36 #include "libswscale/swscale.h"
37 #include "libavcodec/opt.h"
38 #include "libavcodec/audioconvert.h"
39 #include "libavcodec/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/avstring.h"
42 #include "libavformat/os_support.h"
44 #if HAVE_SYS_RESOURCE_H
45 #include <sys/types.h>
46 #include <sys/resource.h>
47 #elif HAVE_GETPROCESSTIMES
52 #include <sys/select.h>
57 #include <sys/ioctl.h>
63 #undef time //needed because HAVE_AV_CONFIG_H is defined on top
73 const char program_name[] = "FFmpeg";
74 const int program_birth_year = 2000;
76 /* select an input stream for an output stream */
77 typedef struct AVStreamMap {
81 int sync_stream_index;
84 /** select an input file for an output file */
85 typedef struct AVMetaDataMap {
90 static const OptionDef options[];
94 static const char *last_asked_format = NULL;
95 static AVFormatContext *input_files[MAX_FILES];
96 static int64_t input_files_ts_offset[MAX_FILES];
97 static double input_files_ts_scale[MAX_FILES][MAX_STREAMS];
98 static AVCodec *input_codecs[MAX_FILES*MAX_STREAMS];
99 static int nb_input_files = 0;
100 static int nb_icodecs;
102 static AVFormatContext *output_files[MAX_FILES];
103 static AVCodec *output_codecs[MAX_FILES*MAX_STREAMS];
104 static int nb_output_files = 0;
105 static int nb_ocodecs;
107 static AVStreamMap stream_maps[MAX_FILES*MAX_STREAMS];
108 static int nb_stream_maps;
110 static AVMetaDataMap meta_data_maps[MAX_FILES];
111 static int nb_meta_data_maps;
113 static int frame_width = 0;
114 static int frame_height = 0;
115 static float frame_aspect_ratio = 0;
116 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
117 static enum SampleFormat audio_sample_fmt = SAMPLE_FMT_NONE;
118 static int frame_padtop = 0;
119 static int frame_padbottom = 0;
120 static int frame_padleft = 0;
121 static int frame_padright = 0;
122 static int padcolor[3] = {16,128,128}; /* default to black */
123 static int frame_topBand = 0;
124 static int frame_bottomBand = 0;
125 static int frame_leftBand = 0;
126 static int frame_rightBand = 0;
127 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
128 static AVRational frame_rate;
129 static float video_qscale = 0;
130 static uint16_t *intra_matrix = NULL;
131 static uint16_t *inter_matrix = NULL;
132 static const char *video_rc_override_string=NULL;
133 static int video_disable = 0;
134 static int video_discard = 0;
135 static char *video_codec_name = NULL;
136 static int video_codec_tag = 0;
137 static char *video_language = NULL;
138 static int same_quality = 0;
139 static int do_deinterlace = 0;
140 static int top_field_first = -1;
141 static int me_threshold = 0;
142 static int intra_dc_precision = 8;
143 static int loop_input = 0;
144 static int loop_output = AVFMT_NOOUTPUTLOOP;
145 static int qp_hist = 0;
147 static int intra_only = 0;
148 static int audio_sample_rate = 44100;
149 static int64_t channel_layout = 0;
150 #define QSCALE_NONE -99999
151 static float audio_qscale = QSCALE_NONE;
152 static int audio_disable = 0;
153 static int audio_channels = 1;
154 static char *audio_codec_name = NULL;
155 static int audio_codec_tag = 0;
156 static char *audio_language = NULL;
158 static int subtitle_disable = 0;
159 static char *subtitle_codec_name = NULL;
160 static char *subtitle_language = NULL;
161 static int subtitle_codec_tag = 0;
163 static float mux_preload= 0.5;
164 static float mux_max_delay= 0.7;
166 static int64_t recording_time = INT64_MAX;
167 static int64_t start_time = 0;
168 static int64_t rec_timestamp = 0;
169 static int64_t input_ts_offset = 0;
170 static int file_overwrite = 0;
171 static int metadata_count;
172 static AVMetadataTag *metadata;
173 static int do_benchmark = 0;
174 static int do_hex_dump = 0;
175 static int do_pkt_dump = 0;
176 static int do_psnr = 0;
177 static int do_pass = 0;
178 static char *pass_logfilename_prefix = NULL;
179 static int audio_stream_copy = 0;
180 static int video_stream_copy = 0;
181 static int subtitle_stream_copy = 0;
182 static int video_sync_method= -1;
183 static int audio_sync_method= 0;
184 static float audio_drift_threshold= 0.1;
185 static int copy_ts= 0;
186 static int opt_shortest = 0;
187 static int video_global_header = 0;
188 static char *vstats_filename;
189 static FILE *vstats_file;
190 static int opt_programid = 0;
191 static int copy_initial_nonkeyframes = 0;
193 static int rate_emu = 0;
195 static int video_channel = 0;
196 static char *video_standard;
198 static int audio_volume = 256;
200 static int exit_on_error = 0;
201 static int using_stdin = 0;
202 static int verbose = 1;
203 static int thread_count= 1;
204 static int q_pressed = 0;
205 static int64_t video_size = 0;
206 static int64_t audio_size = 0;
207 static int64_t extra_size = 0;
208 static int nb_frames_dup = 0;
209 static int nb_frames_drop = 0;
210 static int input_sync;
211 static uint64_t limit_filesize = 0;
212 static int force_fps = 0;
214 static int pgmyuv_compatibility_hack=0;
215 static float dts_delta_threshold = 10;
217 static unsigned int sws_flags = SWS_BICUBIC;
219 static int64_t timer_start;
221 static uint8_t *audio_buf;
222 static uint8_t *audio_out;
223 unsigned int allocated_audio_out_size, allocated_audio_buf_size;
225 static short *samples;
227 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
228 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
229 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
230 static AVBitStreamFilterContext *bitstream_filters[MAX_FILES][MAX_STREAMS];
232 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
234 struct AVInputStream;
236 typedef struct AVOutputStream {
237 int file_index; /* file index */
238 int index; /* stream index in the output file */
239 int source_index; /* AVInputStream index */
240 AVStream *st; /* stream in the output file */
241 int encoding_needed; /* true if encoding needed for this stream */
243 /* input pts and corresponding output pts
245 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
246 struct AVInputStream *sync_ist; /* input stream to sync against */
247 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
250 AVFrame pict_tmp; /* temporary image for resampling */
251 struct SwsContext *img_resample_ctx; /* for image resampling */
254 int resample_pix_fmt;
256 /* full frame size of first frame */
260 /* cropping area sizes */
267 /* cropping area of first frame */
268 int original_topBand;
269 int original_bottomBand;
270 int original_leftBand;
271 int original_rightBand;
273 /* padding area sizes */
282 ReSampleContext *resample; /* for audio resampling */
284 AVAudioConvert *reformat_ctx;
285 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
289 typedef struct AVInputStream {
293 int discard; /* true if stream data should be discarded */
294 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
295 int64_t sample_index; /* current sample */
297 int64_t start; /* time when read started */
298 int64_t next_pts; /* synthetic pts for cases where pkt.pts
300 int64_t pts; /* current pts */
301 int is_start; /* is 1 at the start and after a discontinuity */
304 typedef struct AVInputFile {
305 int eof_reached; /* true if eof reached */
306 int ist_index; /* index of first stream in ist_table */
307 int buffer_size; /* current total buffer size */
308 int nb_streams; /* nb streams we are aware of */
313 /* init terminal so that we can grab keys */
314 static struct termios oldtty;
317 static void term_exit(void)
320 tcsetattr (0, TCSANOW, &oldtty);
324 static volatile int received_sigterm = 0;
327 sigterm_handler(int sig)
329 received_sigterm = sig;
333 static void term_init(void)
341 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
342 |INLCR|IGNCR|ICRNL|IXON);
343 tty.c_oflag |= OPOST;
344 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
345 tty.c_cflag &= ~(CSIZE|PARENB);
350 tcsetattr (0, TCSANOW, &tty);
351 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
354 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
355 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
357 register a function to be called at normal program termination
360 #if CONFIG_BEOS_NETSERVER
361 fcntl(0, F_SETFL, fcntl(0, F_GETFL) | O_NONBLOCK);
365 /* read a key without blocking */
366 static int read_key(void)
371 #if !CONFIG_BEOS_NETSERVER
379 n = select(1, &rfds, NULL, NULL, &tv);
395 static int decode_interrupt_cb(void)
397 return q_pressed || (q_pressed = read_key() == 'q');
400 static int av_exit(int ret)
405 for(i=0;i<nb_output_files;i++) {
406 /* maybe av_close_output_file ??? */
407 AVFormatContext *s = output_files[i];
409 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
411 for(j=0;j<s->nb_streams;j++) {
412 av_metadata_free(&s->streams[j]->metadata);
413 av_free(s->streams[j]->codec);
414 av_free(s->streams[j]);
416 for(j=0;j<s->nb_programs;j++) {
417 av_metadata_free(&s->programs[j]->metadata);
419 for(j=0;j<s->nb_chapters;j++) {
420 av_metadata_free(&s->chapters[j]->metadata);
422 av_metadata_free(&s->metadata);
425 for(i=0;i<nb_input_files;i++)
426 av_close_input_file(input_files[i]);
428 av_free(intra_matrix);
429 av_free(inter_matrix);
433 av_free(vstats_filename);
437 av_free(video_codec_name);
438 av_free(audio_codec_name);
439 av_free(subtitle_codec_name);
441 av_free(video_standard);
443 #if CONFIG_POWERPC_PERF
444 void powerpc_display_perf_report(void);
445 powerpc_display_perf_report();
446 #endif /* CONFIG_POWERPC_PERF */
448 for (i=0;i<CODEC_TYPE_NB;i++)
449 av_free(avcodec_opts[i]);
450 av_free(avformat_opts);
454 allocated_audio_buf_size= allocated_audio_out_size= 0;
457 if (received_sigterm) {
459 "Received signal %d: terminating.\n",
460 (int) received_sigterm);
464 exit(ret); /* not all OS-es handle main() return value */
468 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
474 err = av_open_input_file(&ic, filename, NULL, FFM_PACKET_SIZE, NULL);
477 /* copy stream format */
478 s->nb_streams = ic->nb_streams;
479 for(i=0;i<ic->nb_streams;i++) {
482 // FIXME: a more elegant solution is needed
483 st = av_mallocz(sizeof(AVStream));
484 memcpy(st, ic->streams[i], sizeof(AVStream));
485 st->codec = avcodec_alloc_context();
487 print_error(filename, AVERROR(ENOMEM));
490 memcpy(st->codec, ic->streams[i]->codec, sizeof(AVCodecContext));
493 if (st->codec->codec_type == CODEC_TYPE_AUDIO && audio_stream_copy)
495 else if (st->codec->codec_type == CODEC_TYPE_VIDEO && video_stream_copy)
498 if(!st->codec->thread_count)
499 st->codec->thread_count = 1;
500 if(st->codec->thread_count>1)
501 avcodec_thread_init(st->codec, st->codec->thread_count);
503 if(st->codec->flags & CODEC_FLAG_BITEXACT)
508 s->timestamp = av_gettime();
510 av_close_input_file(ic);
515 get_sync_ipts(const AVOutputStream *ost)
517 const AVInputStream *ist = ost->sync_ist;
518 return (double)(ist->pts - start_time)/AV_TIME_BASE;
521 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
525 AVPacket new_pkt= *pkt;
526 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
527 &new_pkt.data, &new_pkt.size,
528 pkt->data, pkt->size,
529 pkt->flags & PKT_FLAG_KEY);
532 new_pkt.destruct= av_destruct_packet;
534 fprintf(stderr, "%s failed for stream %d, codec %s",
535 bsfc->filter->name, pkt->stream_index,
536 avctx->codec ? avctx->codec->name : "copy");
546 ret= av_interleaved_write_frame(s, pkt);
548 print_error("av_interleaved_write_frame()", ret);
553 #define MAX_AUDIO_PACKET_SIZE (128 * 1024)
555 static void do_audio_out(AVFormatContext *s,
558 unsigned char *buf, int size)
561 int64_t audio_out_size, audio_buf_size;
563 int size_out, frame_bytes, ret;
564 AVCodecContext *enc= ost->st->codec;
565 AVCodecContext *dec= ist->st->codec;
566 int osize= av_get_bits_per_sample_format(enc->sample_fmt)/8;
567 int isize= av_get_bits_per_sample_format(dec->sample_fmt)/8;
568 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
570 audio_buf_size= (size + isize*dec->channels - 1) / (isize*dec->channels);
571 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
572 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
573 audio_buf_size*= osize*enc->channels;
575 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
576 if(coded_bps > 8*osize)
577 audio_out_size= audio_out_size * coded_bps / (8*osize);
578 audio_out_size += FF_MIN_BUFFER_SIZE;
580 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
581 fprintf(stderr, "Buffer sizes too large\n");
585 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
586 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
587 if (!audio_buf || !audio_out){
588 fprintf(stderr, "Out of memory in do_audio_out\n");
592 if (enc->channels != dec->channels)
593 ost->audio_resample = 1;
595 if (ost->audio_resample && !ost->resample) {
596 if (dec->sample_fmt != SAMPLE_FMT_S16)
597 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
598 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
599 enc->sample_rate, dec->sample_rate,
600 enc->sample_fmt, dec->sample_fmt,
602 if (!ost->resample) {
603 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
604 dec->channels, dec->sample_rate,
605 enc->channels, enc->sample_rate);
610 #define MAKE_SFMT_PAIR(a,b) ((a)+SAMPLE_FMT_NB*(b))
611 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
612 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
613 if (ost->reformat_ctx)
614 av_audio_convert_free(ost->reformat_ctx);
615 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
616 dec->sample_fmt, 1, NULL, 0);
617 if (!ost->reformat_ctx) {
618 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
619 avcodec_get_sample_fmt_name(dec->sample_fmt),
620 avcodec_get_sample_fmt_name(enc->sample_fmt));
623 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
626 if(audio_sync_method){
627 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
628 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2);
629 double idelta= delta*ist->st->codec->sample_rate / enc->sample_rate;
630 int byte_delta= ((int)idelta)*2*ist->st->codec->channels;
632 //FIXME resample delay
633 if(fabs(delta) > 50){
634 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
636 byte_delta= FFMAX(byte_delta, -size);
640 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
645 static uint8_t *input_tmp= NULL;
646 input_tmp= av_realloc(input_tmp, byte_delta + size);
648 if(byte_delta + size <= MAX_AUDIO_PACKET_SIZE)
651 byte_delta= MAX_AUDIO_PACKET_SIZE - size;
653 memset(input_tmp, 0, byte_delta);
654 memcpy(input_tmp + byte_delta, buf, size);
658 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
660 }else if(audio_sync_method>1){
661 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
662 assert(ost->audio_resample);
664 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
665 // fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
666 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
670 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
671 - av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2); //FIXME wrong
673 if (ost->audio_resample) {
675 size_out = audio_resample(ost->resample,
676 (short *)buftmp, (short *)buf,
677 size / (ist->st->codec->channels * isize));
678 size_out = size_out * enc->channels * osize;
684 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
685 const void *ibuf[6]= {buftmp};
686 void *obuf[6]= {audio_buf};
687 int istride[6]= {isize};
688 int ostride[6]= {osize};
689 int len= size_out/istride[0];
690 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
691 printf("av_audio_convert() failed\n");
697 size_out = len*osize;
700 /* now encode as many frames as possible */
701 if (enc->frame_size > 1) {
702 /* output resampled raw samples */
703 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
704 fprintf(stderr, "av_fifo_realloc2() failed\n");
707 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
709 frame_bytes = enc->frame_size * osize * enc->channels;
711 while (av_fifo_size(ost->fifo) >= frame_bytes) {
713 av_init_packet(&pkt);
715 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
717 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
719 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
722 fprintf(stderr, "Audio encoding failed\n");
726 pkt.stream_index= ost->index;
729 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
730 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
731 pkt.flags |= PKT_FLAG_KEY;
732 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
734 ost->sync_opts += enc->frame_size;
738 av_init_packet(&pkt);
740 ost->sync_opts += size_out / (osize * enc->channels);
742 /* output a pcm frame */
743 /* determine the size of the coded buffer */
746 size_out = size_out*coded_bps/8;
748 if(size_out > audio_out_size){
749 fprintf(stderr, "Internal error, buffer size too small\n");
753 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
754 ret = avcodec_encode_audio(enc, audio_out, size_out,
757 fprintf(stderr, "Audio encoding failed\n");
761 pkt.stream_index= ost->index;
764 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
765 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
766 pkt.flags |= PKT_FLAG_KEY;
767 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
771 static void pre_process_video_frame(AVInputStream *ist, AVPicture *picture, void **bufp)
775 AVPicture picture_tmp;
778 dec = ist->st->codec;
780 /* deinterlace : must be done before any resize */
781 if (do_deinterlace) {
784 /* create temporary picture */
785 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
786 buf = av_malloc(size);
790 picture2 = &picture_tmp;
791 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
793 if(avpicture_deinterlace(picture2, picture,
794 dec->pix_fmt, dec->width, dec->height) < 0) {
795 /* if error, do not deinterlace */
796 fprintf(stderr, "Deinterlacing failed\n");
805 if (picture != picture2)
806 *picture = *picture2;
810 /* we begin to correct av delay at this threshold */
811 #define AV_DELAY_MAX 0.100
813 static void do_subtitle_out(AVFormatContext *s,
819 static uint8_t *subtitle_out = NULL;
820 int subtitle_out_max_size = 1024 * 1024;
821 int subtitle_out_size, nb, i;
825 if (pts == AV_NOPTS_VALUE) {
826 fprintf(stderr, "Subtitle packets must have a pts\n");
832 enc = ost->st->codec;
835 subtitle_out = av_malloc(subtitle_out_max_size);
838 /* Note: DVB subtitle need one packet to draw them and one other
839 packet to clear them */
840 /* XXX: signal it in the codec context ? */
841 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
846 for(i = 0; i < nb; i++) {
847 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
848 // start_display_time is required to be 0
849 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
850 sub->end_display_time -= sub->start_display_time;
851 sub->start_display_time = 0;
852 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
853 subtitle_out_max_size, sub);
854 if (subtitle_out_size < 0) {
855 fprintf(stderr, "Subtitle encoding failed\n");
859 av_init_packet(&pkt);
860 pkt.stream_index = ost->index;
861 pkt.data = subtitle_out;
862 pkt.size = subtitle_out_size;
863 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
864 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
865 /* XXX: the pts correction is handled here. Maybe handling
866 it in the codec would be better */
868 pkt.pts += 90 * sub->start_display_time;
870 pkt.pts += 90 * sub->end_display_time;
872 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
876 static int bit_buffer_size= 1024*256;
877 static uint8_t *bit_buffer= NULL;
879 static void do_video_out(AVFormatContext *s,
885 int nb_frames, i, ret;
886 int64_t topBand, bottomBand, leftBand, rightBand;
887 AVFrame *final_picture, *formatted_picture, *resampling_dst, *padding_src;
888 AVFrame picture_crop_temp, picture_pad_temp;
889 AVCodecContext *enc, *dec;
891 avcodec_get_frame_defaults(&picture_crop_temp);
892 avcodec_get_frame_defaults(&picture_pad_temp);
894 enc = ost->st->codec;
895 dec = ist->st->codec;
897 /* by default, we output a single frame */
902 if(video_sync_method){
904 vdelta = get_sync_ipts(ost) / av_q2d(enc->time_base) - ost->sync_opts;
905 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
908 else if (video_sync_method == 2 || (video_sync_method<0 && (s->oformat->flags & AVFMT_VARIABLE_FPS))){
912 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
913 }else if (vdelta > 1.1)
914 nb_frames = lrintf(vdelta);
915 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
919 fprintf(stderr, "*** drop!\n");
920 }else if (nb_frames > 1) {
921 nb_frames_dup += nb_frames - 1;
923 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
926 ost->sync_opts= lrintf(get_sync_ipts(ost) / av_q2d(enc->time_base));
928 nb_frames= FFMIN(nb_frames, max_frames[CODEC_TYPE_VIDEO] - ost->frame_number);
932 if (ost->video_crop) {
933 if (av_picture_crop((AVPicture *)&picture_crop_temp, (AVPicture *)in_picture, dec->pix_fmt, ost->topBand, ost->leftBand) < 0) {
934 fprintf(stderr, "error cropping picture\n");
939 formatted_picture = &picture_crop_temp;
941 formatted_picture = in_picture;
944 final_picture = formatted_picture;
945 padding_src = formatted_picture;
946 resampling_dst = &ost->pict_tmp;
947 if (ost->video_pad) {
948 final_picture = &ost->pict_tmp;
949 if (ost->video_resample) {
950 if (av_picture_crop((AVPicture *)&picture_pad_temp, (AVPicture *)final_picture, enc->pix_fmt, ost->padtop, ost->padleft) < 0) {
951 fprintf(stderr, "error padding picture\n");
956 resampling_dst = &picture_pad_temp;
960 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
961 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
962 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
964 fprintf(stderr,"Input Stream #%d.%d frame size changed to %dx%d, %s\n", ist->file_index, ist->index, ist->st->codec->width, ist->st->codec->height,avcodec_get_pix_fmt_name(ist->st->codec->pix_fmt));
965 if(!ost->video_resample)
969 if (ost->video_resample) {
971 final_picture = &ost->pict_tmp;
972 if( (ost->resample_height != (ist->st->codec->height - (ost->topBand + ost->bottomBand)))
973 || (ost->resample_width != (ist->st->codec->width - (ost->leftBand + ost->rightBand)))
974 || (ost->resample_pix_fmt!= ist->st->codec->pix_fmt) ) {
976 /* keep bands proportional to the frame size */
977 topBand = ((int64_t)ist->st->codec->height * ost->original_topBand / ost->original_height) & ~1;
978 bottomBand = ((int64_t)ist->st->codec->height * ost->original_bottomBand / ost->original_height) & ~1;
979 leftBand = ((int64_t)ist->st->codec->width * ost->original_leftBand / ost->original_width) & ~1;
980 rightBand = ((int64_t)ist->st->codec->width * ost->original_rightBand / ost->original_width) & ~1;
982 /* sanity check to ensure no bad band sizes sneak in */
983 assert(topBand <= INT_MAX && topBand >= 0);
984 assert(bottomBand <= INT_MAX && bottomBand >= 0);
985 assert(leftBand <= INT_MAX && leftBand >= 0);
986 assert(rightBand <= INT_MAX && rightBand >= 0);
988 ost->topBand = topBand;
989 ost->bottomBand = bottomBand;
990 ost->leftBand = leftBand;
991 ost->rightBand = rightBand;
993 ost->resample_height = ist->st->codec->height - (ost->topBand + ost->bottomBand);
994 ost->resample_width = ist->st->codec->width - (ost->leftBand + ost->rightBand);
995 ost->resample_pix_fmt= ist->st->codec->pix_fmt;
997 /* initialize a new scaler context */
998 sws_freeContext(ost->img_resample_ctx);
999 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1000 ost->img_resample_ctx = sws_getContext(
1001 ist->st->codec->width - (ost->leftBand + ost->rightBand),
1002 ist->st->codec->height - (ost->topBand + ost->bottomBand),
1003 ist->st->codec->pix_fmt,
1004 ost->st->codec->width - (ost->padleft + ost->padright),
1005 ost->st->codec->height - (ost->padtop + ost->padbottom),
1006 ost->st->codec->pix_fmt,
1007 sws_flags, NULL, NULL, NULL);
1008 if (ost->img_resample_ctx == NULL) {
1009 fprintf(stderr, "Cannot get resampling context\n");
1013 sws_scale(ost->img_resample_ctx, formatted_picture->data, formatted_picture->linesize,
1014 0, ost->resample_height, resampling_dst->data, resampling_dst->linesize);
1017 if (ost->video_pad) {
1018 av_picture_pad((AVPicture*)final_picture, (AVPicture *)padding_src,
1019 enc->height, enc->width, enc->pix_fmt,
1020 ost->padtop, ost->padbottom, ost->padleft, ost->padright, padcolor);
1023 /* duplicates frame if needed */
1024 for(i=0;i<nb_frames;i++) {
1026 av_init_packet(&pkt);
1027 pkt.stream_index= ost->index;
1029 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1030 /* raw pictures are written as AVPicture structure to
1031 avoid any copies. We support temorarily the older
1033 AVFrame* old_frame = enc->coded_frame;
1034 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1035 pkt.data= (uint8_t *)final_picture;
1036 pkt.size= sizeof(AVPicture);
1037 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1038 pkt.flags |= PKT_FLAG_KEY;
1040 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1041 enc->coded_frame = old_frame;
1043 AVFrame big_picture;
1045 big_picture= *final_picture;
1046 /* better than nothing: use input picture interlaced
1048 big_picture.interlaced_frame = in_picture->interlaced_frame;
1049 if(avcodec_opts[CODEC_TYPE_VIDEO]->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)){
1050 if(top_field_first == -1)
1051 big_picture.top_field_first = in_picture->top_field_first;
1053 big_picture.top_field_first = top_field_first;
1056 /* handles sameq here. This is not correct because it may
1057 not be a global option */
1059 big_picture.quality = ist->st->quality;
1061 big_picture.quality = ost->st->quality;
1063 big_picture.pict_type = 0;
1064 // big_picture.pts = AV_NOPTS_VALUE;
1065 big_picture.pts= ost->sync_opts;
1066 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1067 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1068 ret = avcodec_encode_video(enc,
1069 bit_buffer, bit_buffer_size,
1072 fprintf(stderr, "Video encoding failed\n");
1077 pkt.data= bit_buffer;
1079 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1080 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1081 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1082 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1083 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1085 if(enc->coded_frame->key_frame)
1086 pkt.flags |= PKT_FLAG_KEY;
1087 write_frame(s, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1090 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1091 // enc->frame_number-1, ret, enc->pict_type);
1092 /* if two pass, output log */
1093 if (ost->logfile && enc->stats_out) {
1094 fprintf(ost->logfile, "%s", enc->stats_out);
1099 ost->frame_number++;
1103 static double psnr(double d){
1104 return -10.0*log(d)/log(10.0);
1107 static void do_video_stats(AVFormatContext *os, AVOutputStream *ost,
1110 AVCodecContext *enc;
1112 double ti1, bitrate, avg_bitrate;
1114 /* this is executed just the first time do_video_stats is called */
1116 vstats_file = fopen(vstats_filename, "w");
1123 enc = ost->st->codec;
1124 if (enc->codec_type == CODEC_TYPE_VIDEO) {
1125 frame_number = ost->frame_number;
1126 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1127 if (enc->flags&CODEC_FLAG_PSNR)
1128 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1130 fprintf(vstats_file,"f_size= %6d ", frame_size);
1131 /* compute pts value */
1132 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1136 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1137 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1138 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1139 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1140 fprintf(vstats_file,"type= %c\n", av_get_pict_type_char(enc->coded_frame->pict_type));
1144 static void print_report(AVFormatContext **output_files,
1145 AVOutputStream **ost_table, int nb_ostreams,
1149 AVOutputStream *ost;
1150 AVFormatContext *oc;
1152 AVCodecContext *enc;
1153 int frame_number, vid, i;
1154 double bitrate, ti1, pts;
1155 static int64_t last_time = -1;
1156 static int qp_histogram[52];
1158 if (!is_last_report) {
1160 /* display the report every 0.5 seconds */
1161 cur_time = av_gettime();
1162 if (last_time == -1) {
1163 last_time = cur_time;
1166 if ((cur_time - last_time) < 500000)
1168 last_time = cur_time;
1172 oc = output_files[0];
1174 total_size = url_fsize(oc->pb);
1175 if(total_size<0) // FIXME improve url_fsize() so it works with non seekable output too
1176 total_size= url_ftell(oc->pb);
1181 for(i=0;i<nb_ostreams;i++) {
1183 enc = ost->st->codec;
1184 if (vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1185 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ",
1186 !ost->st->stream_copy ?
1187 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1189 if (!vid && enc->codec_type == CODEC_TYPE_VIDEO) {
1190 float t = (av_gettime()-timer_start) / 1000000.0;
1192 frame_number = ost->frame_number;
1193 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1194 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0,
1195 !ost->st->stream_copy ?
1196 enc->coded_frame->quality/(float)FF_QP2LAMBDA : -1);
1198 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1201 int qp= lrintf(enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1202 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1205 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1207 if (enc->flags&CODEC_FLAG_PSNR){
1209 double error, error_sum=0;
1210 double scale, scale_sum=0;
1211 char type[3]= {'Y','U','V'};
1212 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1215 error= enc->error[j];
1216 scale= enc->width*enc->height*255.0*255.0*frame_number;
1218 error= enc->coded_frame->error[j];
1219 scale= enc->width*enc->height*255.0*255.0;
1224 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1226 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1230 /* compute min output value */
1231 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1232 if ((pts < ti1) && (pts > 0))
1238 if (verbose || is_last_report) {
1239 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1241 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1242 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1243 (double)total_size / 1024, ti1, bitrate);
1245 if (nb_frames_dup || nb_frames_drop)
1246 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1247 nb_frames_dup, nb_frames_drop);
1250 fprintf(stderr, "%s \r", buf);
1255 if (is_last_report && verbose >= 0){
1256 int64_t raw= audio_size + video_size + extra_size;
1257 fprintf(stderr, "\n");
1258 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1262 100.0*(total_size - raw)/raw
1267 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1268 static int output_packet(AVInputStream *ist, int ist_index,
1269 AVOutputStream **ost_table, int nb_ostreams,
1270 const AVPacket *pkt)
1272 AVFormatContext *os;
1273 AVOutputStream *ost;
1277 void *buffer_to_free;
1278 static unsigned int samples_size= 0;
1279 AVSubtitle subtitle, *subtitle_to_free;
1282 int bps = av_get_bits_per_sample_format(ist->st->codec->sample_fmt)>>3;
1284 if(ist->next_pts == AV_NOPTS_VALUE)
1285 ist->next_pts= ist->pts;
1289 av_init_packet(&avpkt);
1297 if(pkt->dts != AV_NOPTS_VALUE)
1298 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1300 //while we have more to decode or while the decoder did output something on EOF
1301 while (avpkt.size > 0 || (!pkt && ist->next_pts != ist->pts)) {
1305 ist->pts= ist->next_pts;
1307 if(avpkt.size && avpkt.size != pkt->size &&
1308 !(ist->st->codec->codec->capabilities & CODEC_CAP_SUBFRAMES) && verbose>0)
1309 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1311 /* decode the packet if needed */
1312 data_buf = NULL; /* fail safe */
1314 subtitle_to_free = NULL;
1315 if (ist->decoding_needed) {
1316 switch(ist->st->codec->codec_type) {
1317 case CODEC_TYPE_AUDIO:{
1318 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1319 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1321 samples= av_malloc(samples_size);
1323 data_size= samples_size;
1324 /* XXX: could avoid copy if PCM 16 bits with same
1325 endianness as CPU */
1326 ret = avcodec_decode_audio3(ist->st->codec, samples, &data_size,
1332 /* Some bug in mpeg audio decoder gives */
1333 /* data_size < 0, it seems they are overflows */
1334 if (data_size <= 0) {
1335 /* no audio frame */
1338 data_buf = (uint8_t *)samples;
1339 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * data_size) /
1340 (ist->st->codec->sample_rate * ist->st->codec->channels);
1342 case CODEC_TYPE_VIDEO:
1343 data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1344 /* XXX: allocate picture correctly */
1345 avcodec_get_frame_defaults(&picture);
1347 ret = avcodec_decode_video2(ist->st->codec,
1348 &picture, &got_picture, &avpkt);
1349 ist->st->quality= picture.quality;
1353 /* no picture yet */
1354 goto discard_packet;
1356 if (ist->st->codec->time_base.num != 0) {
1357 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1358 ist->next_pts += ((int64_t)AV_TIME_BASE *
1359 ist->st->codec->time_base.num * ticks) /
1360 ist->st->codec->time_base.den;
1364 case CODEC_TYPE_SUBTITLE:
1365 ret = avcodec_decode_subtitle2(ist->st->codec,
1366 &subtitle, &got_subtitle, &avpkt);
1369 if (!got_subtitle) {
1370 goto discard_packet;
1372 subtitle_to_free = &subtitle;
1379 switch(ist->st->codec->codec_type) {
1380 case CODEC_TYPE_AUDIO:
1381 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1382 ist->st->codec->sample_rate;
1384 case CODEC_TYPE_VIDEO:
1385 if (ist->st->codec->time_base.num != 0) {
1386 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1387 ist->next_pts += ((int64_t)AV_TIME_BASE *
1388 ist->st->codec->time_base.num * ticks) /
1389 ist->st->codec->time_base.den;
1393 data_buf = avpkt.data;
1394 data_size = avpkt.size;
1399 buffer_to_free = NULL;
1400 if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1401 pre_process_video_frame(ist, (AVPicture *)&picture,
1405 // preprocess audio (volume)
1406 if (ist->st->codec->codec_type == CODEC_TYPE_AUDIO) {
1407 if (audio_volume != 256) {
1410 for(i=0;i<(data_size / sizeof(short));i++) {
1411 int v = ((*volp) * audio_volume + 128) >> 8;
1412 if (v < -32768) v = -32768;
1413 if (v > 32767) v = 32767;
1419 /* frame rate emulation */
1421 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1422 int64_t now = av_gettime() - ist->start;
1427 /* if output time reached then transcode raw format,
1428 encode packets and output them */
1429 if (start_time == 0 || ist->pts >= start_time)
1430 for(i=0;i<nb_ostreams;i++) {
1434 if (ost->source_index == ist_index) {
1435 os = output_files[ost->file_index];
1437 /* set the input output pts pairs */
1438 //ost->sync_ipts = (double)(ist->pts + input_files_ts_offset[ist->file_index] - start_time)/ AV_TIME_BASE;
1440 if (ost->encoding_needed) {
1441 switch(ost->st->codec->codec_type) {
1442 case CODEC_TYPE_AUDIO:
1443 do_audio_out(os, ost, ist, data_buf, data_size);
1445 case CODEC_TYPE_VIDEO:
1446 do_video_out(os, ost, ist, &picture, &frame_size);
1447 if (vstats_filename && frame_size)
1448 do_video_stats(os, ost, frame_size);
1450 case CODEC_TYPE_SUBTITLE:
1451 do_subtitle_out(os, ost, ist, &subtitle,
1458 AVFrame avframe; //FIXME/XXX remove this
1460 int64_t ost_tb_start_time= av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
1462 av_init_packet(&opkt);
1464 if ((!ost->frame_number && !(pkt->flags & PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1467 /* no reencoding needed : output the packet directly */
1468 /* force the input stream PTS */
1470 avcodec_get_frame_defaults(&avframe);
1471 ost->st->codec->coded_frame= &avframe;
1472 avframe.key_frame = pkt->flags & PKT_FLAG_KEY;
1474 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO)
1475 audio_size += data_size;
1476 else if (ost->st->codec->codec_type == CODEC_TYPE_VIDEO) {
1477 video_size += data_size;
1481 opkt.stream_index= ost->index;
1482 if(pkt->pts != AV_NOPTS_VALUE)
1483 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1485 opkt.pts= AV_NOPTS_VALUE;
1487 if (pkt->dts == AV_NOPTS_VALUE)
1488 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1490 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1491 opkt.dts -= ost_tb_start_time;
1493 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1494 opkt.flags= pkt->flags;
1496 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1497 if(ost->st->codec->codec_id != CODEC_ID_H264) {
1498 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & PKT_FLAG_KEY))
1499 opkt.destruct= av_destruct_packet;
1501 opkt.data = data_buf;
1502 opkt.size = data_size;
1505 write_frame(os, &opkt, ost->st->codec, bitstream_filters[ost->file_index][opkt.stream_index]);
1506 ost->st->codec->frame_number++;
1507 ost->frame_number++;
1508 av_free_packet(&opkt);
1512 av_free(buffer_to_free);
1513 /* XXX: allocate the subtitles in the codec ? */
1514 if (subtitle_to_free) {
1515 if (subtitle_to_free->rects != NULL) {
1516 for (i = 0; i < subtitle_to_free->num_rects; i++) {
1517 av_freep(&subtitle_to_free->rects[i]->pict.data[0]);
1518 av_freep(&subtitle_to_free->rects[i]->pict.data[1]);
1519 av_freep(&subtitle_to_free->rects[i]);
1521 av_freep(&subtitle_to_free->rects);
1523 subtitle_to_free->num_rects = 0;
1524 subtitle_to_free = NULL;
1531 for(i=0;i<nb_ostreams;i++) {
1533 if (ost->source_index == ist_index) {
1534 AVCodecContext *enc= ost->st->codec;
1535 os = output_files[ost->file_index];
1537 if(ost->st->codec->codec_type == CODEC_TYPE_AUDIO && enc->frame_size <=1)
1539 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1542 if (ost->encoding_needed) {
1546 av_init_packet(&pkt);
1547 pkt.stream_index= ost->index;
1549 switch(ost->st->codec->codec_type) {
1550 case CODEC_TYPE_AUDIO:
1551 fifo_bytes = av_fifo_size(ost->fifo);
1553 /* encode any samples remaining in fifo */
1554 if (fifo_bytes > 0) {
1555 int osize = av_get_bits_per_sample_format(enc->sample_fmt) >> 3;
1556 int fs_tmp = enc->frame_size;
1558 av_fifo_generic_read(ost->fifo, samples, fifo_bytes, NULL);
1559 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1560 enc->frame_size = fifo_bytes / (osize * enc->channels);
1562 int frame_bytes = enc->frame_size*osize*enc->channels;
1563 if (samples_size < frame_bytes)
1565 memset((uint8_t*)samples+fifo_bytes, 0, frame_bytes - fifo_bytes);
1568 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, samples);
1569 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1570 ost->st->time_base.num, enc->sample_rate);
1571 enc->frame_size = fs_tmp;
1574 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1577 fprintf(stderr, "Audio encoding failed\n");
1581 pkt.flags |= PKT_FLAG_KEY;
1583 case CODEC_TYPE_VIDEO:
1584 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1586 fprintf(stderr, "Video encoding failed\n");
1590 if(enc->coded_frame && enc->coded_frame->key_frame)
1591 pkt.flags |= PKT_FLAG_KEY;
1592 if (ost->logfile && enc->stats_out) {
1593 fprintf(ost->logfile, "%s", enc->stats_out);
1602 pkt.data= bit_buffer;
1604 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1605 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1606 write_frame(os, &pkt, ost->st->codec, bitstream_filters[ost->file_index][pkt.stream_index]);
1618 static void print_sdp(AVFormatContext **avc, int n)
1622 avf_sdp_create(avc, n, sdp, sizeof(sdp));
1623 printf("SDP:\n%s\n", sdp);
1627 static int stream_index_from_inputs(AVFormatContext **input_files,
1629 AVInputFile *file_table,
1630 AVInputStream **ist_table,
1631 enum CodecType type,
1635 for(z=0; z<nb_input_files; z++) {
1636 AVFormatContext *ic = input_files[z];
1637 for(p=0; p<ic->nb_programs; p++) {
1638 AVProgram *program = ic->programs[p];
1639 if(program->id != programid)
1641 for(q=0; q<program->nb_stream_indexes; q++) {
1642 int sidx = program->stream_index[q];
1643 int ris = file_table[z].ist_index + sidx;
1644 if(ist_table[ris]->discard && ic->streams[sidx]->codec->codec_type == type)
1654 * The following code is the main loop of the file converter
1656 static int av_encode(AVFormatContext **output_files,
1657 int nb_output_files,
1658 AVFormatContext **input_files,
1660 AVStreamMap *stream_maps, int nb_stream_maps)
1662 int ret = 0, i, j, k, n, nb_istreams = 0, nb_ostreams = 0;
1663 AVFormatContext *is, *os;
1664 AVCodecContext *codec, *icodec;
1665 AVOutputStream *ost, **ost_table = NULL;
1666 AVInputStream *ist, **ist_table = NULL;
1667 AVInputFile *file_table;
1671 uint8_t no_packet[MAX_FILES]={0};
1672 int no_packet_count=0;
1674 file_table= av_mallocz(nb_input_files * sizeof(AVInputFile));
1678 /* input stream init */
1680 for(i=0;i<nb_input_files;i++) {
1681 is = input_files[i];
1682 file_table[i].ist_index = j;
1683 file_table[i].nb_streams = is->nb_streams;
1684 j += is->nb_streams;
1688 ist_table = av_mallocz(nb_istreams * sizeof(AVInputStream *));
1692 for(i=0;i<nb_istreams;i++) {
1693 ist = av_mallocz(sizeof(AVInputStream));
1699 for(i=0;i<nb_input_files;i++) {
1700 is = input_files[i];
1701 for(k=0;k<is->nb_streams;k++) {
1702 ist = ist_table[j++];
1703 ist->st = is->streams[k];
1704 ist->file_index = i;
1706 ist->discard = 1; /* the stream is discarded by default
1710 ist->start = av_gettime();
1715 /* output stream init */
1717 for(i=0;i<nb_output_files;i++) {
1718 os = output_files[i];
1719 if (!os->nb_streams) {
1720 dump_format(output_files[i], i, output_files[i]->filename, 1);
1721 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1724 nb_ostreams += os->nb_streams;
1726 if (nb_stream_maps > 0 && nb_stream_maps != nb_ostreams) {
1727 fprintf(stderr, "Number of stream maps must match number of output streams\n");
1731 /* Sanity check the mapping args -- do the input files & streams exist? */
1732 for(i=0;i<nb_stream_maps;i++) {
1733 int fi = stream_maps[i].file_index;
1734 int si = stream_maps[i].stream_index;
1736 if (fi < 0 || fi > nb_input_files - 1 ||
1737 si < 0 || si > file_table[fi].nb_streams - 1) {
1738 fprintf(stderr,"Could not find input stream #%d.%d\n", fi, si);
1741 fi = stream_maps[i].sync_file_index;
1742 si = stream_maps[i].sync_stream_index;
1743 if (fi < 0 || fi > nb_input_files - 1 ||
1744 si < 0 || si > file_table[fi].nb_streams - 1) {
1745 fprintf(stderr,"Could not find sync stream #%d.%d\n", fi, si);
1750 ost_table = av_mallocz(sizeof(AVOutputStream *) * nb_ostreams);
1753 for(i=0;i<nb_ostreams;i++) {
1754 ost = av_mallocz(sizeof(AVOutputStream));
1761 for(k=0;k<nb_output_files;k++) {
1762 os = output_files[k];
1763 for(i=0;i<os->nb_streams;i++,n++) {
1766 ost->file_index = k;
1768 ost->st = os->streams[i];
1769 if (nb_stream_maps > 0) {
1770 ost->source_index = file_table[stream_maps[n].file_index].ist_index +
1771 stream_maps[n].stream_index;
1773 /* Sanity check that the stream types match */
1774 if (ist_table[ost->source_index]->st->codec->codec_type != ost->st->codec->codec_type) {
1775 int i= ost->file_index;
1776 dump_format(output_files[i], i, output_files[i]->filename, 1);
1777 fprintf(stderr, "Codec type mismatch for mapping #%d.%d -> #%d.%d\n",
1778 stream_maps[n].file_index, stream_maps[n].stream_index,
1779 ost->file_index, ost->index);
1786 j = stream_index_from_inputs(input_files, nb_input_files, file_table, ist_table, ost->st->codec->codec_type, opt_programid);
1788 ost->source_index = j;
1792 /* get corresponding input stream index : we select the first one with the right type */
1794 for(j=0;j<nb_istreams;j++) {
1797 ist->st->codec->codec_type == ost->st->codec->codec_type) {
1798 ost->source_index = j;
1806 if(! opt_programid) {
1807 /* try again and reuse existing stream */
1808 for(j=0;j<nb_istreams;j++) {
1810 if (ist->st->codec->codec_type == ost->st->codec->codec_type) {
1811 ost->source_index = j;
1817 int i= ost->file_index;
1818 dump_format(output_files[i], i, output_files[i]->filename, 1);
1819 fprintf(stderr, "Could not find input stream matching output stream #%d.%d\n",
1820 ost->file_index, ost->index);
1825 ist = ist_table[ost->source_index];
1827 ost->sync_ist = (nb_stream_maps > 0) ?
1828 ist_table[file_table[stream_maps[n].sync_file_index].ist_index +
1829 stream_maps[n].sync_stream_index] : ist;
1833 /* for each output stream, we compute the right encoding parameters */
1834 for(i=0;i<nb_ostreams;i++) {
1835 AVMetadataTag *lang;
1837 os = output_files[ost->file_index];
1838 ist = ist_table[ost->source_index];
1840 codec = ost->st->codec;
1841 icodec = ist->st->codec;
1843 if ((lang=av_metadata_get(ist->st->metadata, "language", NULL, 0))
1844 && !av_metadata_get(ost->st->metadata, "language", NULL, 0))
1845 av_metadata_set(&ost->st->metadata, "language", lang->value);
1847 ost->st->disposition = ist->st->disposition;
1848 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1849 codec->chroma_sample_location = icodec->chroma_sample_location;
1851 if (ost->st->stream_copy) {
1852 /* if stream_copy is selected, no need to decode or encode */
1853 codec->codec_id = icodec->codec_id;
1854 codec->codec_type = icodec->codec_type;
1856 if(!codec->codec_tag){
1857 if( !os->oformat->codec_tag
1858 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1859 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1860 codec->codec_tag = icodec->codec_tag;
1863 codec->bit_rate = icodec->bit_rate;
1864 codec->extradata= icodec->extradata;
1865 codec->extradata_size= icodec->extradata_size;
1866 if(av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/1000){
1867 codec->time_base = icodec->time_base;
1868 codec->time_base.num *= icodec->ticks_per_frame;
1870 codec->time_base = ist->st->time_base;
1871 switch(codec->codec_type) {
1872 case CODEC_TYPE_AUDIO:
1873 if(audio_volume != 256) {
1874 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1877 codec->channel_layout = icodec->channel_layout;
1878 codec->sample_rate = icodec->sample_rate;
1879 codec->channels = icodec->channels;
1880 codec->frame_size = icodec->frame_size;
1881 codec->block_align= icodec->block_align;
1882 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1883 codec->block_align= 0;
1884 if(codec->codec_id == CODEC_ID_AC3)
1885 codec->block_align= 0;
1887 case CODEC_TYPE_VIDEO:
1888 codec->pix_fmt = icodec->pix_fmt;
1889 codec->width = icodec->width;
1890 codec->height = icodec->height;
1891 codec->has_b_frames = icodec->has_b_frames;
1893 case CODEC_TYPE_SUBTITLE:
1894 codec->width = icodec->width;
1895 codec->height = icodec->height;
1901 switch(codec->codec_type) {
1902 case CODEC_TYPE_AUDIO:
1903 ost->fifo= av_fifo_alloc(1024);
1906 ost->reformat_pair = MAKE_SFMT_PAIR(SAMPLE_FMT_NONE,SAMPLE_FMT_NONE);
1907 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1908 icodec->request_channels = codec->channels;
1909 ist->decoding_needed = 1;
1910 ost->encoding_needed = 1;
1912 case CODEC_TYPE_VIDEO:
1913 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1914 fprintf(stderr, "Video pixel format is unknown, stream cannot be decoded\n");
1917 ost->video_crop = ((frame_leftBand + frame_rightBand + frame_topBand + frame_bottomBand) != 0);
1918 ost->video_pad = ((frame_padleft + frame_padright + frame_padtop + frame_padbottom) != 0);
1919 ost->video_resample = ((codec->width != icodec->width -
1920 (frame_leftBand + frame_rightBand) +
1921 (frame_padleft + frame_padright)) ||
1922 (codec->height != icodec->height -
1923 (frame_topBand + frame_bottomBand) +
1924 (frame_padtop + frame_padbottom)) ||
1925 (codec->pix_fmt != icodec->pix_fmt));
1926 if (ost->video_crop) {
1927 ost->topBand = ost->original_topBand = frame_topBand;
1928 ost->bottomBand = ost->original_bottomBand = frame_bottomBand;
1929 ost->leftBand = ost->original_leftBand = frame_leftBand;
1930 ost->rightBand = ost->original_rightBand = frame_rightBand;
1932 if (ost->video_pad) {
1933 ost->padtop = frame_padtop;
1934 ost->padleft = frame_padleft;
1935 ost->padbottom = frame_padbottom;
1936 ost->padright = frame_padright;
1937 if (!ost->video_resample) {
1938 avcodec_get_frame_defaults(&ost->pict_tmp);
1939 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1940 codec->width, codec->height))
1944 if (ost->video_resample) {
1945 avcodec_get_frame_defaults(&ost->pict_tmp);
1946 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
1947 codec->width, codec->height)) {
1948 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1951 sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
1952 ost->img_resample_ctx = sws_getContext(
1953 icodec->width - (frame_leftBand + frame_rightBand),
1954 icodec->height - (frame_topBand + frame_bottomBand),
1956 codec->width - (frame_padleft + frame_padright),
1957 codec->height - (frame_padtop + frame_padbottom),
1959 sws_flags, NULL, NULL, NULL);
1960 if (ost->img_resample_ctx == NULL) {
1961 fprintf(stderr, "Cannot get resampling context\n");
1965 ost->original_height = icodec->height;
1966 ost->original_width = icodec->width;
1968 codec->bits_per_raw_sample= 0;
1970 ost->resample_height = icodec->height - (frame_topBand + frame_bottomBand);
1971 ost->resample_width = icodec->width - (frame_leftBand + frame_rightBand);
1972 ost->resample_pix_fmt= icodec->pix_fmt;
1973 ost->encoding_needed = 1;
1974 ist->decoding_needed = 1;
1976 case CODEC_TYPE_SUBTITLE:
1977 ost->encoding_needed = 1;
1978 ist->decoding_needed = 1;
1985 if (ost->encoding_needed &&
1986 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1987 char logfilename[1024];
1992 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1993 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
1995 if (codec->flags & CODEC_FLAG_PASS1) {
1996 f = fopen(logfilename, "w");
1998 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2003 /* read the log file */
2004 f = fopen(logfilename, "r");
2006 fprintf(stderr, "Cannot read log file '%s' for pass-2 encoding: %s\n", logfilename, strerror(errno));
2009 fseek(f, 0, SEEK_END);
2011 fseek(f, 0, SEEK_SET);
2012 logbuffer = av_malloc(size + 1);
2014 fprintf(stderr, "Could not allocate log buffer\n");
2017 size = fread(logbuffer, 1, size, f);
2019 logbuffer[size] = '\0';
2020 codec->stats_in = logbuffer;
2024 if(codec->codec_type == CODEC_TYPE_VIDEO){
2025 int size= codec->width * codec->height;
2026 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2031 bit_buffer = av_malloc(bit_buffer_size);
2033 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2035 ret = AVERROR(ENOMEM);
2039 /* open each encoder */
2040 for(i=0;i<nb_ostreams;i++) {
2042 if (ost->encoding_needed) {
2043 AVCodec *codec = output_codecs[i];
2045 codec = avcodec_find_encoder(ost->st->codec->codec_id);
2047 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2048 ost->st->codec->codec_id, ost->file_index, ost->index);
2049 ret = AVERROR(EINVAL);
2052 if (avcodec_open(ost->st->codec, codec) < 0) {
2053 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2054 ost->file_index, ost->index);
2055 ret = AVERROR(EINVAL);
2058 extra_size += ost->st->codec->extradata_size;
2062 /* open each decoder */
2063 for(i=0;i<nb_istreams;i++) {
2065 if (ist->decoding_needed) {
2066 AVCodec *codec = input_codecs[i];
2068 codec = avcodec_find_decoder(ist->st->codec->codec_id);
2070 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
2071 ist->st->codec->codec_id, ist->file_index, ist->index);
2072 ret = AVERROR(EINVAL);
2075 if (avcodec_open(ist->st->codec, codec) < 0) {
2076 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
2077 ist->file_index, ist->index);
2078 ret = AVERROR(EINVAL);
2081 //if (ist->st->codec->codec_type == CODEC_TYPE_VIDEO)
2082 // ist->st->codec->flags |= CODEC_FLAG_REPEAT_FIELD;
2087 for(i=0;i<nb_istreams;i++) {
2090 ist->next_pts = AV_NOPTS_VALUE;
2094 /* set meta data information from input file if required */
2095 for (i=0;i<nb_meta_data_maps;i++) {
2096 AVFormatContext *out_file;
2097 AVFormatContext *in_file;
2098 AVMetadataTag *mtag;
2100 int out_file_index = meta_data_maps[i].out_file;
2101 int in_file_index = meta_data_maps[i].in_file;
2102 if (out_file_index < 0 || out_file_index >= nb_output_files) {
2103 snprintf(error, sizeof(error), "Invalid output file index %d map_meta_data(%d,%d)",
2104 out_file_index, out_file_index, in_file_index);
2105 ret = AVERROR(EINVAL);
2108 if (in_file_index < 0 || in_file_index >= nb_input_files) {
2109 snprintf(error, sizeof(error), "Invalid input file index %d map_meta_data(%d,%d)",
2110 in_file_index, out_file_index, in_file_index);
2111 ret = AVERROR(EINVAL);
2115 out_file = output_files[out_file_index];
2116 in_file = input_files[in_file_index];
2120 while((mtag=av_metadata_get(in_file->metadata, "", mtag, AV_METADATA_IGNORE_SUFFIX)))
2121 av_metadata_set(&out_file->metadata, mtag->key, mtag->value);
2122 av_metadata_conv(out_file, out_file->oformat->metadata_conv,
2123 in_file->iformat->metadata_conv);
2126 /* open files and write file headers */
2127 for(i=0;i<nb_output_files;i++) {
2128 os = output_files[i];
2129 if (av_write_header(os) < 0) {
2130 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2131 ret = AVERROR(EINVAL);
2134 if (strcmp(output_files[i]->oformat->name, "rtp")) {
2140 /* dump the file output parameters - cannot be done before in case
2142 for(i=0;i<nb_output_files;i++) {
2143 dump_format(output_files[i], i, output_files[i]->filename, 1);
2146 /* dump the stream mapping */
2148 fprintf(stderr, "Stream mapping:\n");
2149 for(i=0;i<nb_ostreams;i++) {
2151 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2152 ist_table[ost->source_index]->file_index,
2153 ist_table[ost->source_index]->index,
2156 if (ost->sync_ist != ist_table[ost->source_index])
2157 fprintf(stderr, " [sync #%d.%d]",
2158 ost->sync_ist->file_index,
2159 ost->sync_ist->index);
2160 fprintf(stderr, "\n");
2165 fprintf(stderr, "%s\n", error);
2170 print_sdp(output_files, nb_output_files);
2173 if (!using_stdin && verbose >= 0) {
2174 fprintf(stderr, "Press [q] to stop encoding\n");
2175 url_set_interrupt_cb(decode_interrupt_cb);
2179 timer_start = av_gettime();
2181 for(; received_sigterm == 0;) {
2182 int file_index, ist_index;
2190 /* if 'q' pressed, exits */
2194 /* read_key() returns 0 on EOF */
2200 /* select the stream that we must read now by looking at the
2201 smallest output pts */
2203 for(i=0;i<nb_ostreams;i++) {
2206 os = output_files[ost->file_index];
2207 ist = ist_table[ost->source_index];
2208 if(no_packet[ist->file_index])
2210 if(ost->st->codec->codec_type == CODEC_TYPE_VIDEO)
2211 opts = ost->sync_opts * av_q2d(ost->st->codec->time_base);
2213 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2214 ipts = (double)ist->pts;
2215 if (!file_table[ist->file_index].eof_reached){
2216 if(ipts < ipts_min) {
2218 if(input_sync ) file_index = ist->file_index;
2220 if(opts < opts_min) {
2222 if(!input_sync) file_index = ist->file_index;
2225 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2230 /* if none, if is finished */
2231 if (file_index < 0) {
2232 if(no_packet_count){
2234 memset(no_packet, 0, sizeof(no_packet));
2241 /* finish if recording time exhausted */
2242 if (opts_min >= (recording_time / 1000000.0))
2245 /* finish if limit size exhausted */
2246 if (limit_filesize != 0 && limit_filesize < url_ftell(output_files[0]->pb))
2249 /* read a frame from it and output it in the fifo */
2250 is = input_files[file_index];
2251 ret= av_read_frame(is, &pkt);
2252 if(ret == AVERROR(EAGAIN)){
2253 no_packet[file_index]=1;
2258 file_table[file_index].eof_reached = 1;
2266 memset(no_packet, 0, sizeof(no_packet));
2269 av_pkt_dump_log(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump);
2271 /* the following test is needed in case new streams appear
2272 dynamically in stream : we ignore them */
2273 if (pkt.stream_index >= file_table[file_index].nb_streams)
2274 goto discard_packet;
2275 ist_index = file_table[file_index].ist_index + pkt.stream_index;
2276 ist = ist_table[ist_index];
2278 goto discard_packet;
2280 if (pkt.dts != AV_NOPTS_VALUE)
2281 pkt.dts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2282 if (pkt.pts != AV_NOPTS_VALUE)
2283 pkt.pts += av_rescale_q(input_files_ts_offset[ist->file_index], AV_TIME_BASE_Q, ist->st->time_base);
2285 if(input_files_ts_scale[file_index][pkt.stream_index]){
2286 if(pkt.pts != AV_NOPTS_VALUE)
2287 pkt.pts *= input_files_ts_scale[file_index][pkt.stream_index];
2288 if(pkt.dts != AV_NOPTS_VALUE)
2289 pkt.dts *= input_files_ts_scale[file_index][pkt.stream_index];
2292 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files_ts_offset[ist->file_index], ist->st->codec->codec_type);
2293 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2294 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2295 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2296 int64_t delta= pkt_dts - ist->next_pts;
2297 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2298 input_files_ts_offset[ist->file_index]-= delta;
2300 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n", delta, input_files_ts_offset[ist->file_index]);
2301 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2302 if(pkt.pts != AV_NOPTS_VALUE)
2303 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2307 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->index, pkt.size);
2308 if (output_packet(ist, ist_index, ost_table, nb_ostreams, &pkt) < 0) {
2311 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2312 ist->file_index, ist->index);
2315 av_free_packet(&pkt);
2320 av_free_packet(&pkt);
2322 /* dump report by using the output first video and audio streams */
2323 print_report(output_files, ost_table, nb_ostreams, 0);
2326 /* at the end of stream, we must flush the decoder buffers */
2327 for(i=0;i<nb_istreams;i++) {
2329 if (ist->decoding_needed) {
2330 output_packet(ist, i, ost_table, nb_ostreams, NULL);
2336 /* write the trailer if needed and close file */
2337 for(i=0;i<nb_output_files;i++) {
2338 os = output_files[i];
2339 av_write_trailer(os);
2342 /* dump report by using the first video and audio streams */
2343 print_report(output_files, ost_table, nb_ostreams, 1);
2345 /* close each encoder */
2346 for(i=0;i<nb_ostreams;i++) {
2348 if (ost->encoding_needed) {
2349 av_freep(&ost->st->codec->stats_in);
2350 avcodec_close(ost->st->codec);
2354 /* close each decoder */
2355 for(i=0;i<nb_istreams;i++) {
2357 if (ist->decoding_needed) {
2358 avcodec_close(ist->st->codec);
2366 av_freep(&bit_buffer);
2367 av_free(file_table);
2370 for(i=0;i<nb_istreams;i++) {
2377 for(i=0;i<nb_ostreams;i++) {
2381 fclose(ost->logfile);
2382 ost->logfile = NULL;
2384 av_fifo_free(ost->fifo); /* works even if fifo is not
2385 initialized but set to zero */
2386 av_free(ost->pict_tmp.data[0]);
2387 if (ost->video_resample)
2388 sws_freeContext(ost->img_resample_ctx);
2390 audio_resample_close(ost->resample);
2391 if (ost->reformat_ctx)
2392 av_audio_convert_free(ost->reformat_ctx);
2401 static void opt_format(const char *arg)
2403 /* compatibility stuff for pgmyuv */
2404 if (!strcmp(arg, "pgmyuv")) {
2405 pgmyuv_compatibility_hack=1;
2406 // opt_image_format(arg);
2408 fprintf(stderr, "pgmyuv format is deprecated, use image2\n");
2411 last_asked_format = arg;
2414 static void opt_video_rc_override_string(const char *arg)
2416 video_rc_override_string = arg;
2419 static int opt_me_threshold(const char *opt, const char *arg)
2421 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2425 static int opt_verbose(const char *opt, const char *arg)
2427 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2431 static int opt_frame_rate(const char *opt, const char *arg)
2433 if (av_parse_video_frame_rate(&frame_rate, arg) < 0) {
2434 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2440 static int opt_bitrate(const char *opt, const char *arg)
2442 int codec_type = opt[0]=='a' ? CODEC_TYPE_AUDIO : CODEC_TYPE_VIDEO;
2444 opt_default(opt, arg);
2446 if (av_get_int(avcodec_opts[codec_type], "b", NULL) < 1000)
2447 fprintf(stderr, "WARNING: The bitrate parameter is set too low. It takes bits/s as argument, not kbits/s\n");
2452 static void opt_frame_crop_top(const char *arg)
2454 frame_topBand = atoi(arg);
2455 if (frame_topBand < 0) {
2456 fprintf(stderr, "Incorrect top crop size\n");
2459 if ((frame_topBand) >= frame_height){
2460 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2463 frame_height -= frame_topBand;
2466 static void opt_frame_crop_bottom(const char *arg)
2468 frame_bottomBand = atoi(arg);
2469 if (frame_bottomBand < 0) {
2470 fprintf(stderr, "Incorrect bottom crop size\n");
2473 if ((frame_bottomBand) >= frame_height){
2474 fprintf(stderr, "Vertical crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2477 frame_height -= frame_bottomBand;
2480 static void opt_frame_crop_left(const char *arg)
2482 frame_leftBand = atoi(arg);
2483 if (frame_leftBand < 0) {
2484 fprintf(stderr, "Incorrect left crop size\n");
2487 if ((frame_leftBand) >= frame_width){
2488 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2491 frame_width -= frame_leftBand;
2494 static void opt_frame_crop_right(const char *arg)
2496 frame_rightBand = atoi(arg);
2497 if (frame_rightBand < 0) {
2498 fprintf(stderr, "Incorrect right crop size\n");
2501 if ((frame_rightBand) >= frame_width){
2502 fprintf(stderr, "Horizontal crop dimensions are outside the range of the original image.\nRemember to crop first and scale second.\n");
2505 frame_width -= frame_rightBand;
2508 static void opt_frame_size(const char *arg)
2510 if (av_parse_video_frame_size(&frame_width, &frame_height, arg) < 0) {
2511 fprintf(stderr, "Incorrect frame size\n");
2516 static void opt_pad_color(const char *arg) {
2517 /* Input is expected to be six hex digits similar to
2518 how colors are expressed in html tags (but without the #) */
2519 int rgb = strtol(arg, NULL, 16);
2523 g = ((rgb >> 8) & 255);
2526 padcolor[0] = RGB_TO_Y(r,g,b);
2527 padcolor[1] = RGB_TO_U(r,g,b,0);
2528 padcolor[2] = RGB_TO_V(r,g,b,0);
2531 static void opt_frame_pad_top(const char *arg)
2533 frame_padtop = atoi(arg);
2534 if (frame_padtop < 0) {
2535 fprintf(stderr, "Incorrect top pad size\n");
2540 static void opt_frame_pad_bottom(const char *arg)
2542 frame_padbottom = atoi(arg);
2543 if (frame_padbottom < 0) {
2544 fprintf(stderr, "Incorrect bottom pad size\n");
2550 static void opt_frame_pad_left(const char *arg)
2552 frame_padleft = atoi(arg);
2553 if (frame_padleft < 0) {
2554 fprintf(stderr, "Incorrect left pad size\n");
2560 static void opt_frame_pad_right(const char *arg)
2562 frame_padright = atoi(arg);
2563 if (frame_padright < 0) {
2564 fprintf(stderr, "Incorrect right pad size\n");
2569 static void opt_frame_pix_fmt(const char *arg)
2571 if (strcmp(arg, "list")) {
2572 frame_pix_fmt = avcodec_get_pix_fmt(arg);
2573 if (frame_pix_fmt == PIX_FMT_NONE) {
2574 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2578 list_fmts(avcodec_pix_fmt_string, PIX_FMT_NB);
2583 static void opt_frame_aspect_ratio(const char *arg)
2590 p = strchr(arg, ':');
2592 x = strtol(arg, &end, 10);
2594 y = strtol(end+1, &end, 10);
2596 ar = (double)x / (double)y;
2598 ar = strtod(arg, NULL);
2601 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2604 frame_aspect_ratio = ar;
2607 static int opt_metadata(const char *opt, const char *arg)
2609 char *mid= strchr(arg, '=');
2612 fprintf(stderr, "Missing =\n");
2618 metadata= av_realloc(metadata, sizeof(*metadata)*metadata_count);
2619 metadata[metadata_count-1].key = av_strdup(arg);
2620 metadata[metadata_count-1].value= av_strdup(mid);
2625 static void opt_qscale(const char *arg)
2627 video_qscale = atof(arg);
2628 if (video_qscale <= 0 ||
2629 video_qscale > 255) {
2630 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2635 static void opt_top_field_first(const char *arg)
2637 top_field_first= atoi(arg);
2640 static int opt_thread_count(const char *opt, const char *arg)
2642 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2645 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2650 static void opt_audio_sample_fmt(const char *arg)
2652 if (strcmp(arg, "list"))
2653 audio_sample_fmt = avcodec_get_sample_fmt(arg);
2655 list_fmts(avcodec_sample_fmt_string, SAMPLE_FMT_NB);
2660 static int opt_audio_rate(const char *opt, const char *arg)
2662 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2666 static int opt_audio_channels(const char *opt, const char *arg)
2668 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2672 static void opt_video_channel(const char *arg)
2674 video_channel = strtol(arg, NULL, 0);
2677 static void opt_video_standard(const char *arg)
2679 video_standard = av_strdup(arg);
2682 static void opt_codec(int *pstream_copy, char **pcodec_name,
2683 int codec_type, const char *arg)
2685 av_freep(pcodec_name);
2686 if (!strcmp(arg, "copy")) {
2689 *pcodec_name = av_strdup(arg);
2693 static void opt_audio_codec(const char *arg)
2695 opt_codec(&audio_stream_copy, &audio_codec_name, CODEC_TYPE_AUDIO, arg);
2698 static void opt_audio_tag(const char *arg)
2701 audio_codec_tag= strtol(arg, &tail, 0);
2704 audio_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2707 static void opt_video_tag(const char *arg)
2710 video_codec_tag= strtol(arg, &tail, 0);
2713 video_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2716 static void opt_video_codec(const char *arg)
2718 opt_codec(&video_stream_copy, &video_codec_name, CODEC_TYPE_VIDEO, arg);
2721 static void opt_subtitle_codec(const char *arg)
2723 opt_codec(&subtitle_stream_copy, &subtitle_codec_name, CODEC_TYPE_SUBTITLE, arg);
2726 static void opt_subtitle_tag(const char *arg)
2729 subtitle_codec_tag= strtol(arg, &tail, 0);
2732 subtitle_codec_tag= arg[0] + (arg[1]<<8) + (arg[2]<<16) + (arg[3]<<24);
2735 static void opt_map(const char *arg)
2740 m = &stream_maps[nb_stream_maps++];
2742 m->file_index = strtol(arg, &p, 0);
2746 m->stream_index = strtol(p, &p, 0);
2749 m->sync_file_index = strtol(p, &p, 0);
2752 m->sync_stream_index = strtol(p, &p, 0);
2754 m->sync_file_index = m->file_index;
2755 m->sync_stream_index = m->stream_index;
2759 static void opt_map_meta_data(const char *arg)
2764 m = &meta_data_maps[nb_meta_data_maps++];
2766 m->out_file = strtol(arg, &p, 0);
2770 m->in_file = strtol(p, &p, 0);
2773 static void opt_input_ts_scale(const char *arg)
2775 unsigned int stream;
2779 stream = strtol(arg, &p, 0);
2782 scale= strtod(p, &p);
2784 if(stream >= MAX_STREAMS)
2787 input_files_ts_scale[nb_input_files][stream]= scale;
2790 static int opt_recording_time(const char *opt, const char *arg)
2792 recording_time = parse_time_or_die(opt, arg, 1);
2796 static int opt_start_time(const char *opt, const char *arg)
2798 start_time = parse_time_or_die(opt, arg, 1);
2802 static int opt_rec_timestamp(const char *opt, const char *arg)
2804 rec_timestamp = parse_time_or_die(opt, arg, 0) / 1000000;
2808 static int opt_input_ts_offset(const char *opt, const char *arg)
2810 input_ts_offset = parse_time_or_die(opt, arg, 1);
2814 static enum CodecID find_codec_or_die(const char *name, int type, int encoder)
2816 const char *codec_string = encoder ? "encoder" : "decoder";
2820 return CODEC_ID_NONE;
2822 avcodec_find_encoder_by_name(name) :
2823 avcodec_find_decoder_by_name(name);
2825 fprintf(stderr, "Unknown %s '%s'\n", codec_string, name);
2828 if(codec->type != type) {
2829 fprintf(stderr, "Invalid %s type '%s'\n", codec_string, name);
2835 static void opt_input_file(const char *filename)
2837 AVFormatContext *ic;
2838 AVFormatParameters params, *ap = ¶ms;
2839 AVInputFormat *file_iformat = NULL;
2840 int err, i, ret, rfps, rfps_base;
2843 if (last_asked_format) {
2844 file_iformat = av_find_input_format(last_asked_format);
2845 last_asked_format = NULL;
2848 if (!strcmp(filename, "-"))
2851 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2852 !strcmp(filename, "/dev/stdin");
2854 /* get default parameters from command line */
2855 ic = avformat_alloc_context();
2857 print_error(filename, AVERROR(ENOMEM));
2861 memset(ap, 0, sizeof(*ap));
2862 ap->prealloced_context = 1;
2863 ap->sample_rate = audio_sample_rate;
2864 ap->channels = audio_channels;
2865 ap->time_base.den = frame_rate.num;
2866 ap->time_base.num = frame_rate.den;
2867 ap->width = frame_width + frame_padleft + frame_padright;
2868 ap->height = frame_height + frame_padtop + frame_padbottom;
2869 ap->pix_fmt = frame_pix_fmt;
2870 // ap->sample_fmt = audio_sample_fmt; //FIXME:not implemented in libavformat
2871 ap->channel = video_channel;
2872 ap->standard = video_standard;
2873 ap->video_codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 0);
2874 ap->audio_codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 0);
2875 if(pgmyuv_compatibility_hack)
2876 ap->video_codec_id= CODEC_ID_PGMYUV;
2878 set_context_opts(ic, avformat_opts, AV_OPT_FLAG_DECODING_PARAM);
2880 ic->video_codec_id = find_codec_or_die(video_codec_name , CODEC_TYPE_VIDEO , 0);
2881 ic->audio_codec_id = find_codec_or_die(audio_codec_name , CODEC_TYPE_AUDIO , 0);
2882 ic->subtitle_codec_id= find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 0);
2883 ic->flags |= AVFMT_FLAG_NONBLOCK;
2885 /* open the input file with generic libav function */
2886 err = av_open_input_file(&ic, filename, file_iformat, 0, ap);
2888 print_error(filename, err);
2893 for(i=0; i<ic->nb_programs; i++)
2894 if(ic->programs[i]->id != opt_programid)
2895 ic->programs[i]->discard = AVDISCARD_ALL;
2898 ic->loop_input = loop_input;
2900 /* If not enough info to get the stream parameters, we decode the
2901 first frames to get it. (used in mpeg case for example) */
2902 ret = av_find_stream_info(ic);
2903 if (ret < 0 && verbose >= 0) {
2904 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2908 timestamp = start_time;
2909 /* add the stream start time */
2910 if (ic->start_time != AV_NOPTS_VALUE)
2911 timestamp += ic->start_time;
2913 /* if seeking requested, we execute it */
2914 if (start_time != 0) {
2915 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2917 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2918 filename, (double)timestamp / AV_TIME_BASE);
2920 /* reset seek info */
2924 /* update the current parameters so that they match the one of the input stream */
2925 for(i=0;i<ic->nb_streams;i++) {
2926 AVStream *st = ic->streams[i];
2927 AVCodecContext *enc = st->codec;
2929 avcodec_thread_init(enc, thread_count);
2930 switch(enc->codec_type) {
2931 case CODEC_TYPE_AUDIO:
2932 set_context_opts(enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2933 //fprintf(stderr, "\nInput Audio channels: %d", enc->channels);
2934 channel_layout = enc->channel_layout;
2935 audio_channels = enc->channels;
2936 audio_sample_rate = enc->sample_rate;
2937 audio_sample_fmt = enc->sample_fmt;
2938 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(audio_codec_name);
2940 st->discard= AVDISCARD_ALL;
2942 case CODEC_TYPE_VIDEO:
2943 set_context_opts(enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM);
2944 frame_height = enc->height;
2945 frame_width = enc->width;
2946 if(ic->streams[i]->sample_aspect_ratio.num)
2947 frame_aspect_ratio=av_q2d(ic->streams[i]->sample_aspect_ratio);
2949 frame_aspect_ratio=av_q2d(enc->sample_aspect_ratio);
2950 frame_aspect_ratio *= (float) enc->width / enc->height;
2951 frame_pix_fmt = enc->pix_fmt;
2952 rfps = ic->streams[i]->r_frame_rate.num;
2953 rfps_base = ic->streams[i]->r_frame_rate.den;
2955 enc->flags |= CODEC_FLAG_EMU_EDGE;
2956 frame_height >>= enc->lowres;
2957 frame_width >>= enc->lowres;
2960 enc->debug |= FF_DEBUG_MV;
2962 if (enc->time_base.den != rfps || enc->time_base.num != rfps_base) {
2965 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2966 i, (float)enc->time_base.den / enc->time_base.num, enc->time_base.den, enc->time_base.num,
2968 (float)rfps / rfps_base, rfps, rfps_base);
2970 /* update the current frame rate to match the stream frame rate */
2971 frame_rate.num = rfps;
2972 frame_rate.den = rfps_base;
2974 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(video_codec_name);
2976 st->discard= AVDISCARD_ALL;
2977 else if(video_discard)
2978 st->discard= video_discard;
2980 case CODEC_TYPE_DATA:
2982 case CODEC_TYPE_SUBTITLE:
2983 input_codecs[nb_icodecs++] = avcodec_find_decoder_by_name(subtitle_codec_name);
2984 if(subtitle_disable)
2985 st->discard = AVDISCARD_ALL;
2987 case CODEC_TYPE_ATTACHMENT:
2988 case CODEC_TYPE_UNKNOWN:
2996 input_files[nb_input_files] = ic;
2997 input_files_ts_offset[nb_input_files] = input_ts_offset - (copy_ts ? 0 : timestamp);
2998 /* dump the file content */
3000 dump_format(ic, nb_input_files, filename, 0);
3006 av_freep(&video_codec_name);
3007 av_freep(&audio_codec_name);
3008 av_freep(&subtitle_codec_name);
3011 static void check_audio_video_sub_inputs(int *has_video_ptr, int *has_audio_ptr,
3012 int *has_subtitle_ptr)
3014 int has_video, has_audio, has_subtitle, i, j;
3015 AVFormatContext *ic;
3020 for(j=0;j<nb_input_files;j++) {
3021 ic = input_files[j];
3022 for(i=0;i<ic->nb_streams;i++) {
3023 AVCodecContext *enc = ic->streams[i]->codec;
3024 switch(enc->codec_type) {
3025 case CODEC_TYPE_AUDIO:
3028 case CODEC_TYPE_VIDEO:
3031 case CODEC_TYPE_SUBTITLE:
3034 case CODEC_TYPE_DATA:
3035 case CODEC_TYPE_ATTACHMENT:
3036 case CODEC_TYPE_UNKNOWN:
3043 *has_video_ptr = has_video;
3044 *has_audio_ptr = has_audio;
3045 *has_subtitle_ptr = has_subtitle;
3048 static void new_video_stream(AVFormatContext *oc)
3051 AVCodecContext *video_enc;
3052 enum CodecID codec_id;
3054 st = av_new_stream(oc, oc->nb_streams);
3056 fprintf(stderr, "Could not alloc stream\n");
3059 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_VIDEO);
3060 bitstream_filters[nb_output_files][oc->nb_streams - 1]= video_bitstream_filters;
3061 video_bitstream_filters= NULL;
3064 avcodec_thread_init(st->codec, thread_count);
3066 video_enc = st->codec;
3069 video_enc->codec_tag= video_codec_tag;
3071 if( (video_global_header&1)
3072 || (video_global_header==0 && (oc->oformat->flags & AVFMT_GLOBALHEADER))){
3073 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3074 avcodec_opts[CODEC_TYPE_VIDEO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3076 if(video_global_header&2){
3077 video_enc->flags2 |= CODEC_FLAG2_LOCAL_HEADER;
3078 avcodec_opts[CODEC_TYPE_VIDEO]->flags2|= CODEC_FLAG2_LOCAL_HEADER;
3081 if (video_stream_copy) {
3082 st->stream_copy = 1;
3083 video_enc->codec_type = CODEC_TYPE_VIDEO;
3084 video_enc->sample_aspect_ratio =
3085 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3090 AVRational fps= frame_rate.num ? frame_rate : (AVRational){25,1};
3092 if (video_codec_name) {
3093 codec_id = find_codec_or_die(video_codec_name, CODEC_TYPE_VIDEO, 1);
3094 codec = avcodec_find_encoder_by_name(video_codec_name);
3095 output_codecs[nb_ocodecs] = codec;
3097 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_VIDEO);
3098 codec = avcodec_find_encoder(codec_id);
3101 video_enc->codec_id = codec_id;
3103 set_context_opts(video_enc, avcodec_opts[CODEC_TYPE_VIDEO], AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3105 if (codec && codec->supported_framerates && !force_fps)
3106 fps = codec->supported_framerates[av_find_nearest_q_idx(fps, codec->supported_framerates)];
3107 video_enc->time_base.den = fps.num;
3108 video_enc->time_base.num = fps.den;
3110 video_enc->width = frame_width + frame_padright + frame_padleft;
3111 video_enc->height = frame_height + frame_padtop + frame_padbottom;
3112 video_enc->sample_aspect_ratio = av_d2q(frame_aspect_ratio*video_enc->height/video_enc->width, 255);
3113 video_enc->pix_fmt = frame_pix_fmt;
3114 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3116 if(codec && codec->pix_fmts){
3117 const enum PixelFormat *p= codec->pix_fmts;
3119 if(*p == video_enc->pix_fmt)
3123 video_enc->pix_fmt = codec->pix_fmts[0];
3127 video_enc->gop_size = 0;
3128 if (video_qscale || same_quality) {
3129 video_enc->flags |= CODEC_FLAG_QSCALE;
3130 video_enc->global_quality=
3131 st->quality = FF_QP2LAMBDA * video_qscale;
3135 video_enc->intra_matrix = intra_matrix;
3137 video_enc->inter_matrix = inter_matrix;
3139 p= video_rc_override_string;
3142 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3144 fprintf(stderr, "error parsing rc_override\n");
3147 video_enc->rc_override=
3148 av_realloc(video_enc->rc_override,
3149 sizeof(RcOverride)*(i+1));
3150 video_enc->rc_override[i].start_frame= start;
3151 video_enc->rc_override[i].end_frame = end;
3153 video_enc->rc_override[i].qscale= q;
3154 video_enc->rc_override[i].quality_factor= 1.0;
3157 video_enc->rc_override[i].qscale= 0;
3158 video_enc->rc_override[i].quality_factor= -q/100.0;
3163 video_enc->rc_override_count=i;
3164 if (!video_enc->rc_initial_buffer_occupancy)
3165 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3166 video_enc->me_threshold= me_threshold;
3167 video_enc->intra_dc_precision= intra_dc_precision - 8;
3170 video_enc->flags|= CODEC_FLAG_PSNR;
3175 video_enc->flags |= CODEC_FLAG_PASS1;
3177 video_enc->flags |= CODEC_FLAG_PASS2;
3182 if (video_language) {
3183 av_metadata_set(&st->metadata, "language", video_language);
3184 av_freep(&video_language);
3187 /* reset some key parameters */
3189 av_freep(&video_codec_name);
3190 video_stream_copy = 0;
3193 static void new_audio_stream(AVFormatContext *oc)
3196 AVCodecContext *audio_enc;
3197 enum CodecID codec_id;
3199 st = av_new_stream(oc, oc->nb_streams);
3201 fprintf(stderr, "Could not alloc stream\n");
3204 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_AUDIO);
3206 bitstream_filters[nb_output_files][oc->nb_streams - 1]= audio_bitstream_filters;
3207 audio_bitstream_filters= NULL;
3210 avcodec_thread_init(st->codec, thread_count);
3212 audio_enc = st->codec;
3213 audio_enc->codec_type = CODEC_TYPE_AUDIO;
3216 audio_enc->codec_tag= audio_codec_tag;
3218 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3219 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3220 avcodec_opts[CODEC_TYPE_AUDIO]->flags|= CODEC_FLAG_GLOBAL_HEADER;
3222 if (audio_stream_copy) {
3223 st->stream_copy = 1;
3224 audio_enc->channels = audio_channels;
3228 set_context_opts(audio_enc, avcodec_opts[CODEC_TYPE_AUDIO], AV_OPT_FLAG_AUDIO_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3230 if (audio_codec_name) {
3231 codec_id = find_codec_or_die(audio_codec_name, CODEC_TYPE_AUDIO, 1);
3232 codec = avcodec_find_encoder_by_name(audio_codec_name);
3233 output_codecs[nb_ocodecs] = codec;
3235 codec_id = av_guess_codec(oc->oformat, NULL, oc->filename, NULL, CODEC_TYPE_AUDIO);
3236 codec = avcodec_find_encoder(codec_id);
3238 audio_enc->codec_id = codec_id;
3240 if (audio_qscale > QSCALE_NONE) {
3241 audio_enc->flags |= CODEC_FLAG_QSCALE;
3242 audio_enc->global_quality = st->quality = FF_QP2LAMBDA * audio_qscale;
3244 audio_enc->channels = audio_channels;
3245 audio_enc->sample_fmt = audio_sample_fmt;
3246 audio_enc->channel_layout = channel_layout;
3247 if (avcodec_channel_layout_num_channels(channel_layout) != audio_channels)
3248 audio_enc->channel_layout = 0;
3250 if(codec && codec->sample_fmts){
3251 const enum SampleFormat *p= codec->sample_fmts;
3253 if(*p == audio_enc->sample_fmt)
3257 audio_enc->sample_fmt = codec->sample_fmts[0];
3261 audio_enc->sample_rate = audio_sample_rate;
3262 audio_enc->time_base= (AVRational){1, audio_sample_rate};
3263 if (audio_language) {
3264 av_metadata_set(&st->metadata, "language", audio_language);
3265 av_freep(&audio_language);
3268 /* reset some key parameters */
3270 av_freep(&audio_codec_name);
3271 audio_stream_copy = 0;
3274 static void new_subtitle_stream(AVFormatContext *oc)
3277 AVCodecContext *subtitle_enc;
3279 st = av_new_stream(oc, oc->nb_streams);
3281 fprintf(stderr, "Could not alloc stream\n");
3284 avcodec_get_context_defaults2(st->codec, CODEC_TYPE_SUBTITLE);
3286 bitstream_filters[nb_output_files][oc->nb_streams - 1]= subtitle_bitstream_filters;
3287 subtitle_bitstream_filters= NULL;
3289 subtitle_enc = st->codec;
3290 subtitle_enc->codec_type = CODEC_TYPE_SUBTITLE;
3292 if(subtitle_codec_tag)
3293 subtitle_enc->codec_tag= subtitle_codec_tag;
3295 if (subtitle_stream_copy) {
3296 st->stream_copy = 1;
3298 set_context_opts(avcodec_opts[CODEC_TYPE_SUBTITLE], subtitle_enc, AV_OPT_FLAG_SUBTITLE_PARAM | AV_OPT_FLAG_ENCODING_PARAM);
3299 subtitle_enc->codec_id = find_codec_or_die(subtitle_codec_name, CODEC_TYPE_SUBTITLE, 1);
3300 output_codecs[nb_ocodecs] = avcodec_find_encoder_by_name(subtitle_codec_name);
3304 if (subtitle_language) {
3305 av_metadata_set(&st->metadata, "language", subtitle_language);
3306 av_freep(&subtitle_language);
3309 subtitle_disable = 0;
3310 av_freep(&subtitle_codec_name);
3311 subtitle_stream_copy = 0;
3314 static void opt_new_audio_stream(void)
3316 AVFormatContext *oc;
3317 if (nb_output_files <= 0) {
3318 fprintf(stderr, "At least one output file must be specified\n");
3321 oc = output_files[nb_output_files - 1];
3322 new_audio_stream(oc);
3325 static void opt_new_video_stream(void)
3327 AVFormatContext *oc;
3328 if (nb_output_files <= 0) {
3329 fprintf(stderr, "At least one output file must be specified\n");
3332 oc = output_files[nb_output_files - 1];
3333 new_video_stream(oc);
3336 static void opt_new_subtitle_stream(void)
3338 AVFormatContext *oc;
3339 if (nb_output_files <= 0) {
3340 fprintf(stderr, "At least one output file must be specified\n");
3343 oc = output_files[nb_output_files - 1];
3344 new_subtitle_stream(oc);
3347 static void opt_output_file(const char *filename)
3349 AVFormatContext *oc;
3350 int use_video, use_audio, use_subtitle;
3351 int input_has_video, input_has_audio, input_has_subtitle;
3352 AVFormatParameters params, *ap = ¶ms;
3353 AVOutputFormat *file_oformat;
3355 if (!strcmp(filename, "-"))
3358 oc = avformat_alloc_context();
3360 print_error(filename, AVERROR(ENOMEM));
3364 if (last_asked_format) {
3365 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3366 if (!file_oformat) {
3367 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3370 last_asked_format = NULL;
3372 file_oformat = av_guess_format(NULL, filename, NULL);
3373 if (!file_oformat) {
3374 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3380 oc->oformat = file_oformat;
3381 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3383 if (!strcmp(file_oformat->name, "ffm") &&
3384 av_strstart(filename, "http:", NULL)) {
3385 /* special case for files sent to ffserver: we get the stream
3386 parameters from ffserver */
3387 int err = read_ffserver_streams(oc, filename);
3389 print_error(filename, err);
3393 use_video = file_oformat->video_codec != CODEC_ID_NONE || video_stream_copy || video_codec_name;
3394 use_audio = file_oformat->audio_codec != CODEC_ID_NONE || audio_stream_copy || audio_codec_name;
3395 use_subtitle = file_oformat->subtitle_codec != CODEC_ID_NONE || subtitle_stream_copy || subtitle_codec_name;
3397 /* disable if no corresponding type found and at least one
3399 if (nb_input_files > 0) {
3400 check_audio_video_sub_inputs(&input_has_video, &input_has_audio,
3401 &input_has_subtitle);
3402 if (!input_has_video)
3404 if (!input_has_audio)
3406 if (!input_has_subtitle)
3410 /* manual disable */
3411 if (audio_disable) {
3414 if (video_disable) {
3417 if (subtitle_disable) {
3422 new_video_stream(oc);
3426 new_audio_stream(oc);
3430 new_subtitle_stream(oc);
3433 oc->timestamp = rec_timestamp;
3435 for(; metadata_count>0; metadata_count--){
3436 av_metadata_set(&oc->metadata, metadata[metadata_count-1].key,
3437 metadata[metadata_count-1].value);
3439 av_metadata_conv(oc, oc->oformat->metadata_conv, NULL);
3442 output_files[nb_output_files++] = oc;
3444 /* check filename in case of an image number is expected */
3445 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3446 if (!av_filename_number_test(oc->filename)) {
3447 print_error(oc->filename, AVERROR_NUMEXPECTED);
3452 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3453 /* test if it already exists to avoid loosing precious files */
3454 if (!file_overwrite &&
3455 (strchr(filename, ':') == NULL ||
3456 filename[1] == ':' ||
3457 av_strstart(filename, "file:", NULL))) {
3458 if (url_exist(filename)) {
3460 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3462 if (!read_yesno()) {
3463 fprintf(stderr, "Not overwriting - exiting\n");
3468 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3475 if (url_fopen(&oc->pb, filename, URL_WRONLY) < 0) {
3476 fprintf(stderr, "Could not open '%s'\n", filename);
3481 memset(ap, 0, sizeof(*ap));
3482 if (av_set_parameters(oc, ap) < 0) {
3483 fprintf(stderr, "%s: Invalid encoding parameters\n",
3488 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3489 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3490 oc->loop_output = loop_output;
3491 oc->flags |= AVFMT_FLAG_NONBLOCK;
3493 set_context_opts(oc, avformat_opts, AV_OPT_FLAG_ENCODING_PARAM);
3496 /* same option as mencoder */
3497 static void opt_pass(const char *pass_str)
3500 pass = atoi(pass_str);
3501 if (pass != 1 && pass != 2) {
3502 fprintf(stderr, "pass number can be only 1 or 2\n");
3508 static int64_t getutime(void)
3511 struct rusage rusage;
3513 getrusage(RUSAGE_SELF, &rusage);
3514 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3515 #elif HAVE_GETPROCESSTIMES
3517 FILETIME c, e, k, u;
3518 proc = GetCurrentProcess();
3519 GetProcessTimes(proc, &c, &e, &k, &u);
3520 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3522 return av_gettime();
3526 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3529 const char *p = str;
3536 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3543 static void opt_inter_matrix(const char *arg)
3545 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3546 parse_matrix_coeffs(inter_matrix, arg);
3549 static void opt_intra_matrix(const char *arg)
3551 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3552 parse_matrix_coeffs(intra_matrix, arg);
3556 * Trivial log callback.
3557 * Only suitable for show_help and similar since it lacks prefix handling.
3559 static void log_callback_help(void* ptr, int level, const char* fmt, va_list vl)
3561 vfprintf(stdout, fmt, vl);
3564 static void show_usage(void)
3566 printf("Hyper fast Audio and Video encoder\n");
3567 printf("usage: ffmpeg [options] [[infile options] -i infile]... {[outfile options] outfile}...\n");
3571 static void show_help(void)
3573 av_log_set_callback(log_callback_help);
3575 show_help_options(options, "Main options:\n",
3576 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3577 show_help_options(options, "\nAdvanced options:\n",
3578 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3580 show_help_options(options, "\nVideo options:\n",
3581 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3583 show_help_options(options, "\nAdvanced Video options:\n",
3584 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3585 OPT_VIDEO | OPT_EXPERT);
3586 show_help_options(options, "\nAudio options:\n",
3587 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3589 show_help_options(options, "\nAdvanced Audio options:\n",
3590 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3591 OPT_AUDIO | OPT_EXPERT);
3592 show_help_options(options, "\nSubtitle options:\n",
3593 OPT_SUBTITLE | OPT_GRAB,
3595 show_help_options(options, "\nAudio/Video grab options:\n",
3599 av_opt_show(avcodec_opts[0], NULL);
3601 av_opt_show(avformat_opts, NULL);
3603 av_opt_show(sws_opts, NULL);
3606 static void opt_target(const char *arg)
3608 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3609 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3611 if(!strncmp(arg, "pal-", 4)) {
3614 } else if(!strncmp(arg, "ntsc-", 5)) {
3617 } else if(!strncmp(arg, "film-", 5)) {
3622 /* Calculate FR via float to avoid int overflow */
3623 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3626 } else if((fr == 29970) || (fr == 23976)) {
3629 /* Try to determine PAL/NTSC by peeking in the input files */
3630 if(nb_input_files) {
3632 for(j = 0; j < nb_input_files; j++) {
3633 for(i = 0; i < input_files[j]->nb_streams; i++) {
3634 AVCodecContext *c = input_files[j]->streams[i]->codec;
3635 if(c->codec_type != CODEC_TYPE_VIDEO)
3637 fr = c->time_base.den * 1000 / c->time_base.num;
3641 } else if((fr == 29970) || (fr == 23976)) {
3651 if(verbose && norm != UNKNOWN)
3652 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3655 if(norm == UNKNOWN) {
3656 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3657 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3658 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3662 if(!strcmp(arg, "vcd")) {
3664 opt_video_codec("mpeg1video");
3665 opt_audio_codec("mp2");
3668 opt_frame_size(norm == PAL ? "352x288" : "352x240");
3669 opt_frame_rate(NULL, frame_rates[norm]);
3670 opt_default("g", norm == PAL ? "15" : "18");
3672 opt_default("b", "1150000");
3673 opt_default("maxrate", "1150000");
3674 opt_default("minrate", "1150000");
3675 opt_default("bufsize", "327680"); // 40*1024*8;
3677 opt_default("ab", "224000");
3678 audio_sample_rate = 44100;
3681 opt_default("packetsize", "2324");
3682 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3684 /* We have to offset the PTS, so that it is consistent with the SCR.
3685 SCR starts at 36000, but the first two packs contain only padding
3686 and the first pack from the other stream, respectively, may also have
3687 been written before.
3688 So the real data starts at SCR 36000+3*1200. */
3689 mux_preload= (36000+3*1200) / 90000.0; //0.44
3690 } else if(!strcmp(arg, "svcd")) {
3692 opt_video_codec("mpeg2video");
3693 opt_audio_codec("mp2");
3696 opt_frame_size(norm == PAL ? "480x576" : "480x480");
3697 opt_frame_rate(NULL, frame_rates[norm]);
3698 opt_default("g", norm == PAL ? "15" : "18");
3700 opt_default("b", "2040000");
3701 opt_default("maxrate", "2516000");
3702 opt_default("minrate", "0"); //1145000;
3703 opt_default("bufsize", "1835008"); //224*1024*8;
3704 opt_default("flags", "+scan_offset");
3707 opt_default("ab", "224000");
3708 audio_sample_rate = 44100;
3710 opt_default("packetsize", "2324");
3712 } else if(!strcmp(arg, "dvd")) {
3714 opt_video_codec("mpeg2video");
3715 opt_audio_codec("ac3");
3718 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3719 opt_frame_rate(NULL, frame_rates[norm]);
3720 opt_default("g", norm == PAL ? "15" : "18");
3722 opt_default("b", "6000000");
3723 opt_default("maxrate", "9000000");
3724 opt_default("minrate", "0"); //1500000;
3725 opt_default("bufsize", "1835008"); //224*1024*8;
3727 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3728 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3730 opt_default("ab", "448000");
3731 audio_sample_rate = 48000;
3733 } else if(!strncmp(arg, "dv", 2)) {
3737 opt_frame_size(norm == PAL ? "720x576" : "720x480");
3738 opt_frame_pix_fmt(!strncmp(arg, "dv50", 4) ? "yuv422p" :
3739 (norm == PAL ? "yuv420p" : "yuv411p"));
3740 opt_frame_rate(NULL, frame_rates[norm]);
3742 audio_sample_rate = 48000;
3746 fprintf(stderr, "Unknown target: %s\n", arg);
3751 static void opt_vstats_file (const char *arg)
3753 av_free (vstats_filename);
3754 vstats_filename=av_strdup (arg);
3757 static void opt_vstats (void)
3760 time_t today2 = time(NULL);
3761 struct tm *today = localtime(&today2);
3763 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3765 opt_vstats_file(filename);
3768 static int opt_bsf(const char *opt, const char *arg)
3770 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3771 AVBitStreamFilterContext **bsfp;
3774 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
3778 bsfp= *opt == 'v' ? &video_bitstream_filters :
3779 *opt == 'a' ? &audio_bitstream_filters :
3780 &subtitle_bitstream_filters;
3782 bsfp= &(*bsfp)->next;
3789 static int opt_preset(const char *opt, const char *arg)
3792 char filename[1000], tmp[1000], tmp2[1000], line[1000];
3794 const char *base[2]= { getenv("HOME"),
3799 for(i=!base[0]; i<2 && !f; i++){
3800 snprintf(filename, sizeof(filename), "%s%s/%s.ffpreset", base[i], i ? "" : "/.ffmpeg", arg);
3801 f= fopen(filename, "r");
3803 char *codec_name= *opt == 'v' ? video_codec_name :
3804 *opt == 'a' ? audio_codec_name :
3805 subtitle_codec_name;
3806 snprintf(filename, sizeof(filename), "%s%s/%s-%s.ffpreset", base[i], i ? "" : "/.ffmpeg", codec_name, arg);
3807 f= fopen(filename, "r");
3811 av_strlcpy(filename, arg, sizeof(filename));
3812 f= fopen(filename, "r");
3816 fprintf(stderr, "File for preset '%s' not found\n", arg);
3821 int e= fscanf(f, "%999[^\n]\n", line) - 1;
3822 if(line[0] == '#' && !e)
3824 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
3826 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
3829 if(!strcmp(tmp, "acodec")){
3830 opt_audio_codec(tmp2);
3831 }else if(!strcmp(tmp, "vcodec")){
3832 opt_video_codec(tmp2);
3833 }else if(!strcmp(tmp, "scodec")){
3834 opt_subtitle_codec(tmp2);
3835 }else if(opt_default(tmp, tmp2) < 0){
3836 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
3846 static const OptionDef options[] = {
3848 #include "cmdutils_common_opts.h"
3849 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
3850 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
3851 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3852 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file:stream[:syncfile:syncstream]" },
3853 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "set meta data information of outfile from infile", "outfile:infile" },
3854 { "t", OPT_FUNC2 | HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3855 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
3856 { "ss", OPT_FUNC2 | HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
3857 { "itsoffset", OPT_FUNC2 | HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
3858 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "stream:scale" },
3859 { "timestamp", OPT_FUNC2 | HAS_ARG, {(void*)opt_rec_timestamp}, "set the timestamp ('now' to set the current time)", "time" },
3860 { "metadata", OPT_FUNC2 | HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
3861 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[CODEC_TYPE_DATA]}, "set the number of data frames to record", "number" },
3862 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3863 "add timings for benchmarking" },
3864 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3865 "dump each input packet" },
3866 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3867 "when dumping packets, also dump the payload" },
3868 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
3869 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "loop (current only works with images)" },
3870 { "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)", "" },
3871 { "v", HAS_ARG | OPT_FUNC2, {(void*)opt_verbose}, "set ffmpeg verbosity level", "number" },
3872 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3873 { "threads", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
3874 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3875 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3876 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3877 { "vglobal", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_global_header}, "video global header storage type", "" },
3878 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3879 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3880 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3881 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
3882 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3883 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3886 { "b", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3887 { "vb", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3888 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[CODEC_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
3889 { "r", OPT_FUNC2 | HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3890 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
3891 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
3892 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
3893 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_top}, "set top crop band size (in pixels)", "size" },
3894 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_bottom}, "set bottom crop band size (in pixels)", "size" },
3895 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_left}, "set left crop band size (in pixels)", "size" },
3896 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop_right}, "set right crop band size (in pixels)", "size" },
3897 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_top}, "set top pad band size (in pixels)", "size" },
3898 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_bottom}, "set bottom pad band size (in pixels)", "size" },
3899 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_left}, "set left pad band size (in pixels)", "size" },
3900 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_pad_right}, "set right pad band size (in pixels)", "size" },
3901 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad_color}, "set color of pad bands (Hex 000000 thru FFFFFF)", "color" },
3902 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
3903 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
3904 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3905 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
3906 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
3907 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3908 { "me_threshold", HAS_ARG | OPT_FUNC2 | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimaton threshold", "threshold" },
3909 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quality},
3910 "use same video quality as source (implies VBR)" },
3911 { "pass", HAS_ARG | OPT_VIDEO, {(void*)&opt_pass}, "select the pass number (1 or 2)", "n" },
3912 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3913 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3914 "deinterlace pictures" },
3915 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3916 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3917 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3918 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3919 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3920 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3921 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3922 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3923 { "newvideo", OPT_VIDEO, {(void*)opt_new_video_stream}, "add a new video stream to the current output stream" },
3924 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
3925 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3926 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
3929 { "ab", OPT_FUNC2 | HAS_ARG | OPT_AUDIO, {(void*)opt_bitrate}, "set bitrate (in bits/s)", "bitrate" },
3930 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[CODEC_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
3931 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
3932 { "ar", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
3933 { "ac", HAS_ARG | OPT_FUNC2 | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
3934 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
3935 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3936 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3937 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3938 { "newaudio", OPT_AUDIO, {(void*)opt_new_audio_stream}, "add a new audio stream to the current output stream" },
3939 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
3940 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
3942 /* subtitle options */
3943 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
3944 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3945 { "newsubtitle", OPT_SUBTITLE, {(void*)opt_new_subtitle_stream}, "add a new subtitle stream to the current output stream" },
3946 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
3947 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3950 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "set video grab channel (DV1394 only)", "channel" },
3951 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "set television standard (NTSC, PAL (SECAM))", "standard" },
3952 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3955 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
3956 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
3958 { "absf", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3959 { "vbsf", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3960 { "sbsf", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
3962 { "apre", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
3963 { "vpre", OPT_FUNC2 | HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
3964 { "spre", OPT_FUNC2 | HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
3965 { "fpre", OPT_FUNC2 | HAS_ARG | OPT_EXPERT, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
3967 { "default", OPT_FUNC2 | HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3971 int main(int argc, char **argv)
3976 avcodec_register_all();
3977 avdevice_register_all();
3981 if(isatty(STDIN_FILENO))
3982 url_set_interrupt_cb(decode_interrupt_cb);
3985 for(i=0; i<CODEC_TYPE_NB; i++){
3986 avcodec_opts[i]= avcodec_alloc_context2(i);
3988 avformat_opts = avformat_alloc_context();
3989 sws_opts = sws_getContext(16,16,0, 16,16,0, sws_flags, NULL,NULL,NULL);
3994 parse_options(argc, argv, options, opt_output_file);
3996 if(nb_output_files <= 0 && nb_input_files == 0) {
3998 fprintf(stderr, "Use -h to get full help or, even better, run 'man ffmpeg'\n");
4002 /* file converter / grab */
4003 if (nb_output_files <= 0) {
4004 fprintf(stderr, "At least one output file must be specified\n");
4008 if (nb_input_files == 0) {
4009 fprintf(stderr, "At least one input file must be specified\n");
4014 if (av_encode(output_files, nb_output_files, input_files, nb_input_files,
4015 stream_maps, nb_stream_maps) < 0)
4017 ti = getutime() - ti;
4019 printf("bench: utime=%0.3fs\n", ti / 1000000.0);