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
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
49 #include "libavformat/ffm.h" // not public API
52 # include "libavfilter/avcodec.h"
53 # include "libavfilter/avfilter.h"
54 # include "libavfilter/avfiltergraph.h"
55 # include "libavfilter/vsink_buffer.h"
56 # include "libavfilter/vsrc_buffer.h"
59 #if HAVE_SYS_RESOURCE_H
60 #include <sys/types.h>
62 #include <sys/resource.h>
63 #elif HAVE_GETPROCESSTIMES
66 #if HAVE_GETPROCESSMEMORYINFO
72 #include <sys/select.h>
77 #include <sys/ioctl.h>
87 #include "libavutil/avassert.h"
89 const char program_name[] = "ffmpeg";
90 const int program_birth_year = 2000;
92 /* select an input stream for an output stream */
93 typedef struct StreamMap {
94 int disabled; /** 1 is this mapping is disabled by a negative map */
98 int sync_stream_index;
102 * select an input file for an output file
104 typedef struct MetadataMap {
105 int file; ///< file index
106 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
107 int index; ///< stream/chapter/program number
110 static const OptionDef options[];
112 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
114 /* indexed by output file stream index */
115 static int *streamid_map = NULL;
116 static int nb_streamid_map = 0;
118 static int frame_width = 0;
119 static int frame_height = 0;
120 static float frame_aspect_ratio = 0;
121 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
122 static int frame_bits_per_raw_sample = 0;
123 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
124 static AVRational frame_rate;
125 static float video_qscale = 0;
126 static uint16_t *intra_matrix = NULL;
127 static uint16_t *inter_matrix = NULL;
128 static const char *video_rc_override_string=NULL;
129 static int video_disable = 0;
130 static int video_discard = 0;
131 static char *video_codec_name = NULL;
132 static unsigned int video_codec_tag = 0;
133 static char *video_language = NULL;
134 static int same_quant = 0;
135 static int do_deinterlace = 0;
136 static int top_field_first = -1;
137 static int me_threshold = 0;
138 static int intra_dc_precision = 8;
139 static int loop_input = 0;
140 static int loop_output = AVFMT_NOOUTPUTLOOP;
141 static int qp_hist = 0;
143 static char *vfilters = NULL;
146 static int intra_only = 0;
147 static int audio_sample_rate = 0;
148 #define QSCALE_NONE -99999
149 static float audio_qscale = QSCALE_NONE;
150 static int audio_disable = 0;
151 static int audio_channels = 0;
152 static char *audio_codec_name = NULL;
153 static unsigned int audio_codec_tag = 0;
154 static char *audio_language = NULL;
156 static int subtitle_disable = 0;
157 static char *subtitle_codec_name = NULL;
158 static char *subtitle_language = NULL;
159 static unsigned int subtitle_codec_tag = 0;
161 static int data_disable = 0;
162 static char *data_codec_name = NULL;
163 static unsigned int data_codec_tag = 0;
165 static int file_overwrite = 0;
166 static int do_benchmark = 0;
167 static int do_hex_dump = 0;
168 static int do_pkt_dump = 0;
169 static int do_psnr = 0;
170 static int do_pass = 0;
171 static const char *pass_logfilename_prefix;
172 static int video_sync_method= -1;
173 static int audio_sync_method= 0;
174 static float audio_drift_threshold= 0.1;
175 static int copy_ts= 0;
176 static int copy_tb= 0;
177 static int opt_shortest = 0;
178 static char *vstats_filename;
179 static FILE *vstats_file;
180 static int opt_programid = 0;
181 static int copy_initial_nonkeyframes = 0;
183 static int audio_volume = 256;
185 static int exit_on_error = 0;
186 static int using_stdin = 0;
187 static int verbose = 1;
188 static int run_as_daemon = 0;
189 static int thread_count= 1;
190 static int q_pressed = 0;
191 static int64_t video_size = 0;
192 static int64_t audio_size = 0;
193 static int64_t extra_size = 0;
194 static int nb_frames_dup = 0;
195 static int nb_frames_drop = 0;
196 static int input_sync;
197 static int force_fps = 0;
198 static char *forced_key_frames = NULL;
200 static float dts_delta_threshold = 10;
202 static uint8_t *audio_buf;
203 static uint8_t *audio_out;
204 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
206 static short *samples;
207 static uint8_t *input_tmp= NULL;
209 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
211 typedef struct InputStream {
214 int discard; /* true if stream data should be discarded */
215 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
218 int64_t start; /* time when read started */
219 int64_t next_pts; /* synthetic pts for cases where pkt.pts
221 int64_t pts; /* current pts */
223 int is_start; /* is 1 at the start and after a discontinuity */
224 int showed_multi_packet_warning;
228 typedef struct InputFile {
229 AVFormatContext *ctx;
230 int eof_reached; /* true if eof reached */
231 int ist_index; /* index of first stream in ist_table */
232 int buffer_size; /* current total buffer size */
234 int nb_streams; /* number of stream that avconv is aware of; may be different
235 from ctx.nb_streams if new streams appear during av_read_frame() */
239 typedef struct OutputStream {
240 int file_index; /* file index */
241 int index; /* stream index in the output file */
242 int source_index; /* InputStream index */
243 AVStream *st; /* stream in the output file */
244 int encoding_needed; /* true if encoding needed for this stream */
246 /* input pts and corresponding output pts
248 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
249 struct InputStream *sync_ist; /* input stream to sync against */
250 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
251 AVBitStreamFilterContext *bitstream_filters;
257 AVFrame resample_frame; /* temporary frame for image resampling */
258 struct SwsContext *img_resample_ctx; /* for image resampling */
261 int resample_pix_fmt;
262 AVRational frame_rate;
264 float frame_aspect_ratio;
266 /* forced key frames */
267 int64_t *forced_kf_pts;
273 ReSampleContext *resample; /* for audio resampling */
274 int resample_sample_fmt;
275 int resample_channels;
276 int resample_sample_rate;
278 AVAudioConvert *reformat_ctx;
279 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
283 AVFilterContext *output_video_filter;
284 AVFilterContext *input_video_filter;
285 AVFilterBufferRef *picref;
287 AVFilterGraph *graph;
292 int is_past_recording_time;
298 /* init terminal so that we can grab keys */
299 static struct termios oldtty;
302 typedef struct OutputFile {
303 AVFormatContext *ctx;
305 int ost_index; /* index of the first stream in output_streams */
306 int64_t recording_time; /* desired length of the resulting file in microseconds */
307 int64_t start_time; /* start time in microseconds */
308 uint64_t limit_filesize;
311 static InputStream *input_streams = NULL;
312 static int nb_input_streams = 0;
313 static InputFile *input_files = NULL;
314 static int nb_input_files = 0;
316 static OutputStream *output_streams = NULL;
317 static int nb_output_streams = 0;
318 static OutputFile *output_files = NULL;
319 static int nb_output_files = 0;
321 typedef struct OptionsContext {
322 /* input/output options */
326 SpecifierOpt *codec_names;
330 int64_t input_ts_offset;
333 SpecifierOpt *ts_scale;
337 StreamMap *stream_maps;
339 /* first item specifies output metadata, second is input */
340 MetadataMap (*meta_data_maps)[2];
341 int nb_meta_data_maps;
342 int metadata_global_manual;
343 int metadata_streams_manual;
344 int metadata_chapters_manual;
346 int chapters_input_file;
348 int64_t recording_time;
349 uint64_t limit_filesize;
353 SpecifierOpt *metadata;
355 SpecifierOpt *max_frames;
357 SpecifierOpt *bitstream_filters;
358 int nb_bitstream_filters;
361 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
364 for (i = 0; i < o->nb_ ## name; i++) {\
365 char *spec = o->name[i].specifier;\
366 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
367 outvar = o->name[i].u.type;\
373 static void reset_options(OptionsContext *o, int is_input)
375 const OptionDef *po = options;
376 OptionsContext bak= *o;
378 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
380 void *dst = (uint8_t*)o + po->u.off;
382 if (po->flags & OPT_SPEC) {
383 SpecifierOpt **so = dst;
384 int i, *count = (int*)(so + 1);
385 for (i = 0; i < *count; i++) {
386 av_freep(&(*so)[i].specifier);
387 if (po->flags & OPT_STRING)
388 av_freep(&(*so)[i].u.str);
392 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
397 av_freep(&o->stream_maps);
398 av_freep(&o->meta_data_maps);
400 memset(o, 0, sizeof(*o));
402 if(is_input) o->recording_time = bak.recording_time;
403 else o->recording_time = INT64_MAX;
404 o->mux_preload = 0.5;
405 o->mux_max_delay = 0.7;
406 o->limit_filesize = UINT64_MAX;
407 o->chapters_input_file = INT_MAX;
415 static int configure_video_filters(InputStream *ist, OutputStream *ost)
417 AVFilterContext *last_filter, *filter;
418 /** filter graph containing all filters including input & output */
419 AVCodecContext *codec = ost->st->codec;
420 AVCodecContext *icodec = ist->st->codec;
421 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
422 AVRational sample_aspect_ratio;
426 ost->graph = avfilter_graph_alloc();
428 if (ist->st->sample_aspect_ratio.num){
429 sample_aspect_ratio = ist->st->sample_aspect_ratio;
431 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
433 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
434 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
435 sample_aspect_ratio.num, sample_aspect_ratio.den);
437 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
438 "src", args, NULL, ost->graph);
441 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
442 "out", NULL, pix_fmts, ost->graph);
445 last_filter = ost->input_video_filter;
447 if (codec->width != icodec->width || codec->height != icodec->height) {
448 snprintf(args, 255, "%d:%d:flags=0x%X",
452 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
453 NULL, args, NULL, ost->graph)) < 0)
455 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
457 last_filter = filter;
460 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
461 ost->graph->scale_sws_opts = av_strdup(args);
464 AVFilterInOut *outputs = avfilter_inout_alloc();
465 AVFilterInOut *inputs = avfilter_inout_alloc();
467 outputs->name = av_strdup("in");
468 outputs->filter_ctx = last_filter;
469 outputs->pad_idx = 0;
470 outputs->next = NULL;
472 inputs->name = av_strdup("out");
473 inputs->filter_ctx = ost->output_video_filter;
477 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
479 av_freep(&ost->avfilter);
481 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
485 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
488 codec->width = ost->output_video_filter->inputs[0]->w;
489 codec->height = ost->output_video_filter->inputs[0]->h;
490 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
491 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
492 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
493 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
497 #endif /* CONFIG_AVFILTER */
499 static void term_exit(void)
501 av_log(NULL, AV_LOG_QUIET, "%s", "");
504 tcsetattr (0, TCSANOW, &oldtty);
508 static volatile int received_sigterm = 0;
511 sigterm_handler(int sig)
513 received_sigterm = sig;
518 static void term_init(void)
528 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
529 |INLCR|IGNCR|ICRNL|IXON);
530 tty.c_oflag |= OPOST;
531 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
532 tty.c_cflag &= ~(CSIZE|PARENB);
537 tcsetattr (0, TCSANOW, &tty);
538 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
542 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
543 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
545 signal(SIGXCPU, sigterm_handler);
549 /* read a key without blocking */
550 static int read_key(void)
565 n = select(1, &rfds, NULL, NULL, &tv);
574 # if HAVE_PEEKNAMEDPIPE
576 static HANDLE input_handle;
579 input_handle = GetStdHandle(STD_INPUT_HANDLE);
580 is_pipe = !GetConsoleMode(input_handle, &dw);
583 if (stdin->_cnt > 0) {
588 /* When running under a GUI, you will end here. */
589 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
606 static int decode_interrupt_cb(void)
608 q_pressed += read_key() == 'q';
609 return q_pressed > 1;
612 void exit_program(int ret)
617 for(i=0;i<nb_output_files;i++) {
618 AVFormatContext *s = output_files[i].ctx;
619 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
621 avformat_free_context(s);
622 av_dict_free(&output_files[i].opts);
624 for(i=0;i<nb_input_files;i++) {
625 av_close_input_file(input_files[i].ctx);
627 for (i = 0; i < nb_input_streams; i++)
628 av_dict_free(&input_streams[i].opts);
630 av_free(intra_matrix);
631 av_free(inter_matrix);
635 av_free(vstats_filename);
637 av_freep(&input_streams);
638 av_freep(&input_files);
639 av_freep(&output_streams);
640 av_freep(&output_files);
645 allocated_audio_buf_size= allocated_audio_out_size= 0;
652 av_freep(&input_tmp);
654 if (received_sigterm) {
656 "Received signal %d: terminating.\n",
657 (int) received_sigterm);
661 exit(ret); /* not all OS-es handle main() return value */
664 static void assert_avoptions(AVDictionary *m)
666 AVDictionaryEntry *t;
667 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
668 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
673 static void assert_codec_experimental(AVCodecContext *c, int encoder)
675 const char *codec_string = encoder ? "encoder" : "decoder";
677 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
678 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
679 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
680 "results.\nAdd '-strict experimental' if you want to use it.\n",
681 codec_string, c->codec->name);
682 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
683 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
684 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
685 codec_string, codec->name);
690 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
692 if(codec && codec->sample_fmts){
693 const enum AVSampleFormat *p= codec->sample_fmts;
695 if(*p == st->codec->sample_fmt)
699 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
700 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
701 if(av_get_sample_fmt_name(st->codec->sample_fmt))
702 av_log(NULL, AV_LOG_WARNING,
703 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
704 av_get_sample_fmt_name(st->codec->sample_fmt),
706 av_get_sample_fmt_name(codec->sample_fmts[0]));
707 st->codec->sample_fmt = codec->sample_fmts[0];
712 static void choose_sample_rate(AVStream *st, AVCodec *codec)
714 if(codec && codec->supported_samplerates){
715 const int *p= codec->supported_samplerates;
717 int best_dist=INT_MAX;
719 int dist= abs(st->codec->sample_rate - *p);
720 if(dist < best_dist){
726 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
728 st->codec->sample_rate= best;
732 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
734 if(codec && codec->pix_fmts){
735 const enum PixelFormat *p= codec->pix_fmts;
736 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
737 if(st->codec->codec_id==CODEC_ID_MJPEG){
738 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
739 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
740 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
744 if(*p == st->codec->pix_fmt)
748 if(st->codec->pix_fmt != PIX_FMT_NONE)
749 av_log(NULL, AV_LOG_WARNING,
750 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
751 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
753 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
754 st->codec->pix_fmt = codec->pix_fmts[0];
760 get_sync_ipts(const OutputStream *ost)
762 const InputStream *ist = ost->sync_ist;
763 OutputFile *of = &output_files[ost->file_index];
764 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
767 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
771 AVPacket new_pkt= *pkt;
772 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
773 &new_pkt.data, &new_pkt.size,
774 pkt->data, pkt->size,
775 pkt->flags & AV_PKT_FLAG_KEY);
778 new_pkt.destruct= av_destruct_packet;
780 fprintf(stderr, "%s failed for stream %d, codec %s",
781 bsfc->filter->name, pkt->stream_index,
782 avctx->codec ? avctx->codec->name : "copy");
792 ret= av_interleaved_write_frame(s, pkt);
794 print_error("av_interleaved_write_frame()", ret);
799 static void do_audio_out(AVFormatContext *s,
802 unsigned char *buf, int size)
805 int64_t audio_out_size, audio_buf_size;
806 int64_t allocated_for_size= size;
808 int size_out, frame_bytes, ret, resample_changed;
809 AVCodecContext *enc= ost->st->codec;
810 AVCodecContext *dec= ist->st->codec;
811 int osize = av_get_bytes_per_sample(enc->sample_fmt);
812 int isize = av_get_bytes_per_sample(dec->sample_fmt);
813 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
816 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
817 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
818 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
819 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
820 audio_buf_size*= osize*enc->channels;
822 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
823 if(coded_bps > 8*osize)
824 audio_out_size= audio_out_size * coded_bps / (8*osize);
825 audio_out_size += FF_MIN_BUFFER_SIZE;
827 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
828 fprintf(stderr, "Buffer sizes too large\n");
832 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
833 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
834 if (!audio_buf || !audio_out){
835 fprintf(stderr, "Out of memory in do_audio_out\n");
839 if (enc->channels != dec->channels)
840 ost->audio_resample = 1;
842 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
843 ost->resample_channels != dec->channels ||
844 ost->resample_sample_rate != dec->sample_rate;
846 if ((ost->audio_resample && !ost->resample) || resample_changed) {
847 if (resample_changed) {
848 av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
849 ist->file_index, ist->st->index,
850 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
851 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
852 ost->resample_sample_fmt = dec->sample_fmt;
853 ost->resample_channels = dec->channels;
854 ost->resample_sample_rate = dec->sample_rate;
856 audio_resample_close(ost->resample);
858 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
859 if (audio_sync_method <= 1 &&
860 ost->resample_sample_fmt == enc->sample_fmt &&
861 ost->resample_channels == enc->channels &&
862 ost->resample_sample_rate == enc->sample_rate) {
863 ost->resample = NULL;
864 ost->audio_resample = 0;
866 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
867 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
868 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
869 enc->sample_rate, dec->sample_rate,
870 enc->sample_fmt, dec->sample_fmt,
872 if (!ost->resample) {
873 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
874 dec->channels, dec->sample_rate,
875 enc->channels, enc->sample_rate);
881 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
882 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
883 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
884 if (ost->reformat_ctx)
885 av_audio_convert_free(ost->reformat_ctx);
886 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
887 dec->sample_fmt, 1, NULL, 0);
888 if (!ost->reformat_ctx) {
889 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
890 av_get_sample_fmt_name(dec->sample_fmt),
891 av_get_sample_fmt_name(enc->sample_fmt));
894 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
897 if(audio_sync_method){
898 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
899 - av_fifo_size(ost->fifo)/(enc->channels * 2);
900 double idelta= delta*dec->sample_rate / enc->sample_rate;
901 int byte_delta= ((int)idelta)*2*dec->channels;
903 //FIXME resample delay
904 if(fabs(delta) > 50){
905 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
907 byte_delta= FFMAX(byte_delta, -size);
911 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
916 input_tmp= av_realloc(input_tmp, byte_delta + size);
918 if(byte_delta > allocated_for_size - size){
919 allocated_for_size= byte_delta + (int64_t)size;
924 memset(input_tmp, 0, byte_delta);
925 memcpy(input_tmp + byte_delta, buf, size);
929 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
931 }else if(audio_sync_method>1){
932 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
933 av_assert0(ost->audio_resample);
935 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
936 // 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));
937 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
941 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
942 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
944 if (ost->audio_resample) {
946 size_out = audio_resample(ost->resample,
947 (short *)buftmp, (short *)buf,
948 size / (dec->channels * isize));
949 size_out = size_out * enc->channels * osize;
955 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
956 const void *ibuf[6]= {buftmp};
957 void *obuf[6]= {audio_buf};
958 int istride[6]= {isize};
959 int ostride[6]= {osize};
960 int len= size_out/istride[0];
961 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
962 printf("av_audio_convert() failed\n");
968 size_out = len*osize;
971 /* now encode as many frames as possible */
972 if (enc->frame_size > 1) {
973 /* output resampled raw samples */
974 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
975 fprintf(stderr, "av_fifo_realloc2() failed\n");
978 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
980 frame_bytes = enc->frame_size * osize * enc->channels;
982 while (av_fifo_size(ost->fifo) >= frame_bytes) {
984 av_init_packet(&pkt);
986 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
988 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
990 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
993 fprintf(stderr, "Audio encoding failed\n");
997 pkt.stream_index= ost->index;
1000 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1001 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1002 pkt.flags |= AV_PKT_FLAG_KEY;
1003 write_frame(s, &pkt, enc, ost->bitstream_filters);
1005 ost->sync_opts += enc->frame_size;
1009 av_init_packet(&pkt);
1011 ost->sync_opts += size_out / (osize * enc->channels);
1013 /* output a pcm frame */
1014 /* determine the size of the coded buffer */
1017 size_out = size_out*coded_bps/8;
1019 if(size_out > audio_out_size){
1020 fprintf(stderr, "Internal error, buffer size too small\n");
1024 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1025 ret = avcodec_encode_audio(enc, audio_out, size_out,
1028 fprintf(stderr, "Audio encoding failed\n");
1032 pkt.stream_index= ost->index;
1033 pkt.data= audio_out;
1035 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1036 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1037 pkt.flags |= AV_PKT_FLAG_KEY;
1038 write_frame(s, &pkt, enc, ost->bitstream_filters);
1042 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1044 AVCodecContext *dec;
1045 AVPicture *picture2;
1046 AVPicture picture_tmp;
1049 dec = ist->st->codec;
1051 /* deinterlace : must be done before any resize */
1052 if (do_deinterlace) {
1055 /* create temporary picture */
1056 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1057 buf = av_malloc(size);
1061 picture2 = &picture_tmp;
1062 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1064 if(avpicture_deinterlace(picture2, picture,
1065 dec->pix_fmt, dec->width, dec->height) < 0) {
1066 /* if error, do not deinterlace */
1067 fprintf(stderr, "Deinterlacing failed\n");
1076 if (picture != picture2)
1077 *picture = *picture2;
1081 static void do_subtitle_out(AVFormatContext *s,
1087 static uint8_t *subtitle_out = NULL;
1088 int subtitle_out_max_size = 1024 * 1024;
1089 int subtitle_out_size, nb, i;
1090 AVCodecContext *enc;
1093 if (pts == AV_NOPTS_VALUE) {
1094 fprintf(stderr, "Subtitle packets must have a pts\n");
1100 enc = ost->st->codec;
1102 if (!subtitle_out) {
1103 subtitle_out = av_malloc(subtitle_out_max_size);
1106 /* Note: DVB subtitle need one packet to draw them and one other
1107 packet to clear them */
1108 /* XXX: signal it in the codec context ? */
1109 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1114 for(i = 0; i < nb; i++) {
1115 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1116 // start_display_time is required to be 0
1117 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1118 sub->end_display_time -= sub->start_display_time;
1119 sub->start_display_time = 0;
1120 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1121 subtitle_out_max_size, sub);
1122 if (subtitle_out_size < 0) {
1123 fprintf(stderr, "Subtitle encoding failed\n");
1127 av_init_packet(&pkt);
1128 pkt.stream_index = ost->index;
1129 pkt.data = subtitle_out;
1130 pkt.size = subtitle_out_size;
1131 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1132 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1133 /* XXX: the pts correction is handled here. Maybe handling
1134 it in the codec would be better */
1136 pkt.pts += 90 * sub->start_display_time;
1138 pkt.pts += 90 * sub->end_display_time;
1140 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1144 static int bit_buffer_size= 1024*256;
1145 static uint8_t *bit_buffer= NULL;
1147 static void do_video_resample(OutputStream *ost,
1149 AVFrame *in_picture,
1150 AVFrame **out_picture)
1153 *out_picture = in_picture;
1155 AVCodecContext *dec = ist->st->codec;
1156 AVCodecContext *enc = ost->st->codec;
1157 int resample_changed = ost->resample_width != dec->width ||
1158 ost->resample_height != dec->height ||
1159 ost->resample_pix_fmt != dec->pix_fmt;
1161 *out_picture = in_picture;
1162 if (resample_changed) {
1163 av_log(NULL, AV_LOG_INFO,
1164 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1165 ist->file_index, ist->st->index,
1166 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1167 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1168 ost->resample_width = dec->width;
1169 ost->resample_height = dec->height;
1170 ost->resample_pix_fmt = dec->pix_fmt;
1173 ost->video_resample = dec->width != enc->width ||
1174 dec->height != enc->height ||
1175 dec->pix_fmt != enc->pix_fmt;
1177 if (ost->video_resample) {
1178 *out_picture = &ost->resample_frame;
1179 if (!ost->img_resample_ctx || resample_changed) {
1180 /* initialize the destination picture */
1181 if (!ost->resample_frame.data[0]) {
1182 avcodec_get_frame_defaults(&ost->resample_frame);
1183 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1184 enc->width, enc->height)) {
1185 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1189 /* initialize a new scaler context */
1190 sws_freeContext(ost->img_resample_ctx);
1191 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1192 enc->width, enc->height, enc->pix_fmt,
1193 ost->sws_flags, NULL, NULL, NULL);
1194 if (ost->img_resample_ctx == NULL) {
1195 fprintf(stderr, "Cannot get resampling context\n");
1199 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1200 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1206 static void do_video_out(AVFormatContext *s,
1209 AVFrame *in_picture,
1210 int *frame_size, float quality)
1212 int nb_frames, i, ret, format_video_sync;
1213 AVFrame *final_picture;
1214 AVCodecContext *enc;
1217 enc = ost->st->codec;
1219 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1221 /* by default, we output a single frame */
1226 format_video_sync = video_sync_method;
1227 if (format_video_sync < 0)
1228 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1230 if (format_video_sync) {
1231 double vdelta = sync_ipts - ost->sync_opts;
1232 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1235 else if (format_video_sync == 2) {
1238 }else if(vdelta>0.6)
1239 ost->sync_opts= lrintf(sync_ipts);
1240 }else if (vdelta > 1.1)
1241 nb_frames = lrintf(vdelta);
1242 //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);
1243 if (nb_frames == 0){
1246 fprintf(stderr, "*** drop!\n");
1247 }else if (nb_frames > 1) {
1248 nb_frames_dup += nb_frames - 1;
1250 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1253 ost->sync_opts= lrintf(sync_ipts);
1255 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1259 do_video_resample(ost, ist, in_picture, &final_picture);
1261 /* duplicates frame if needed */
1262 for(i=0;i<nb_frames;i++) {
1264 av_init_packet(&pkt);
1265 pkt.stream_index= ost->index;
1267 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1268 /* raw pictures are written as AVPicture structure to
1269 avoid any copies. We support temporarily the older
1271 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1272 enc->coded_frame->top_field_first = in_picture->top_field_first;
1273 pkt.data= (uint8_t *)final_picture;
1274 pkt.size= sizeof(AVPicture);
1275 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1276 pkt.flags |= AV_PKT_FLAG_KEY;
1278 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1280 AVFrame big_picture;
1282 big_picture= *final_picture;
1283 /* better than nothing: use input picture interlaced
1285 big_picture.interlaced_frame = in_picture->interlaced_frame;
1286 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1287 if(top_field_first == -1)
1288 big_picture.top_field_first = in_picture->top_field_first;
1290 big_picture.top_field_first = top_field_first;
1293 /* handles same_quant here. This is not correct because it may
1294 not be a global option */
1295 big_picture.quality = quality;
1297 big_picture.pict_type = 0;
1298 // big_picture.pts = AV_NOPTS_VALUE;
1299 big_picture.pts= ost->sync_opts;
1300 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1301 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1302 if (ost->forced_kf_index < ost->forced_kf_count &&
1303 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1304 big_picture.pict_type = AV_PICTURE_TYPE_I;
1305 ost->forced_kf_index++;
1307 ret = avcodec_encode_video(enc,
1308 bit_buffer, bit_buffer_size,
1311 fprintf(stderr, "Video encoding failed\n");
1316 pkt.data= bit_buffer;
1318 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1319 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1320 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1321 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1322 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1324 if(enc->coded_frame->key_frame)
1325 pkt.flags |= AV_PKT_FLAG_KEY;
1326 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1329 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1330 // enc->frame_number-1, ret, enc->pict_type);
1331 /* if two pass, output log */
1332 if (ost->logfile && enc->stats_out) {
1333 fprintf(ost->logfile, "%s", enc->stats_out);
1338 ost->frame_number++;
1342 static double psnr(double d){
1343 return -10.0*log(d)/log(10.0);
1346 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1349 AVCodecContext *enc;
1351 double ti1, bitrate, avg_bitrate;
1353 /* this is executed just the first time do_video_stats is called */
1355 vstats_file = fopen(vstats_filename, "w");
1362 enc = ost->st->codec;
1363 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1364 frame_number = ost->frame_number;
1365 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1366 if (enc->flags&CODEC_FLAG_PSNR)
1367 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1369 fprintf(vstats_file,"f_size= %6d ", frame_size);
1370 /* compute pts value */
1371 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1375 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1376 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1377 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1378 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1379 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1383 static void print_report(OutputFile *output_files,
1384 OutputStream *ost_table, int nb_ostreams,
1385 int is_last_report, int64_t timer_start)
1389 AVFormatContext *oc;
1391 AVCodecContext *enc;
1392 int frame_number, vid, i;
1394 int64_t pts = INT64_MAX;
1395 static int64_t last_time = -1;
1396 static int qp_histogram[52];
1398 if (!is_last_report) {
1400 /* display the report every 0.5 seconds */
1401 cur_time = av_gettime();
1402 if (last_time == -1) {
1403 last_time = cur_time;
1406 if ((cur_time - last_time) < 500000)
1408 last_time = cur_time;
1412 oc = output_files[0].ctx;
1414 total_size = avio_size(oc->pb);
1415 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1416 total_size= avio_tell(oc->pb);
1420 for(i=0;i<nb_ostreams;i++) {
1422 ost = &ost_table[i];
1423 enc = ost->st->codec;
1424 if (!ost->st->stream_copy && enc->coded_frame)
1425 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1426 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1427 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1429 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1430 float t = (av_gettime()-timer_start) / 1000000.0;
1432 frame_number = ost->frame_number;
1433 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1434 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1436 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1440 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1443 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1445 if (enc->flags&CODEC_FLAG_PSNR){
1447 double error, error_sum=0;
1448 double scale, scale_sum=0;
1449 char type[3]= {'Y','U','V'};
1450 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1453 error= enc->error[j];
1454 scale= enc->width*enc->height*255.0*255.0*frame_number;
1456 error= enc->coded_frame->error[j];
1457 scale= enc->width*enc->height*255.0*255.0;
1462 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1464 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1468 /* compute min output value */
1469 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1470 ost->st->time_base, AV_TIME_BASE_Q));
1473 if (verbose > 0 || is_last_report) {
1474 int hours, mins, secs, us;
1475 secs = pts / AV_TIME_BASE;
1476 us = pts % AV_TIME_BASE;
1482 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1484 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1485 "size=%8.0fkB time=", total_size / 1024.0);
1486 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1487 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1488 (100 * us) / AV_TIME_BASE);
1489 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1490 "bitrate=%6.1fkbits/s", bitrate);
1492 if (nb_frames_dup || nb_frames_drop)
1493 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1494 nb_frames_dup, nb_frames_drop);
1497 fprintf(stderr, "%s \r", buf);
1502 if (is_last_report && verbose >= 0){
1503 int64_t raw= audio_size + video_size + extra_size;
1504 fprintf(stderr, "\n");
1505 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1509 100.0*(total_size - raw)/raw
1514 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1516 int fill_char = 0x00;
1517 if (sample_fmt == AV_SAMPLE_FMT_U8)
1519 memset(buf, fill_char, size);
1522 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1526 for (i = 0; i < nb_ostreams; i++) {
1527 OutputStream *ost = &ost_table[i];
1528 AVCodecContext *enc = ost->st->codec;
1529 AVFormatContext *os = output_files[ost->file_index].ctx;
1531 if (!ost->encoding_needed)
1534 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1536 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1542 av_init_packet(&pkt);
1543 pkt.stream_index= ost->index;
1545 switch (ost->st->codec->codec_type) {
1546 case AVMEDIA_TYPE_AUDIO:
1547 fifo_bytes = av_fifo_size(ost->fifo);
1549 /* encode any samples remaining in fifo */
1550 if (fifo_bytes > 0) {
1551 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1552 int fs_tmp = enc->frame_size;
1554 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1555 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1556 enc->frame_size = fifo_bytes / (osize * enc->channels);
1558 int frame_bytes = enc->frame_size*osize*enc->channels;
1559 if (allocated_audio_buf_size < frame_bytes)
1561 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1564 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1565 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1566 ost->st->time_base.num, enc->sample_rate);
1567 enc->frame_size = fs_tmp;
1570 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1573 fprintf(stderr, "Audio encoding failed\n");
1577 pkt.flags |= AV_PKT_FLAG_KEY;
1579 case AVMEDIA_TYPE_VIDEO:
1580 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1582 fprintf(stderr, "Video encoding failed\n");
1586 if(enc->coded_frame && enc->coded_frame->key_frame)
1587 pkt.flags |= AV_PKT_FLAG_KEY;
1588 if (ost->logfile && enc->stats_out) {
1589 fprintf(ost->logfile, "%s", enc->stats_out);
1598 pkt.data = bit_buffer;
1600 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1601 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1602 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1607 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1608 static int output_packet(InputStream *ist, int ist_index,
1609 OutputStream *ost_table, int nb_ostreams,
1610 const AVPacket *pkt)
1612 AVFormatContext *os;
1617 void *buffer_to_free = NULL;
1618 static unsigned int samples_size= 0;
1619 AVSubtitle subtitle, *subtitle_to_free;
1620 int64_t pkt_pts = AV_NOPTS_VALUE;
1622 int frame_available;
1627 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1629 if(ist->next_pts == AV_NOPTS_VALUE)
1630 ist->next_pts= ist->pts;
1634 av_init_packet(&avpkt);
1642 if(pkt->dts != AV_NOPTS_VALUE)
1643 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1644 if(pkt->pts != AV_NOPTS_VALUE)
1645 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1647 //while we have more to decode or while the decoder did output something on EOF
1648 while (avpkt.size > 0 || (!pkt && got_output)) {
1649 uint8_t *data_buf, *decoded_data_buf;
1650 int data_size, decoded_data_size;
1652 ist->pts= ist->next_pts;
1654 if(avpkt.size && avpkt.size != pkt->size &&
1655 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1656 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1657 ist->showed_multi_packet_warning=1;
1660 /* decode the packet if needed */
1661 decoded_data_buf = NULL; /* fail safe */
1662 decoded_data_size= 0;
1663 data_buf = avpkt.data;
1664 data_size = avpkt.size;
1665 subtitle_to_free = NULL;
1666 if (ist->decoding_needed) {
1667 switch(ist->st->codec->codec_type) {
1668 case AVMEDIA_TYPE_AUDIO:{
1669 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1670 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1672 samples= av_malloc(samples_size);
1674 decoded_data_size= samples_size;
1675 /* XXX: could avoid copy if PCM 16 bits with same
1676 endianness as CPU */
1677 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1684 got_output = decoded_data_size > 0;
1685 /* Some bug in mpeg audio decoder gives */
1686 /* decoded_data_size < 0, it seems they are overflows */
1688 /* no audio frame */
1691 decoded_data_buf = (uint8_t *)samples;
1692 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1693 (ist->st->codec->sample_rate * ist->st->codec->channels);
1695 case AVMEDIA_TYPE_VIDEO:
1696 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1697 /* XXX: allocate picture correctly */
1698 avcodec_get_frame_defaults(&picture);
1699 avpkt.pts = pkt_pts;
1700 avpkt.dts = ist->pts;
1701 pkt_pts = AV_NOPTS_VALUE;
1703 ret = avcodec_decode_video2(ist->st->codec,
1704 &picture, &got_output, &avpkt);
1705 quality = same_quant ? picture.quality : 0;
1709 /* no picture yet */
1710 goto discard_packet;
1712 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1713 if (ist->st->codec->time_base.num != 0) {
1714 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1715 ist->next_pts += ((int64_t)AV_TIME_BASE *
1716 ist->st->codec->time_base.num * ticks) /
1717 ist->st->codec->time_base.den;
1720 buffer_to_free = NULL;
1721 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1723 case AVMEDIA_TYPE_SUBTITLE:
1724 ret = avcodec_decode_subtitle2(ist->st->codec,
1725 &subtitle, &got_output, &avpkt);
1729 goto discard_packet;
1731 subtitle_to_free = &subtitle;
1738 switch(ist->st->codec->codec_type) {
1739 case AVMEDIA_TYPE_AUDIO:
1740 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1741 ist->st->codec->sample_rate;
1743 case AVMEDIA_TYPE_VIDEO:
1744 if (ist->st->codec->time_base.num != 0) {
1745 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1746 ist->next_pts += ((int64_t)AV_TIME_BASE *
1747 ist->st->codec->time_base.num * ticks) /
1748 ist->st->codec->time_base.den;
1756 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1757 for(i=0;i<nb_ostreams;i++) {
1758 OutputFile *of = &output_files[ost_table[i].file_index];
1759 if (of->start_time == 0 || ist->pts >= of->start_time) {
1760 ost = &ost_table[i];
1761 if (ost->input_video_filter && ost->source_index == ist_index) {
1762 if (!picture.sample_aspect_ratio.num)
1763 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1764 picture.pts = ist->pts;
1766 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1772 // preprocess audio (volume)
1773 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1774 if (audio_volume != 256) {
1777 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1778 int v = ((*volp) * audio_volume + 128) >> 8;
1779 *volp++ = av_clip_int16(v);
1784 /* frame rate emulation */
1785 if (input_files[ist->file_index].rate_emu) {
1786 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1787 int64_t now = av_gettime() - ist->start;
1791 /* if output time reached then transcode raw format,
1792 encode packets and output them */
1793 for (i = 0; i < nb_ostreams; i++) {
1794 OutputFile *of = &output_files[ost_table[i].file_index];
1797 ost = &ost_table[i];
1798 if (ost->source_index != ist_index)
1801 if (of->start_time && ist->pts < of->start_time)
1804 if (of->recording_time != INT64_MAX &&
1805 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1806 (AVRational){1, 1000000}) >= 0) {
1807 ost->is_past_recording_time = 1;
1812 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1813 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1814 while (frame_available) {
1815 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1816 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1817 if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1820 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1821 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1825 os = output_files[ost->file_index].ctx;
1827 /* set the input output pts pairs */
1828 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1830 if (ost->encoding_needed) {
1831 av_assert0(ist->decoding_needed);
1832 switch(ost->st->codec->codec_type) {
1833 case AVMEDIA_TYPE_AUDIO:
1834 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1836 case AVMEDIA_TYPE_VIDEO:
1838 if (ost->picref->video && !ost->frame_aspect_ratio)
1839 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1841 do_video_out(os, ost, ist, &picture, &frame_size,
1842 same_quant ? quality : ost->st->codec->global_quality);
1843 if (vstats_filename && frame_size)
1844 do_video_stats(os, ost, frame_size);
1846 case AVMEDIA_TYPE_SUBTITLE:
1847 do_subtitle_out(os, ost, ist, &subtitle,
1854 AVFrame avframe; //FIXME/XXX remove this
1857 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1858 av_init_packet(&opkt);
1860 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1861 #if !CONFIG_AVFILTER
1867 /* no reencoding needed : output the packet directly */
1868 /* force the input stream PTS */
1870 avcodec_get_frame_defaults(&avframe);
1871 ost->st->codec->coded_frame= &avframe;
1872 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1874 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1875 audio_size += data_size;
1876 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1877 video_size += data_size;
1881 opkt.stream_index= ost->index;
1882 if(pkt->pts != AV_NOPTS_VALUE)
1883 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1885 opkt.pts= AV_NOPTS_VALUE;
1887 if (pkt->dts == AV_NOPTS_VALUE)
1888 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1890 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1891 opkt.dts -= ost_tb_start_time;
1893 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1894 opkt.flags= pkt->flags;
1896 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1897 if( ost->st->codec->codec_id != CODEC_ID_H264
1898 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1899 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1901 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1902 opkt.destruct= av_destruct_packet;
1904 opkt.data = data_buf;
1905 opkt.size = data_size;
1908 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1909 /* store AVPicture in AVPacket, as expected by the output format */
1910 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1911 opkt.data = (uint8_t *)&pict;
1912 opkt.size = sizeof(AVPicture);
1913 opkt.flags |= AV_PKT_FLAG_KEY;
1915 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1916 ost->st->codec->frame_number++;
1917 ost->frame_number++;
1918 av_free_packet(&opkt);
1922 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1923 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1924 avfilter_unref_buffer(ost->picref);
1929 av_free(buffer_to_free);
1930 /* XXX: allocate the subtitles in the codec ? */
1931 if (subtitle_to_free) {
1932 avsubtitle_free(subtitle_to_free);
1933 subtitle_to_free = NULL;
1941 static void print_sdp(OutputFile *output_files, int n)
1945 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1949 for (i = 0; i < n; i++)
1950 avc[i] = output_files[i].ctx;
1952 av_sdp_create(avc, n, sdp, sizeof(sdp));
1953 printf("SDP:\n%s\n", sdp);
1958 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1959 char *error, int error_len)
1961 InputStream *ist = &input_streams[ist_index];
1962 if (ist->decoding_needed) {
1963 AVCodec *codec = ist->dec;
1965 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
1966 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1967 return AVERROR(EINVAL);
1969 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1970 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1971 ist->file_index, ist->st->index);
1972 return AVERROR(EINVAL);
1974 assert_codec_experimental(ist->st->codec, 0);
1975 assert_avoptions(ist->opts);
1978 ist->pts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames*AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1979 ist->next_pts = AV_NOPTS_VALUE;
1985 static int transcode_init(OutputFile *output_files,
1986 int nb_output_files,
1987 InputFile *input_files,
1991 AVFormatContext *os;
1992 AVCodecContext *codec, *icodec;
1998 /* init framerate emulation */
1999 for (i = 0; i < nb_input_files; i++) {
2000 InputFile *ifile = &input_files[i];
2001 if (ifile->rate_emu)
2002 for (j = 0; j < ifile->nb_streams; j++)
2003 input_streams[j + ifile->ist_index].start = av_gettime();
2006 /* output stream init */
2007 for(i=0;i<nb_output_files;i++) {
2008 os = output_files[i].ctx;
2009 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2010 av_dump_format(os, i, os->filename, 1);
2011 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2012 return AVERROR(EINVAL);
2016 /* for each output stream, we compute the right encoding parameters */
2017 for (i = 0; i < nb_output_streams; i++) {
2018 ost = &output_streams[i];
2019 os = output_files[ost->file_index].ctx;
2020 ist = &input_streams[ost->source_index];
2022 codec = ost->st->codec;
2023 icodec = ist->st->codec;
2025 ost->st->disposition = ist->st->disposition;
2026 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2027 codec->chroma_sample_location = icodec->chroma_sample_location;
2029 if (ost->st->stream_copy) {
2030 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2032 if (extra_size > INT_MAX) {
2033 return AVERROR(EINVAL);
2036 /* if stream_copy is selected, no need to decode or encode */
2037 codec->codec_id = icodec->codec_id;
2038 codec->codec_type = icodec->codec_type;
2040 if(!codec->codec_tag){
2041 if( !os->oformat->codec_tag
2042 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2043 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2044 codec->codec_tag = icodec->codec_tag;
2047 codec->bit_rate = icodec->bit_rate;
2048 codec->rc_max_rate = icodec->rc_max_rate;
2049 codec->rc_buffer_size = icodec->rc_buffer_size;
2050 codec->extradata= av_mallocz(extra_size);
2051 if (!codec->extradata) {
2052 return AVERROR(ENOMEM);
2054 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2055 codec->extradata_size= icodec->extradata_size;
2057 codec->time_base = ist->st->time_base;
2058 if(!strcmp(os->oformat->name, "avi")) {
2059 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2060 codec->time_base = icodec->time_base;
2061 codec->time_base.num *= icodec->ticks_per_frame;
2062 codec->time_base.den *= 2;
2064 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2065 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2066 codec->time_base = icodec->time_base;
2067 codec->time_base.num *= icodec->ticks_per_frame;
2070 av_reduce(&codec->time_base.num, &codec->time_base.den,
2071 codec->time_base.num, codec->time_base.den, INT_MAX);
2073 switch(codec->codec_type) {
2074 case AVMEDIA_TYPE_AUDIO:
2075 if(audio_volume != 256) {
2076 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2079 codec->channel_layout = icodec->channel_layout;
2080 codec->sample_rate = icodec->sample_rate;
2081 codec->channels = icodec->channels;
2082 codec->frame_size = icodec->frame_size;
2083 codec->audio_service_type = icodec->audio_service_type;
2084 codec->block_align= icodec->block_align;
2085 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2086 codec->block_align= 0;
2087 if(codec->codec_id == CODEC_ID_AC3)
2088 codec->block_align= 0;
2090 case AVMEDIA_TYPE_VIDEO:
2091 codec->pix_fmt = icodec->pix_fmt;
2092 codec->width = icodec->width;
2093 codec->height = icodec->height;
2094 codec->has_b_frames = icodec->has_b_frames;
2095 if (!codec->sample_aspect_ratio.num) {
2096 codec->sample_aspect_ratio =
2097 ost->st->sample_aspect_ratio =
2098 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2099 ist->st->codec->sample_aspect_ratio.num ?
2100 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2103 case AVMEDIA_TYPE_SUBTITLE:
2104 codec->width = icodec->width;
2105 codec->height = icodec->height;
2107 case AVMEDIA_TYPE_DATA:
2114 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2115 switch(codec->codec_type) {
2116 case AVMEDIA_TYPE_AUDIO:
2117 ost->fifo= av_fifo_alloc(1024);
2119 return AVERROR(ENOMEM);
2121 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2122 if (!codec->sample_rate) {
2123 codec->sample_rate = icodec->sample_rate;
2125 choose_sample_rate(ost->st, ost->enc);
2126 codec->time_base = (AVRational){1, codec->sample_rate};
2127 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2128 codec->sample_fmt = icodec->sample_fmt;
2129 choose_sample_fmt(ost->st, ost->enc);
2130 if (!codec->channels) {
2131 codec->channels = icodec->channels;
2132 codec->channel_layout = icodec->channel_layout;
2134 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2135 codec->channel_layout = 0;
2136 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2137 icodec->request_channels = codec->channels;
2138 ist->decoding_needed = 1;
2139 ost->encoding_needed = 1;
2140 ost->resample_sample_fmt = icodec->sample_fmt;
2141 ost->resample_sample_rate = icodec->sample_rate;
2142 ost->resample_channels = icodec->channels;
2144 case AVMEDIA_TYPE_VIDEO:
2145 if (codec->pix_fmt == PIX_FMT_NONE)
2146 codec->pix_fmt = icodec->pix_fmt;
2147 choose_pixel_fmt(ost->st, ost->enc);
2149 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2150 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2154 if (!codec->width || !codec->height) {
2155 codec->width = icodec->width;
2156 codec->height = icodec->height;
2159 ost->video_resample = codec->width != icodec->width ||
2160 codec->height != icodec->height ||
2161 codec->pix_fmt != icodec->pix_fmt;
2162 if (ost->video_resample) {
2163 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2166 ost->resample_height = icodec->height;
2167 ost->resample_width = icodec->width;
2168 ost->resample_pix_fmt= icodec->pix_fmt;
2169 ost->encoding_needed = 1;
2170 ist->decoding_needed = 1;
2172 if (!ost->frame_rate.num)
2173 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2174 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2175 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2176 ost->frame_rate = ost->enc->supported_framerates[idx];
2178 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2179 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2180 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2181 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2182 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2186 if (configure_video_filters(ist, ost)) {
2187 fprintf(stderr, "Error opening filters!\n");
2192 case AVMEDIA_TYPE_SUBTITLE:
2193 ost->encoding_needed = 1;
2194 ist->decoding_needed = 1;
2201 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2202 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2203 char logfilename[1024];
2206 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2207 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2209 if (codec->flags & CODEC_FLAG_PASS1) {
2210 f = fopen(logfilename, "wb");
2212 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2218 size_t logbuffer_size;
2219 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2220 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2223 codec->stats_in = logbuffer;
2227 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2228 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2229 int size= codec->width * codec->height;
2230 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2235 bit_buffer = av_malloc(bit_buffer_size);
2237 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2239 return AVERROR(ENOMEM);
2242 /* open each encoder */
2243 for (i = 0; i < nb_output_streams; i++) {
2244 ost = &output_streams[i];
2245 if (ost->encoding_needed) {
2246 AVCodec *codec = ost->enc;
2247 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2249 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2250 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2251 ret = AVERROR(EINVAL);
2254 if (dec->subtitle_header) {
2255 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2256 if (!ost->st->codec->subtitle_header) {
2257 ret = AVERROR(ENOMEM);
2260 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2261 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2263 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2264 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2265 ost->file_index, ost->index);
2266 ret = AVERROR(EINVAL);
2269 assert_codec_experimental(ost->st->codec, 1);
2270 assert_avoptions(ost->opts);
2271 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2272 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2273 "It takes bits/s as argument, not kbits/s\n");
2274 extra_size += ost->st->codec->extradata_size;
2278 /* init input streams */
2279 for (i = 0; i < nb_input_streams; i++)
2280 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2283 /* open files and write file headers */
2284 for (i = 0; i < nb_output_files; i++) {
2285 os = output_files[i].ctx;
2286 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2287 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2288 ret = AVERROR(EINVAL);
2291 // assert_avoptions(output_files[i].opts);
2292 if (strcmp(os->oformat->name, "rtp")) {
2298 /* dump the file output parameters - cannot be done before in case
2300 for(i=0;i<nb_output_files;i++) {
2301 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2304 /* dump the stream mapping */
2306 fprintf(stderr, "Stream mapping:\n");
2307 for (i = 0; i < nb_output_streams;i ++) {
2308 ost = &output_streams[i];
2309 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2310 input_streams[ost->source_index].file_index,
2311 input_streams[ost->source_index].st->index,
2314 if (ost->sync_ist != &input_streams[ost->source_index])
2315 fprintf(stderr, " [sync #%d.%d]",
2316 ost->sync_ist->file_index,
2317 ost->sync_ist->st->index);
2318 if (ost->st->stream_copy)
2319 fprintf(stderr, " (copy)");
2321 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2322 input_streams[ost->source_index].dec->name : "?",
2323 ost->enc ? ost->enc->name : "?");
2324 fprintf(stderr, "\n");
2329 fprintf(stderr, "%s\n", error);
2334 print_sdp(output_files, nb_output_files);
2341 * The following code is the main loop of the file converter
2343 static int transcode(OutputFile *output_files,
2344 int nb_output_files,
2345 InputFile *input_files,
2349 AVFormatContext *is, *os;
2353 int no_packet_count=0;
2354 int64_t timer_start;
2357 if (!(no_packet = av_mallocz(nb_input_files)))
2360 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2366 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2367 avio_set_interrupt_cb(decode_interrupt_cb);
2371 timer_start = av_gettime();
2373 for(; received_sigterm == 0;) {
2374 int file_index, ist_index;
2379 ipts_min= INT64_MAX;
2381 /* if 'q' pressed, exits */
2385 /* read_key() returns 0 on EOF */
2389 if (key == '+') verbose++;
2390 if (key == '-') verbose--;
2391 if (key == 's') qp_hist ^= 1;
2394 do_hex_dump = do_pkt_dump = 0;
2395 } else if(do_pkt_dump){
2399 av_log_set_level(AV_LOG_DEBUG);
2402 if (key == 'c' || key == 'C'){
2403 char ret[4096], target[64], cmd[256], arg[256]={0};
2406 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2408 while((k=read_key()) !='\n' && k!='\r' && i<sizeof(ret)-1)
2409 if(k>0) ret[i++]= k;
2411 if(k>0 && sscanf(ret, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &ts, cmd, arg) >= 3){
2412 for(i=0;i<nb_output_streams;i++) {
2414 ost = &output_streams[i];
2417 r= avfilter_graph_send_command(ost->graph, target, cmd, arg, ret, sizeof(ret), key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2418 fprintf(stderr, "Command reply for %d: %d, %s\n", i, r, ret);
2420 r= avfilter_graph_queue_command(ost->graph, target, cmd, arg, 0, ts);
2425 fprintf(stderr, "Parse error\n");
2429 if (key == 'd' || key == 'D'){
2432 debug = input_streams[0].st->codec->debug<<1;
2433 if(!debug) debug = 1;
2434 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2437 scanf("%d", &debug);
2438 for(i=0;i<nb_input_streams;i++) {
2439 input_streams[i].st->codec->debug = debug;
2441 for(i=0;i<nb_output_streams;i++) {
2442 ost = &output_streams[i];
2443 ost->st->codec->debug = debug;
2445 if(debug) av_log_set_level(AV_LOG_DEBUG);
2446 fprintf(stderr,"debug=%d\n", debug);
2449 fprintf(stderr, "key function\n"
2450 "? show this help\n"
2451 "+ increase verbosity\n"
2452 "- decrease verbosity\n"
2453 "c Send command to filtergraph\n"
2454 "D cycle through available debug modes\n"
2455 "h dump packets/hex press to cycle through the 3 states\n"
2457 "s Show QP histogram\n"
2462 /* select the stream that we must read now by looking at the
2463 smallest output pts */
2465 for (i = 0; i < nb_output_streams; i++) {
2469 ost = &output_streams[i];
2470 of = &output_files[ost->file_index];
2471 os = output_files[ost->file_index].ctx;
2472 ist = &input_streams[ost->source_index];
2473 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2474 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2476 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2478 if (!input_files[ist->file_index].eof_reached){
2479 if(ipts < ipts_min) {
2481 if(input_sync ) file_index = ist->file_index;
2483 if(opts < opts_min) {
2485 if(!input_sync) file_index = ist->file_index;
2488 if (ost->frame_number >= ost->max_frames) {
2490 for (j = of->ost_index; j < of->ctx->nb_streams; j++)
2491 output_streams[j].is_past_recording_time = 1;
2495 /* if none, if is finished */
2496 if (file_index < 0) {
2497 if(no_packet_count){
2499 memset(no_packet, 0, nb_input_files);
2506 /* read a frame from it and output it in the fifo */
2507 is = input_files[file_index].ctx;
2508 ret= av_read_frame(is, &pkt);
2509 if(ret == AVERROR(EAGAIN)){
2510 no_packet[file_index]=1;
2515 input_files[file_index].eof_reached = 1;
2523 memset(no_packet, 0, nb_input_files);
2526 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2527 is->streams[pkt.stream_index]);
2529 /* the following test is needed in case new streams appear
2530 dynamically in stream : we ignore them */
2531 if (pkt.stream_index >= input_files[file_index].nb_streams)
2532 goto discard_packet;
2533 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2534 ist = &input_streams[ist_index];
2536 goto discard_packet;
2538 if (pkt.dts != AV_NOPTS_VALUE)
2539 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2540 if (pkt.pts != AV_NOPTS_VALUE)
2541 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2543 if(pkt.pts != AV_NOPTS_VALUE)
2544 pkt.pts *= ist->ts_scale;
2545 if(pkt.dts != AV_NOPTS_VALUE)
2546 pkt.dts *= ist->ts_scale;
2548 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2549 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2550 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2551 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2552 int64_t delta= pkt_dts - ist->next_pts;
2553 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2554 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2555 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2556 pkt_dts+1<ist->pts)&& !copy_ts){
2557 input_files[ist->file_index].ts_offset -= delta;
2559 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2560 delta, input_files[ist->file_index].ts_offset);
2561 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2562 if(pkt.pts != AV_NOPTS_VALUE)
2563 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2567 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2568 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2571 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2572 ist->file_index, ist->st->index);
2575 av_free_packet(&pkt);
2580 av_free_packet(&pkt);
2582 /* dump report by using the output first video and audio streams */
2583 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2586 /* at the end of stream, we must flush the decoder buffers */
2587 for (i = 0; i < nb_input_streams; i++) {
2588 ist = &input_streams[i];
2589 if (ist->decoding_needed) {
2590 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2593 flush_encoders(output_streams, nb_output_streams);
2597 /* write the trailer if needed and close file */
2598 for(i=0;i<nb_output_files;i++) {
2599 os = output_files[i].ctx;
2600 av_write_trailer(os);
2603 /* dump report by using the first video and audio streams */
2604 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2606 /* close each encoder */
2607 for (i = 0; i < nb_output_streams; i++) {
2608 ost = &output_streams[i];
2609 if (ost->encoding_needed) {
2610 av_freep(&ost->st->codec->stats_in);
2611 avcodec_close(ost->st->codec);
2614 avfilter_graph_free(&ost->graph);
2618 /* close each decoder */
2619 for (i = 0; i < nb_input_streams; i++) {
2620 ist = &input_streams[i];
2621 if (ist->decoding_needed) {
2622 avcodec_close(ist->st->codec);
2630 av_freep(&bit_buffer);
2631 av_freep(&no_packet);
2633 if (output_streams) {
2634 for (i = 0; i < nb_output_streams; i++) {
2635 ost = &output_streams[i];
2637 if (ost->st->stream_copy)
2638 av_freep(&ost->st->codec->extradata);
2640 fclose(ost->logfile);
2641 ost->logfile = NULL;
2643 av_fifo_free(ost->fifo); /* works even if fifo is not
2644 initialized but set to zero */
2645 av_freep(&ost->st->codec->subtitle_header);
2646 av_free(ost->resample_frame.data[0]);
2647 av_free(ost->forced_kf_pts);
2648 if (ost->video_resample)
2649 sws_freeContext(ost->img_resample_ctx);
2651 audio_resample_close(ost->resample);
2652 if (ost->reformat_ctx)
2653 av_audio_convert_free(ost->reformat_ctx);
2654 av_dict_free(&ost->opts);
2661 static int opt_video_rc_override_string(const char *opt, const char *arg)
2663 video_rc_override_string = arg;
2667 static int opt_me_threshold(const char *opt, const char *arg)
2669 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2673 static int opt_verbose(const char *opt, const char *arg)
2675 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2679 static int opt_frame_rate(const char *opt, const char *arg)
2681 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2682 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2688 static int opt_frame_crop(const char *opt, const char *arg)
2690 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2691 return AVERROR(EINVAL);
2694 static int opt_frame_size(const char *opt, const char *arg)
2696 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2697 fprintf(stderr, "Incorrect frame size\n");
2698 return AVERROR(EINVAL);
2703 static int opt_pad(const char *opt, const char *arg) {
2704 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2708 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2710 if (strcmp(arg, "list")) {
2711 frame_pix_fmt = av_get_pix_fmt(arg);
2712 if (frame_pix_fmt == PIX_FMT_NONE) {
2713 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2714 return AVERROR(EINVAL);
2717 opt_pix_fmts(NULL, NULL);
2723 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2730 p = strchr(arg, ':');
2732 x = strtol(arg, &end, 10);
2734 y = strtol(end+1, &end, 10);
2736 ar = (double)x / (double)y;
2738 ar = strtod(arg, NULL);
2741 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2742 return AVERROR(EINVAL);
2744 frame_aspect_ratio = ar;
2748 static int opt_qscale(const char *opt, const char *arg)
2750 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2751 if (video_qscale <= 0 || video_qscale > 255) {
2752 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2753 return AVERROR(EINVAL);
2758 static int opt_top_field_first(const char *opt, const char *arg)
2760 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2761 return opt_default(opt, arg);
2764 static int opt_thread_count(const char *opt, const char *arg)
2766 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2769 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2774 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2776 if (strcmp(arg, "list")) {
2777 audio_sample_fmt = av_get_sample_fmt(arg);
2778 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2779 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2780 return AVERROR(EINVAL);
2785 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2786 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2792 static int opt_audio_rate(const char *opt, const char *arg)
2794 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2798 static int opt_audio_channels(const char *opt, const char *arg)
2800 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2804 static int opt_video_channel(const char *opt, const char *arg)
2806 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2807 return opt_default("channel", arg);
2810 static int opt_video_standard(const char *opt, const char *arg)
2812 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2813 return opt_default("standard", arg);
2816 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2818 audio_codec_name = arg;
2819 return parse_option(o, "codec:a", arg, options);
2822 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2824 video_codec_name = arg;
2825 return parse_option(o, "codec:v", arg, options);
2828 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2830 subtitle_codec_name = arg;
2831 return parse_option(o, "codec:s", arg, options);
2834 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2836 return parse_option(o, "codec:d", arg, options);
2839 static int opt_codec_tag(const char *opt, const char *arg)
2842 uint32_t *codec_tag;
2844 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2845 !strcmp(opt, "vtag") ? &video_codec_tag :
2846 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2850 *codec_tag = strtol(arg, &tail, 0);
2852 *codec_tag = AV_RL32(arg);
2857 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2859 StreamMap *m = NULL;
2860 int i, negative = 0, file_idx;
2861 int sync_file_idx = -1, sync_stream_idx;
2869 map = av_strdup(arg);
2871 /* parse sync stream first, just pick first matching stream */
2872 if (sync = strchr(map, ',')) {
2874 sync_file_idx = strtol(sync + 1, &sync, 0);
2875 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2876 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2881 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2882 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2883 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2884 sync_stream_idx = i;
2887 if (i == input_files[sync_file_idx].nb_streams) {
2888 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2889 "match any streams.\n", arg);
2895 file_idx = strtol(map, &p, 0);
2896 if (file_idx >= nb_input_files || file_idx < 0) {
2897 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2901 /* disable some already defined maps */
2902 for (i = 0; i < o->nb_stream_maps; i++) {
2903 m = &o->stream_maps[i];
2904 if (check_stream_specifier(input_files[m->file_index].ctx,
2905 input_files[m->file_index].ctx->streams[m->stream_index],
2906 *p == ':' ? p + 1 : p) > 0)
2910 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2911 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2912 *p == ':' ? p + 1 : p) <= 0)
2914 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2915 &o->nb_stream_maps, o->nb_stream_maps + 1);
2916 m = &o->stream_maps[o->nb_stream_maps - 1];
2918 m->file_index = file_idx;
2919 m->stream_index = i;
2921 if (sync_file_idx >= 0) {
2922 m->sync_file_index = sync_file_idx;
2923 m->sync_stream_index = sync_stream_idx;
2925 m->sync_file_index = file_idx;
2926 m->sync_stream_index = i;
2931 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2939 static void parse_meta_type(char *arg, char *type, int *index)
2949 if (*(++arg) == ':')
2950 *index = strtol(++arg, NULL, 0);
2953 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2960 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2962 MetadataMap *m, *m1;
2965 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2966 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2968 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2969 m->file = strtol(arg, &p, 0);
2970 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2972 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2973 if (p = strchr(opt, ':'))
2974 parse_meta_type(p + 1, &m1->type, &m1->index);
2978 if (m->type == 'g' || m1->type == 'g')
2979 o->metadata_global_manual = 1;
2980 if (m->type == 's' || m1->type == 's')
2981 o->metadata_streams_manual = 1;
2982 if (m->type == 'c' || m1->type == 'c')
2983 o->metadata_chapters_manual = 1;
2988 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2990 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2991 "Use -map_metadata instead.\n");
2992 return opt_map_metadata(o, opt, arg);
2995 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
2998 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2999 struct tm time = *gmtime((time_t*)&recording_timestamp);
3000 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3001 parse_option(o, "metadata", buf, options);
3003 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3004 "tag instead.\n", opt);
3008 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3010 const char *codec_string = encoder ? "encoder" : "decoder";
3014 return CODEC_ID_NONE;
3016 avcodec_find_encoder_by_name(name) :
3017 avcodec_find_decoder_by_name(name);
3019 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
3022 if(codec->type != type) {
3023 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
3029 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
3031 char *codec_name = NULL;
3033 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3037 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
3038 return avcodec_find_encoder(st->codec->codec_id);
3040 } else if (!strcmp(codec_name, "copy"))
3041 st->stream_copy = 1;
3043 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
3044 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
3045 avcodec_find_decoder_by_name(codec_name);
3052 * Add all the streams from the given input file to the global
3053 * list of input streams.
3055 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3057 int i, rfps, rfps_base;
3059 for (i = 0; i < ic->nb_streams; i++) {
3060 AVStream *st = ic->streams[i];
3061 AVCodecContext *dec = st->codec;
3065 dec->thread_count = thread_count;
3067 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3068 ist = &input_streams[nb_input_streams - 1];
3070 ist->file_index = nb_input_files;
3072 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3074 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
3075 ist->ts_scale = scale;
3077 ist->dec = choose_codec(o, ic, st, dec->codec_type);
3079 ist->dec = avcodec_find_decoder(dec->codec_id);
3081 switch (dec->codec_type) {
3082 case AVMEDIA_TYPE_AUDIO:
3084 ist->dec = avcodec_find_decoder(dec->codec_id);
3086 st->discard= AVDISCARD_ALL;
3088 case AVMEDIA_TYPE_VIDEO:
3090 ist->dec = avcodec_find_decoder(dec->codec_id);
3091 rfps = ic->streams[i]->r_frame_rate.num;
3092 rfps_base = ic->streams[i]->r_frame_rate.den;
3094 dec->flags |= CODEC_FLAG_EMU_EDGE;
3097 dec->debug |= FF_DEBUG_MV;
3099 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3102 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3103 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3105 (float)rfps / rfps_base, rfps, rfps_base);
3109 st->discard= AVDISCARD_ALL;
3110 else if(video_discard)
3111 st->discard= video_discard;
3113 case AVMEDIA_TYPE_DATA:
3115 case AVMEDIA_TYPE_SUBTITLE:
3117 ist->dec = avcodec_find_decoder(dec->codec_id);
3118 if(subtitle_disable)
3119 st->discard = AVDISCARD_ALL;
3121 case AVMEDIA_TYPE_ATTACHMENT:
3122 case AVMEDIA_TYPE_UNKNOWN:
3130 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3132 AVFormatContext *ic;
3133 AVInputFormat *file_iformat = NULL;
3137 AVDictionary **opts;
3138 int orig_nb_streams; // number of streams before avformat_find_stream_info
3141 if (!(file_iformat = av_find_input_format(o->format))) {
3142 fprintf(stderr, "Unknown input format: '%s'\n", o->format);
3147 if (!strcmp(filename, "-"))
3150 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3151 !strcmp(filename, "/dev/stdin");
3153 /* get default parameters from command line */
3154 ic = avformat_alloc_context();
3156 print_error(filename, AVERROR(ENOMEM));
3159 if (audio_sample_rate) {
3160 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3161 av_dict_set(&format_opts, "sample_rate", buf, 0);
3163 if (audio_channels) {
3164 snprintf(buf, sizeof(buf), "%d", audio_channels);
3165 av_dict_set(&format_opts, "channels", buf, 0);
3167 if (frame_rate.num) {
3168 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3169 av_dict_set(&format_opts, "framerate", buf, 0);
3171 if (frame_width && frame_height) {
3172 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3173 av_dict_set(&format_opts, "video_size", buf, 0);
3175 if (frame_pix_fmt != PIX_FMT_NONE)
3176 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3178 ic->flags |= AVFMT_FLAG_NONBLOCK;
3181 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3182 ic->loop_input = loop_input;
3185 /* open the input file with generic libav function */
3186 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3188 print_error(filename, err);
3191 assert_avoptions(format_opts);
3196 for(i=0; i<ic->nb_streams; i++){
3197 ic->streams[i]->discard= AVDISCARD_ALL;
3199 for(i=0; i<ic->nb_programs; i++){
3200 AVProgram *p= ic->programs[i];
3201 if(p->id != opt_programid){
3202 p->discard = AVDISCARD_ALL;
3205 for(j=0; j<p->nb_stream_indexes; j++){
3206 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3211 fprintf(stderr, "Specified program id not found\n");
3217 /* apply forced codec ids */
3218 for (i = 0; i < ic->nb_streams; i++)
3219 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3221 /* Set AVCodecContext options for avformat_find_stream_info */
3222 opts = setup_find_stream_info_opts(ic, codec_opts);
3223 orig_nb_streams = ic->nb_streams;
3225 /* If not enough info to get the stream parameters, we decode the
3226 first frames to get it. (used in mpeg case for example) */
3227 ret = avformat_find_stream_info(ic, opts);
3228 if (ret < 0 && verbose >= 0) {
3229 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3230 av_close_input_file(ic);
3234 timestamp = o->start_time;
3235 /* add the stream start time */
3236 if (ic->start_time != AV_NOPTS_VALUE)
3237 timestamp += ic->start_time;
3239 /* if seeking requested, we execute it */
3240 if (o->start_time != 0) {
3241 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3243 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3244 filename, (double)timestamp / AV_TIME_BASE);
3248 /* update the current parameters so that they match the one of the input stream */
3249 add_input_streams(o, ic);
3251 /* dump the file content */
3253 av_dump_format(ic, nb_input_files, filename, 0);
3255 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3256 input_files[nb_input_files - 1].ctx = ic;
3257 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3258 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3259 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3261 top_field_first = -1;
3262 frame_rate = (AVRational){0, 0};
3263 frame_pix_fmt = PIX_FMT_NONE;
3266 audio_sample_rate = 0;
3268 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3270 for (i = 0; i < orig_nb_streams; i++)
3271 av_dict_free(&opts[i]);
3274 reset_options(o, 1);
3278 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3279 AVCodecContext *avctx)
3285 for (p = kf; *p; p++)
3288 ost->forced_kf_count = n;
3289 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3290 if (!ost->forced_kf_pts) {
3291 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3294 for (i = 0; i < n; i++) {
3295 p = i ? strchr(p, ',') + 1 : kf;
3296 t = parse_time_or_die("force_key_frames", p, 1);
3297 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3301 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3304 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3305 int idx = oc->nb_streams - 1;
3306 int64_t max_frames = INT64_MAX;
3307 char *bsf = NULL, *next;
3308 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3311 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3315 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3316 nb_output_streams + 1);
3317 ost = &output_streams[nb_output_streams - 1];
3318 ost->file_index = nb_output_files;
3321 st->codec->codec_type = type;
3322 ost->enc = choose_codec(o, oc, st, type);
3324 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3327 avcodec_get_context_defaults3(st->codec, ost->enc);
3328 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3330 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3331 ost->max_frames = max_frames;
3333 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3335 if (next = strchr(bsf, ','))
3337 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3338 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter %s\n", bsf);
3342 bsfc_prev->next = bsfc;
3344 ost->bitstream_filters = bsfc;
3350 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3354 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3358 AVCodecContext *video_enc;
3360 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3362 if (!st->stream_copy) {
3363 ost->frame_aspect_ratio = frame_aspect_ratio;
3364 frame_aspect_ratio = 0;
3366 ost->avfilter = vfilters;
3371 st->codec->thread_count= thread_count;
3373 video_enc = st->codec;
3376 video_enc->codec_tag= video_codec_tag;
3378 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3379 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3382 if (st->stream_copy) {
3383 video_enc->sample_aspect_ratio =
3384 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3390 ost->frame_rate = frame_rate;
3392 video_enc->width = frame_width;
3393 video_enc->height = frame_height;
3394 video_enc->pix_fmt = frame_pix_fmt;
3395 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3396 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3399 video_enc->gop_size = 0;
3400 if (video_qscale || same_quant) {
3401 video_enc->flags |= CODEC_FLAG_QSCALE;
3402 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3406 video_enc->intra_matrix = intra_matrix;
3408 video_enc->inter_matrix = inter_matrix;
3410 p= video_rc_override_string;
3413 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3415 fprintf(stderr, "error parsing rc_override\n");
3418 video_enc->rc_override=
3419 av_realloc(video_enc->rc_override,
3420 sizeof(RcOverride)*(i+1));
3421 video_enc->rc_override[i].start_frame= start;
3422 video_enc->rc_override[i].end_frame = end;
3424 video_enc->rc_override[i].qscale= q;
3425 video_enc->rc_override[i].quality_factor= 1.0;
3428 video_enc->rc_override[i].qscale= 0;
3429 video_enc->rc_override[i].quality_factor= -q/100.0;
3434 video_enc->rc_override_count=i;
3435 if (!video_enc->rc_initial_buffer_occupancy)
3436 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3437 video_enc->me_threshold= me_threshold;
3438 video_enc->intra_dc_precision= intra_dc_precision - 8;
3441 video_enc->flags|= CODEC_FLAG_PSNR;
3446 video_enc->flags |= CODEC_FLAG_PASS1;
3448 video_enc->flags |= CODEC_FLAG_PASS2;
3452 if (forced_key_frames)
3453 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3455 if (video_language) {
3456 av_dict_set(&st->metadata, "language", video_language, 0);
3457 av_freep(&video_language);
3460 /* reset some key parameters */
3462 av_freep(&forced_key_frames);
3463 frame_pix_fmt = PIX_FMT_NONE;
3467 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3471 AVCodecContext *audio_enc;
3473 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3476 st->codec->thread_count= thread_count;
3478 audio_enc = st->codec;
3479 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3482 audio_enc->codec_tag= audio_codec_tag;
3484 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3485 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3487 if (!st->stream_copy) {
3488 if (audio_qscale > QSCALE_NONE) {
3489 audio_enc->flags |= CODEC_FLAG_QSCALE;
3490 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3493 audio_enc->channels = audio_channels;
3494 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3495 audio_enc->sample_fmt = audio_sample_fmt;
3496 if (audio_sample_rate)
3497 audio_enc->sample_rate = audio_sample_rate;
3499 if (audio_language) {
3500 av_dict_set(&st->metadata, "language", audio_language, 0);
3501 av_freep(&audio_language);
3504 /* reset some key parameters */
3510 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3514 AVCodecContext *data_enc;
3516 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3518 data_enc = st->codec;
3519 if (!st->stream_copy) {
3520 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3525 data_enc->codec_tag= data_codec_tag;
3527 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3528 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3535 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3539 AVCodecContext *subtitle_enc;
3541 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3543 subtitle_enc = st->codec;
3545 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3547 if(subtitle_codec_tag)
3548 subtitle_enc->codec_tag= subtitle_codec_tag;
3550 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3551 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3554 if (subtitle_language) {
3555 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3556 av_freep(&subtitle_language);
3559 subtitle_disable = 0;
3563 /* arg format is "output-stream-index:streamid-value". */
3564 static int opt_streamid(const char *opt, const char *arg)
3570 av_strlcpy(idx_str, arg, sizeof(idx_str));
3571 p = strchr(idx_str, ':');
3574 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3579 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3580 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3581 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3585 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3587 AVFormatContext *is = ifile->ctx;
3588 AVFormatContext *os = ofile->ctx;
3591 for (i = 0; i < is->nb_chapters; i++) {
3592 AVChapter *in_ch = is->chapters[i], *out_ch;
3593 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3594 AV_TIME_BASE_Q, in_ch->time_base);
3595 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3596 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3599 if (in_ch->end < ts_off)
3601 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3604 out_ch = av_mallocz(sizeof(AVChapter));
3606 return AVERROR(ENOMEM);
3608 out_ch->id = in_ch->id;
3609 out_ch->time_base = in_ch->time_base;
3610 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3611 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3614 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3617 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3619 return AVERROR(ENOMEM);
3620 os->chapters[os->nb_chapters - 1] = out_ch;
3625 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3628 AVFormatContext *ic = NULL;
3630 err = avformat_open_input(&ic, filename, NULL, NULL);
3633 /* copy stream format */
3634 for(i=0;i<ic->nb_streams;i++) {
3639 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3640 ost = new_output_stream(o, s, codec->type);
3643 // FIXME: a more elegant solution is needed
3644 memcpy(st, ic->streams[i], sizeof(AVStream));
3645 st->info = av_malloc(sizeof(*st->info));
3646 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3647 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3649 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3650 choose_sample_fmt(st, codec);
3651 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3652 choose_pixel_fmt(st, codec);
3655 av_close_input_file(ic);
3659 static void opt_output_file(void *optctx, const char *filename)
3661 OptionsContext *o = optctx;
3662 AVFormatContext *oc;
3664 AVOutputFormat *file_oformat;
3668 if (!strcmp(filename, "-"))
3671 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3673 print_error(filename, err);
3676 file_oformat= oc->oformat;
3678 if (!strcmp(file_oformat->name, "ffm") &&
3679 av_strstart(filename, "http:", NULL)) {
3680 /* special case for files sent to ffserver: we get the stream
3681 parameters from ffserver */
3682 int err = read_ffserver_streams(o, oc, filename);
3684 print_error(filename, err);
3687 } else if (!o->nb_stream_maps) {
3688 /* pick the "best" stream of each type */
3689 #define NEW_STREAM(type, index)\
3691 ost = new_ ## type ## _stream(o, oc);\
3692 ost->source_index = index;\
3693 ost->sync_ist = &input_streams[index];\
3694 input_streams[index].discard = 0;\
3697 /* video: highest resolution */
3698 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3699 int area = 0, idx = -1;
3700 for (i = 0; i < nb_input_streams; i++) {
3701 ist = &input_streams[i];
3702 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3703 ist->st->codec->width * ist->st->codec->height > area) {
3704 area = ist->st->codec->width * ist->st->codec->height;
3708 NEW_STREAM(video, idx);
3711 /* audio: most channels */
3712 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3713 int channels = 0, idx = -1;
3714 for (i = 0; i < nb_input_streams; i++) {
3715 ist = &input_streams[i];
3716 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3717 ist->st->codec->channels > channels) {
3718 channels = ist->st->codec->channels;
3722 NEW_STREAM(audio, idx);
3725 /* subtitles: pick first */
3726 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3727 for (i = 0; i < nb_input_streams; i++)
3728 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3729 NEW_STREAM(subtitle, i);
3733 /* do something with data? */
3735 for (i = 0; i < o->nb_stream_maps; i++) {
3736 StreamMap *map = &o->stream_maps[i];
3741 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3742 switch (ist->st->codec->codec_type) {
3743 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3744 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3745 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3746 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3748 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3749 map->file_index, map->stream_index);
3753 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3754 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3755 map->sync_stream_index];
3760 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3761 output_files[nb_output_files - 1].ctx = oc;
3762 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3763 output_files[nb_output_files - 1].recording_time = o->recording_time;
3764 output_files[nb_output_files - 1].start_time = o->start_time;
3765 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3766 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3768 /* check filename in case of an image number is expected */
3769 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3770 if (!av_filename_number_test(oc->filename)) {
3771 print_error(oc->filename, AVERROR(EINVAL));
3776 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3777 /* test if it already exists to avoid loosing precious files */
3778 if (!file_overwrite &&
3779 (strchr(filename, ':') == NULL ||
3780 filename[1] == ':' ||
3781 av_strstart(filename, "file:", NULL))) {
3782 if (avio_check(filename, 0) == 0) {
3784 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3786 if (!read_yesno()) {
3787 fprintf(stderr, "Not overwriting - exiting\n");
3792 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3799 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3800 print_error(filename, err);
3805 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3806 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3808 if (loop_output >= 0) {
3809 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3810 oc->loop_output = loop_output;
3814 if (o->chapters_input_file >= nb_input_files) {
3815 if (o->chapters_input_file == INT_MAX) {
3816 /* copy chapters from the first input file that has them*/
3817 o->chapters_input_file = -1;
3818 for (i = 0; i < nb_input_files; i++)
3819 if (input_files[i].ctx->nb_chapters) {
3820 o->chapters_input_file = i;
3824 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3825 o->chapters_input_file);
3829 if (o->chapters_input_file >= 0)
3830 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3831 o->metadata_chapters_manual);
3834 for (i = 0; i < o->nb_meta_data_maps; i++) {
3835 AVFormatContext *files[2];
3836 AVDictionary **meta[2];
3839 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3840 if ((index) < 0 || (index) >= (nb_elems)) {\
3841 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3846 int in_file_index = o->meta_data_maps[i][1].file;
3847 if (in_file_index < 0)
3849 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3852 files[1] = input_files[in_file_index].ctx;
3854 for (j = 0; j < 2; j++) {
3855 MetadataMap *map = &o->meta_data_maps[i][j];
3857 switch (map->type) {
3859 meta[j] = &files[j]->metadata;
3862 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3863 meta[j] = &files[j]->streams[map->index]->metadata;
3866 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3867 meta[j] = &files[j]->chapters[map->index]->metadata;
3870 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3871 meta[j] = &files[j]->programs[map->index]->metadata;
3876 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3879 /* copy global metadata by default */
3880 if (!o->metadata_global_manual && nb_input_files)
3881 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3882 AV_DICT_DONT_OVERWRITE);
3883 if (!o->metadata_streams_manual)
3884 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3885 InputStream *ist = &input_streams[output_streams[i].source_index];
3886 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3889 /* process manually set metadata */
3890 for (i = 0; i < o->nb_metadata; i++) {
3895 val = strchr(o->metadata[i].u.str, '=');
3897 av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3898 o->metadata[i].u.str);
3903 parse_meta_type(o->metadata[i].specifier, &type, &index);
3909 if (index < 0 || index >= oc->nb_streams) {
3910 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3913 m = &oc->streams[i]->metadata;
3916 if (index < 0 || index >= oc->nb_chapters) {
3917 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3920 m = &oc->chapters[i]->metadata;
3923 av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3927 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3930 frame_rate = (AVRational){0, 0};
3933 audio_sample_rate = 0;
3935 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3937 av_freep(&streamid_map);
3938 nb_streamid_map = 0;
3940 av_freep(&forced_key_frames);
3941 reset_options(o, 0);
3944 /* same option as mencoder */
3945 static int opt_pass(const char *opt, const char *arg)
3947 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3951 static int64_t getutime(void)
3954 struct rusage rusage;
3956 getrusage(RUSAGE_SELF, &rusage);
3957 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3958 #elif HAVE_GETPROCESSTIMES
3960 FILETIME c, e, k, u;
3961 proc = GetCurrentProcess();
3962 GetProcessTimes(proc, &c, &e, &k, &u);
3963 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3965 return av_gettime();
3969 static int64_t getmaxrss(void)
3971 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3972 struct rusage rusage;
3973 getrusage(RUSAGE_SELF, &rusage);
3974 return (int64_t)rusage.ru_maxrss * 1024;
3975 #elif HAVE_GETPROCESSMEMORYINFO
3977 PROCESS_MEMORY_COUNTERS memcounters;
3978 proc = GetCurrentProcess();
3979 memcounters.cb = sizeof(memcounters);
3980 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3981 return memcounters.PeakPagefileUsage;
3987 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3990 const char *p = str;
3997 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4004 static int opt_inter_matrix(const char *opt, const char *arg)
4006 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4007 parse_matrix_coeffs(inter_matrix, arg);
4011 static int opt_intra_matrix(const char *opt, const char *arg)
4013 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4014 parse_matrix_coeffs(intra_matrix, arg);
4018 static void show_usage(void)
4020 printf("Hyper fast Audio and Video encoder\n");
4021 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4025 static int opt_help(const char *opt, const char *arg)
4028 AVOutputFormat *oformat = NULL;
4029 AVInputFormat *iformat = NULL;
4030 const AVClass *class;
4032 av_log_set_callback(log_callback_help);
4034 show_help_options(options, "Main options:\n",
4035 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4036 show_help_options(options, "\nAdvanced options:\n",
4037 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4039 show_help_options(options, "\nVideo options:\n",
4040 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4042 show_help_options(options, "\nAdvanced Video options:\n",
4043 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4044 OPT_VIDEO | OPT_EXPERT);
4045 show_help_options(options, "\nAudio options:\n",
4046 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4048 show_help_options(options, "\nAdvanced Audio options:\n",
4049 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4050 OPT_AUDIO | OPT_EXPERT);
4051 show_help_options(options, "\nSubtitle options:\n",
4052 OPT_SUBTITLE | OPT_GRAB,
4054 show_help_options(options, "\nAudio/Video grab options:\n",
4058 class = avcodec_get_class();
4059 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4062 /* individual codec options */
4064 while ((c = av_codec_next(c))) {
4065 if (c->priv_class) {
4066 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4071 class = avformat_get_class();
4072 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4075 /* individual muxer options */
4076 while ((oformat = av_oformat_next(oformat))) {
4077 if (oformat->priv_class) {
4078 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4083 /* individual demuxer options */
4084 while ((iformat = av_iformat_next(iformat))) {
4085 if (iformat->priv_class) {
4086 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4091 class = sws_get_class();
4092 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4096 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4098 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4099 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4101 if(!strncmp(arg, "pal-", 4)) {
4104 } else if(!strncmp(arg, "ntsc-", 5)) {
4107 } else if(!strncmp(arg, "film-", 5)) {
4112 /* Calculate FR via float to avoid int overflow */
4113 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4116 } else if((fr == 29970) || (fr == 23976)) {
4119 /* Try to determine PAL/NTSC by peeking in the input files */
4120 if(nb_input_files) {
4122 for (j = 0; j < nb_input_files; j++) {
4123 for (i = 0; i < input_files[j].nb_streams; i++) {
4124 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4125 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4127 fr = c->time_base.den * 1000 / c->time_base.num;
4131 } else if((fr == 29970) || (fr == 23976)) {
4141 if(verbose > 0 && norm != UNKNOWN)
4142 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4145 if(norm == UNKNOWN) {
4146 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4147 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4148 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4152 if(!strcmp(arg, "vcd")) {
4153 opt_video_codec(o, "c:v", "mpeg1video");
4154 opt_audio_codec(o, "c:a", "mp2");
4155 parse_option(o, "f", "vcd", options);
4157 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4158 opt_frame_rate("r", frame_rates[norm]);
4159 opt_default("g", norm == PAL ? "15" : "18");
4161 opt_default("b", "1150000");
4162 opt_default("maxrate", "1150000");
4163 opt_default("minrate", "1150000");
4164 opt_default("bufsize", "327680"); // 40*1024*8;
4166 opt_default("b:a", "224000");
4167 audio_sample_rate = 44100;
4170 opt_default("packetsize", "2324");
4171 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4173 /* We have to offset the PTS, so that it is consistent with the SCR.
4174 SCR starts at 36000, but the first two packs contain only padding
4175 and the first pack from the other stream, respectively, may also have
4176 been written before.
4177 So the real data starts at SCR 36000+3*1200. */
4178 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4179 } else if(!strcmp(arg, "svcd")) {
4181 opt_video_codec(o, "c:v", "mpeg2video");
4182 opt_audio_codec(o, "c:a", "mp2");
4183 parse_option(o, "f", "svcd", options);
4185 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4186 opt_frame_rate("r", frame_rates[norm]);
4187 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4188 opt_default("g", norm == PAL ? "15" : "18");
4190 opt_default("b", "2040000");
4191 opt_default("maxrate", "2516000");
4192 opt_default("minrate", "0"); //1145000;
4193 opt_default("bufsize", "1835008"); //224*1024*8;
4194 opt_default("flags", "+scan_offset");
4197 opt_default("b:a", "224000");
4198 audio_sample_rate = 44100;
4200 opt_default("packetsize", "2324");
4202 } else if(!strcmp(arg, "dvd")) {
4204 opt_video_codec(o, "c:v", "mpeg2video");
4205 opt_audio_codec(o, "c:a", "ac3");
4206 parse_option(o, "f", "dvd", options);
4208 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4209 opt_frame_rate("r", frame_rates[norm]);
4210 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4211 opt_default("g", norm == PAL ? "15" : "18");
4213 opt_default("b", "6000000");
4214 opt_default("maxrate", "9000000");
4215 opt_default("minrate", "0"); //1500000;
4216 opt_default("bufsize", "1835008"); //224*1024*8;
4218 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4219 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4221 opt_default("b:a", "448000");
4222 audio_sample_rate = 48000;
4224 } else if(!strncmp(arg, "dv", 2)) {
4226 parse_option(o, "f", "dv", options);
4228 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4229 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4230 norm == PAL ? "yuv420p" : "yuv411p");
4231 opt_frame_rate("r", frame_rates[norm]);
4233 audio_sample_rate = 48000;
4237 fprintf(stderr, "Unknown target: %s\n", arg);
4238 return AVERROR(EINVAL);
4243 static int opt_vstats_file(const char *opt, const char *arg)
4245 av_free (vstats_filename);
4246 vstats_filename=av_strdup (arg);
4250 static int opt_vstats(const char *opt, const char *arg)
4253 time_t today2 = time(NULL);
4254 struct tm *today = localtime(&today2);
4256 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4258 return opt_vstats_file(opt, filename);
4261 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4263 return parse_option(o, "frames:v", arg, options);
4266 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4268 return parse_option(o, "frames:a", arg, options);
4271 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4273 return parse_option(o, "frames:d", arg, options);
4276 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4279 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4280 char *codec_name = *opt == 'v' ? video_codec_name :
4281 *opt == 'a' ? audio_codec_name :
4282 subtitle_codec_name;
4284 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4285 fprintf(stderr, "File for preset '%s' not found\n", arg);
4290 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4291 if(line[0] == '#' && !e)
4293 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4295 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4298 if(!strcmp(tmp, "acodec")){
4299 opt_audio_codec(o, tmp, tmp2);
4300 }else if(!strcmp(tmp, "vcodec")){
4301 opt_video_codec(o, tmp, tmp2);
4302 }else if(!strcmp(tmp, "scodec")){
4303 opt_subtitle_codec(o, tmp, tmp2);
4304 }else if(!strcmp(tmp, "dcodec")){
4305 opt_data_codec(o, tmp, tmp2);
4306 }else if(opt_default(tmp, tmp2) < 0){
4307 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4317 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4321 static int opt_passlogfile(const char *opt, const char *arg)
4323 pass_logfilename_prefix = arg;
4324 #if CONFIG_LIBX264_ENCODER
4325 return opt_default("passlogfile", arg);
4331 #define OFFSET(x) offsetof(OptionsContext, x)
4332 static const OptionDef options[] = {
4334 #include "cmdutils_common_opts.h"
4335 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4336 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4337 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4338 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4339 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4340 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4341 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4342 "outfile[,metadata]:infile[,metadata]" },
4343 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4344 "outfile[,metadata]:infile[,metadata]" },
4345 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4346 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4347 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4348 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4349 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4350 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4351 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4352 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4353 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4354 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4355 "add timings for benchmarking" },
4356 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4357 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4358 "dump each input packet" },
4359 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4360 "when dumping packets, also dump the payload" },
4361 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4362 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4363 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4364 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4365 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4366 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4367 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4368 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4369 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4370 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4371 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4372 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4373 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4374 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4375 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4376 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4377 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4380 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4381 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4382 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4383 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4384 { "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" },
4385 { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4386 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4387 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4388 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4389 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4390 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4391 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4392 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4393 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4394 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4395 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4396 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4397 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4398 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4399 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4400 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4401 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold", "threshold" },
4402 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4403 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4404 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4405 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4406 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4407 "deinterlace pictures" },
4408 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4409 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4410 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4412 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4414 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4415 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4416 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4417 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4418 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4419 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4420 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4421 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4422 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4423 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4426 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4427 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4428 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4429 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4430 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4431 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4432 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4433 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4434 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4435 { "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" },
4437 /* subtitle options */
4438 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4439 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4440 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4441 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4444 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4445 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4446 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4449 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4450 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4452 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4454 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4455 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4456 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4457 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4458 /* data codec support */
4459 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4461 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4465 int main(int argc, char **argv)
4467 OptionsContext o = { 0 };
4470 reset_options(&o, 0);
4472 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4474 if(argc>1 && !strcmp(argv[1], "-d")){
4477 av_log_set_callback(log_callback_null);
4482 avcodec_register_all();
4484 avdevice_register_all();
4487 avfilter_register_all();
4492 if(isatty(STDIN_FILENO))
4493 avio_set_interrupt_cb(decode_interrupt_cb);
4500 parse_options(&o, argc, argv, options, opt_output_file);
4502 if(nb_output_files <= 0 && nb_input_files == 0) {
4504 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4508 /* file converter / grab */
4509 if (nb_output_files <= 0) {
4510 fprintf(stderr, "At least one output file must be specified\n");
4514 if (nb_input_files == 0) {
4515 fprintf(stderr, "At least one input file must be specified\n");
4520 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4522 ti = getutime() - ti;
4524 int maxrss = getmaxrss() / 1024;
4525 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);