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/buffersink.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[] = "avconv";
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 static int frame_bits_per_raw_sample = 0;
115 static int video_discard = 0;
116 static int same_quant = 0;
117 static int do_deinterlace = 0;
118 static int intra_dc_precision = 8;
119 static int qp_hist = 0;
121 static int file_overwrite = 0;
122 static int do_benchmark = 0;
123 static int do_hex_dump = 0;
124 static int do_pkt_dump = 0;
125 static int do_pass = 0;
126 static const char *pass_logfilename_prefix;
127 static int video_sync_method= -1;
128 static int audio_sync_method= 0;
129 static float audio_drift_threshold= 0.1;
130 static int copy_ts= 0;
131 static int copy_tb= 0;
132 static int opt_shortest = 0;
133 static char *vstats_filename;
134 static FILE *vstats_file;
135 static int copy_initial_nonkeyframes = 0;
137 static int audio_volume = 256;
139 static int exit_on_error = 0;
140 static int using_stdin = 0;
141 static int verbose = 1;
142 static int run_as_daemon = 0;
143 static int q_pressed = 0;
144 static int64_t video_size = 0;
145 static int64_t audio_size = 0;
146 static int64_t extra_size = 0;
147 static int nb_frames_dup = 0;
148 static int nb_frames_drop = 0;
149 static int input_sync;
151 static float dts_delta_threshold = 10;
153 static uint8_t *audio_buf;
154 static uint8_t *audio_out;
155 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
157 static short *samples;
159 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
161 typedef struct InputStream {
164 int discard; /* true if stream data should be discarded */
165 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
168 int64_t start; /* time when read started */
169 int64_t next_pts; /* synthetic pts for cases where pkt.pts
171 int64_t pts; /* current pts */
173 int is_start; /* is 1 at the start and after a discontinuity */
174 int showed_multi_packet_warning;
178 typedef struct InputFile {
179 AVFormatContext *ctx;
180 int eof_reached; /* true if eof reached */
181 int ist_index; /* index of first stream in ist_table */
182 int buffer_size; /* current total buffer size */
184 int nb_streams; /* number of stream that avconv is aware of; may be different
185 from ctx.nb_streams if new streams appear during av_read_frame() */
189 typedef struct OutputStream {
190 int file_index; /* file index */
191 int index; /* stream index in the output file */
192 int source_index; /* InputStream index */
193 AVStream *st; /* stream in the output file */
194 int encoding_needed; /* true if encoding needed for this stream */
196 /* input pts and corresponding output pts
198 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
199 struct InputStream *sync_ist; /* input stream to sync against */
200 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
201 AVBitStreamFilterContext *bitstream_filters;
207 AVFrame resample_frame; /* temporary frame for image resampling */
208 struct SwsContext *img_resample_ctx; /* for image resampling */
211 int resample_pix_fmt;
212 AVRational frame_rate;
216 float frame_aspect_ratio;
218 /* forced key frames */
219 int64_t *forced_kf_pts;
225 ReSampleContext *resample; /* for audio resampling */
226 int resample_sample_fmt;
227 int resample_channels;
228 int resample_sample_rate;
230 AVAudioConvert *reformat_ctx;
231 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
235 AVFilterContext *output_video_filter;
236 AVFilterContext *input_video_filter;
237 AVFilterBufferRef *picref;
239 AVFilterGraph *graph;
244 int is_past_recording_time;
249 /* init terminal so that we can grab keys */
250 static struct termios oldtty;
253 typedef struct OutputFile {
254 AVFormatContext *ctx;
256 int ost_index; /* index of the first stream in output_streams */
257 int64_t recording_time; /* desired length of the resulting file in microseconds */
258 int64_t start_time; /* start time in microseconds */
259 uint64_t limit_filesize;
262 static InputStream *input_streams = NULL;
263 static int nb_input_streams = 0;
264 static InputFile *input_files = NULL;
265 static int nb_input_files = 0;
267 static OutputStream *output_streams = NULL;
268 static int nb_output_streams = 0;
269 static OutputFile *output_files = NULL;
270 static int nb_output_files = 0;
272 typedef struct OptionsContext {
273 /* input/output options */
277 SpecifierOpt *codec_names;
279 SpecifierOpt *audio_channels;
280 int nb_audio_channels;
281 SpecifierOpt *audio_sample_rate;
282 int nb_audio_sample_rate;
283 SpecifierOpt *frame_rates;
285 SpecifierOpt *frame_sizes;
287 SpecifierOpt *frame_pix_fmts;
288 int nb_frame_pix_fmts;
291 int64_t input_ts_offset;
294 SpecifierOpt *ts_scale;
298 StreamMap *stream_maps;
300 /* first item specifies output metadata, second is input */
301 MetadataMap (*meta_data_maps)[2];
302 int nb_meta_data_maps;
303 int metadata_global_manual;
304 int metadata_streams_manual;
305 int metadata_chapters_manual;
307 int chapters_input_file;
309 int64_t recording_time;
310 uint64_t limit_filesize;
316 int subtitle_disable;
319 /* indexed by output file stream index */
323 SpecifierOpt *metadata;
325 SpecifierOpt *max_frames;
327 SpecifierOpt *bitstream_filters;
328 int nb_bitstream_filters;
329 SpecifierOpt *codec_tags;
331 SpecifierOpt *sample_fmts;
333 SpecifierOpt *qscale;
335 SpecifierOpt *forced_key_frames;
336 int nb_forced_key_frames;
337 SpecifierOpt *force_fps;
339 SpecifierOpt *frame_aspect_ratios;
340 int nb_frame_aspect_ratios;
341 SpecifierOpt *rc_overrides;
343 SpecifierOpt *intra_matrices;
344 int nb_intra_matrices;
345 SpecifierOpt *inter_matrices;
346 int nb_inter_matrices;
347 SpecifierOpt *top_field_first;
348 int nb_top_field_first;
350 SpecifierOpt *filters;
355 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
358 for (i = 0; i < o->nb_ ## name; i++) {\
359 char *spec = o->name[i].specifier;\
360 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
361 outvar = o->name[i].u.type;\
367 static void reset_options(OptionsContext *o)
369 const OptionDef *po = options;
371 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
373 void *dst = (uint8_t*)o + po->u.off;
375 if (po->flags & OPT_SPEC) {
376 SpecifierOpt **so = dst;
377 int i, *count = (int*)(so + 1);
378 for (i = 0; i < *count; i++) {
379 av_freep(&(*so)[i].specifier);
380 if (po->flags & OPT_STRING)
381 av_freep(&(*so)[i].u.str);
385 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
390 av_freep(&o->stream_maps);
391 av_freep(&o->meta_data_maps);
392 av_freep(&o->streamid_map);
394 memset(o, 0, sizeof(*o));
396 o->mux_preload = 0.5;
397 o->mux_max_delay = 0.7;
398 o->recording_time = INT64_MAX;
399 o->limit_filesize = UINT64_MAX;
400 o->chapters_input_file = INT_MAX;
408 static int configure_video_filters(InputStream *ist, OutputStream *ost)
410 AVFilterContext *last_filter, *filter;
411 /** filter graph containing all filters including input & output */
412 AVCodecContext *codec = ost->st->codec;
413 AVCodecContext *icodec = ist->st->codec;
414 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
415 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
416 AVRational sample_aspect_ratio;
420 ost->graph = avfilter_graph_alloc();
422 if (ist->st->sample_aspect_ratio.num){
423 sample_aspect_ratio = ist->st->sample_aspect_ratio;
425 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
427 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
428 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
429 sample_aspect_ratio.num, sample_aspect_ratio.den);
431 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
432 "src", args, NULL, ost->graph);
435 #if FF_API_OLD_VSINK_API
436 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
437 "out", NULL, pix_fmts, ost->graph);
439 buffersink_params->pixel_fmts = pix_fmts;
440 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
441 "out", NULL, buffersink_params, ost->graph);
443 av_freep(&buffersink_params);
446 last_filter = ost->input_video_filter;
448 if (codec->width != icodec->width || codec->height != icodec->height) {
449 snprintf(args, 255, "%d:%d:flags=0x%X",
453 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
454 NULL, args, NULL, ost->graph)) < 0)
456 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
458 last_filter = filter;
461 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
462 ost->graph->scale_sws_opts = av_strdup(args);
465 AVFilterInOut *outputs = avfilter_inout_alloc();
466 AVFilterInOut *inputs = avfilter_inout_alloc();
468 outputs->name = av_strdup("in");
469 outputs->filter_ctx = last_filter;
470 outputs->pad_idx = 0;
471 outputs->next = NULL;
473 inputs->name = av_strdup("out");
474 inputs->filter_ctx = ost->output_video_filter;
478 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
480 av_freep(&ost->avfilter);
482 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
486 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
489 codec->width = ost->output_video_filter->inputs[0]->w;
490 codec->height = ost->output_video_filter->inputs[0]->h;
491 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
492 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
493 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
494 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
498 #endif /* CONFIG_AVFILTER */
500 static void term_exit(void)
502 av_log(NULL, AV_LOG_QUIET, "%s", "");
505 tcsetattr (0, TCSANOW, &oldtty);
509 static volatile int received_sigterm = 0;
512 sigterm_handler(int sig)
514 received_sigterm = sig;
519 static void term_init(void)
529 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
530 |INLCR|IGNCR|ICRNL|IXON);
531 tty.c_oflag |= OPOST;
532 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
533 tty.c_cflag &= ~(CSIZE|PARENB);
538 tcsetattr (0, TCSANOW, &tty);
539 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
543 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
544 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
546 signal(SIGXCPU, sigterm_handler);
550 /* read a key without blocking */
551 static int read_key(void)
566 n = select(1, &rfds, NULL, NULL, &tv);
581 static int decode_interrupt_cb(void)
583 q_pressed += read_key() == 'q';
584 return q_pressed > 1;
587 void exit_program(int ret)
592 for(i=0;i<nb_output_files;i++) {
593 AVFormatContext *s = output_files[i].ctx;
594 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
596 avformat_free_context(s);
597 av_dict_free(&output_files[i].opts);
599 for(i=0;i<nb_input_files;i++) {
600 av_close_input_file(input_files[i].ctx);
602 for (i = 0; i < nb_input_streams; i++)
603 av_dict_free(&input_streams[i].opts);
607 av_free(vstats_filename);
609 av_freep(&input_streams);
610 av_freep(&input_files);
611 av_freep(&output_streams);
612 av_freep(&output_files);
617 allocated_audio_buf_size= allocated_audio_out_size= 0;
624 if (received_sigterm) {
626 "Received signal %d: terminating.\n",
627 (int) received_sigterm);
631 exit(ret); /* not all OS-es handle main() return value */
634 static void assert_avoptions(AVDictionary *m)
636 AVDictionaryEntry *t;
637 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
638 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
643 static void assert_codec_experimental(AVCodecContext *c, int encoder)
645 const char *codec_string = encoder ? "encoder" : "decoder";
647 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
648 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
649 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
650 "results.\nAdd '-strict experimental' if you want to use it.\n",
651 codec_string, c->codec->name);
652 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
653 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
654 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
655 codec_string, codec->name);
660 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
662 if(codec && codec->sample_fmts){
663 const enum AVSampleFormat *p= codec->sample_fmts;
665 if(*p == st->codec->sample_fmt)
669 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
670 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
671 if(av_get_sample_fmt_name(st->codec->sample_fmt))
672 av_log(NULL, AV_LOG_WARNING,
673 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
674 av_get_sample_fmt_name(st->codec->sample_fmt),
676 av_get_sample_fmt_name(codec->sample_fmts[0]));
677 st->codec->sample_fmt = codec->sample_fmts[0];
682 static void choose_sample_rate(AVStream *st, AVCodec *codec)
684 if(codec && codec->supported_samplerates){
685 const int *p= codec->supported_samplerates;
687 int best_dist=INT_MAX;
689 int dist= abs(st->codec->sample_rate - *p);
690 if(dist < best_dist){
696 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
698 st->codec->sample_rate= best;
702 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
704 if(codec && codec->pix_fmts){
705 const enum PixelFormat *p= codec->pix_fmts;
706 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
707 if(st->codec->codec_id==CODEC_ID_MJPEG){
708 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
709 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
710 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};
714 if(*p == st->codec->pix_fmt)
718 if(st->codec->pix_fmt != PIX_FMT_NONE)
719 av_log(NULL, AV_LOG_WARNING,
720 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
721 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
723 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
724 st->codec->pix_fmt = codec->pix_fmts[0];
730 get_sync_ipts(const OutputStream *ost)
732 const InputStream *ist = ost->sync_ist;
733 OutputFile *of = &output_files[ost->file_index];
734 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
737 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
741 AVPacket new_pkt= *pkt;
742 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
743 &new_pkt.data, &new_pkt.size,
744 pkt->data, pkt->size,
745 pkt->flags & AV_PKT_FLAG_KEY);
748 new_pkt.destruct= av_destruct_packet;
750 fprintf(stderr, "%s failed for stream %d, codec %s",
751 bsfc->filter->name, pkt->stream_index,
752 avctx->codec ? avctx->codec->name : "copy");
762 ret= av_interleaved_write_frame(s, pkt);
764 print_error("av_interleaved_write_frame()", ret);
769 static void do_audio_out(AVFormatContext *s,
772 unsigned char *buf, int size)
775 int64_t audio_out_size, audio_buf_size;
776 int64_t allocated_for_size= size;
778 int size_out, frame_bytes, ret, resample_changed;
779 AVCodecContext *enc= ost->st->codec;
780 AVCodecContext *dec= ist->st->codec;
781 int osize = av_get_bytes_per_sample(enc->sample_fmt);
782 int isize = av_get_bytes_per_sample(dec->sample_fmt);
783 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
786 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
787 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
788 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
789 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
790 audio_buf_size*= osize*enc->channels;
792 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
793 if(coded_bps > 8*osize)
794 audio_out_size= audio_out_size * coded_bps / (8*osize);
795 audio_out_size += FF_MIN_BUFFER_SIZE;
797 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
798 fprintf(stderr, "Buffer sizes too large\n");
802 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
803 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
804 if (!audio_buf || !audio_out){
805 fprintf(stderr, "Out of memory in do_audio_out\n");
809 if (enc->channels != dec->channels)
810 ost->audio_resample = 1;
812 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
813 ost->resample_channels != dec->channels ||
814 ost->resample_sample_rate != dec->sample_rate;
816 if ((ost->audio_resample && !ost->resample) || resample_changed) {
817 if (resample_changed) {
818 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",
819 ist->file_index, ist->st->index,
820 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
821 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
822 ost->resample_sample_fmt = dec->sample_fmt;
823 ost->resample_channels = dec->channels;
824 ost->resample_sample_rate = dec->sample_rate;
826 audio_resample_close(ost->resample);
828 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
829 if (audio_sync_method <= 1 &&
830 ost->resample_sample_fmt == enc->sample_fmt &&
831 ost->resample_channels == enc->channels &&
832 ost->resample_sample_rate == enc->sample_rate) {
833 ost->resample = NULL;
834 ost->audio_resample = 0;
836 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
837 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
838 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
839 enc->sample_rate, dec->sample_rate,
840 enc->sample_fmt, dec->sample_fmt,
842 if (!ost->resample) {
843 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
844 dec->channels, dec->sample_rate,
845 enc->channels, enc->sample_rate);
851 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
852 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
853 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
854 if (ost->reformat_ctx)
855 av_audio_convert_free(ost->reformat_ctx);
856 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
857 dec->sample_fmt, 1, NULL, 0);
858 if (!ost->reformat_ctx) {
859 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
860 av_get_sample_fmt_name(dec->sample_fmt),
861 av_get_sample_fmt_name(enc->sample_fmt));
864 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
867 if(audio_sync_method){
868 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
869 - av_fifo_size(ost->fifo)/(enc->channels * 2);
870 double idelta= delta*dec->sample_rate / enc->sample_rate;
871 int byte_delta= ((int)idelta)*2*dec->channels;
873 //FIXME resample delay
874 if(fabs(delta) > 50){
875 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
877 byte_delta= FFMAX(byte_delta, -size);
881 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
886 static uint8_t *input_tmp= NULL;
887 input_tmp= av_realloc(input_tmp, byte_delta + size);
889 if(byte_delta > allocated_for_size - size){
890 allocated_for_size= byte_delta + (int64_t)size;
895 memset(input_tmp, 0, byte_delta);
896 memcpy(input_tmp + byte_delta, buf, size);
900 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
902 }else if(audio_sync_method>1){
903 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
904 av_assert0(ost->audio_resample);
906 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
907 // 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));
908 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
912 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
913 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
915 if (ost->audio_resample) {
917 size_out = audio_resample(ost->resample,
918 (short *)buftmp, (short *)buf,
919 size / (dec->channels * isize));
920 size_out = size_out * enc->channels * osize;
926 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
927 const void *ibuf[6]= {buftmp};
928 void *obuf[6]= {audio_buf};
929 int istride[6]= {isize};
930 int ostride[6]= {osize};
931 int len= size_out/istride[0];
932 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
933 printf("av_audio_convert() failed\n");
939 size_out = len*osize;
942 /* now encode as many frames as possible */
943 if (enc->frame_size > 1) {
944 /* output resampled raw samples */
945 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
946 fprintf(stderr, "av_fifo_realloc2() failed\n");
949 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
951 frame_bytes = enc->frame_size * osize * enc->channels;
953 while (av_fifo_size(ost->fifo) >= frame_bytes) {
955 av_init_packet(&pkt);
957 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
959 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
961 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
964 fprintf(stderr, "Audio encoding failed\n");
968 pkt.stream_index= ost->index;
971 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
972 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
973 pkt.flags |= AV_PKT_FLAG_KEY;
974 write_frame(s, &pkt, enc, ost->bitstream_filters);
976 ost->sync_opts += enc->frame_size;
980 av_init_packet(&pkt);
982 ost->sync_opts += size_out / (osize * enc->channels);
984 /* output a pcm frame */
985 /* determine the size of the coded buffer */
988 size_out = size_out*coded_bps/8;
990 if(size_out > audio_out_size){
991 fprintf(stderr, "Internal error, buffer size too small\n");
995 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
996 ret = avcodec_encode_audio(enc, audio_out, size_out,
999 fprintf(stderr, "Audio encoding failed\n");
1003 pkt.stream_index= ost->index;
1004 pkt.data= audio_out;
1006 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1007 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1008 pkt.flags |= AV_PKT_FLAG_KEY;
1009 write_frame(s, &pkt, enc, ost->bitstream_filters);
1013 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1015 AVCodecContext *dec;
1016 AVPicture *picture2;
1017 AVPicture picture_tmp;
1020 dec = ist->st->codec;
1022 /* deinterlace : must be done before any resize */
1023 if (do_deinterlace) {
1026 /* create temporary picture */
1027 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1028 buf = av_malloc(size);
1032 picture2 = &picture_tmp;
1033 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1035 if(avpicture_deinterlace(picture2, picture,
1036 dec->pix_fmt, dec->width, dec->height) < 0) {
1037 /* if error, do not deinterlace */
1038 fprintf(stderr, "Deinterlacing failed\n");
1047 if (picture != picture2)
1048 *picture = *picture2;
1052 static void do_subtitle_out(AVFormatContext *s,
1058 static uint8_t *subtitle_out = NULL;
1059 int subtitle_out_max_size = 1024 * 1024;
1060 int subtitle_out_size, nb, i;
1061 AVCodecContext *enc;
1064 if (pts == AV_NOPTS_VALUE) {
1065 fprintf(stderr, "Subtitle packets must have a pts\n");
1071 enc = ost->st->codec;
1073 if (!subtitle_out) {
1074 subtitle_out = av_malloc(subtitle_out_max_size);
1077 /* Note: DVB subtitle need one packet to draw them and one other
1078 packet to clear them */
1079 /* XXX: signal it in the codec context ? */
1080 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1085 for(i = 0; i < nb; i++) {
1086 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1087 // start_display_time is required to be 0
1088 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1089 sub->end_display_time -= sub->start_display_time;
1090 sub->start_display_time = 0;
1091 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1092 subtitle_out_max_size, sub);
1093 if (subtitle_out_size < 0) {
1094 fprintf(stderr, "Subtitle encoding failed\n");
1098 av_init_packet(&pkt);
1099 pkt.stream_index = ost->index;
1100 pkt.data = subtitle_out;
1101 pkt.size = subtitle_out_size;
1102 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1103 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1104 /* XXX: the pts correction is handled here. Maybe handling
1105 it in the codec would be better */
1107 pkt.pts += 90 * sub->start_display_time;
1109 pkt.pts += 90 * sub->end_display_time;
1111 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1115 static int bit_buffer_size= 1024*256;
1116 static uint8_t *bit_buffer= NULL;
1118 static void do_video_resample(OutputStream *ost,
1120 AVFrame *in_picture,
1121 AVFrame **out_picture)
1123 int resample_changed = 0;
1124 AVCodecContext *dec = ist->st->codec;
1125 AVCodecContext *enc = ost->st->codec;
1126 *out_picture = in_picture;
1128 resample_changed = ost->resample_width != dec->width ||
1129 ost->resample_height != dec->height ||
1130 ost->resample_pix_fmt != dec->pix_fmt;
1132 #if !CONFIG_AVFILTER
1133 if (resample_changed) {
1134 av_log(NULL, AV_LOG_INFO,
1135 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1136 ist->file_index, ist->st->index,
1137 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1138 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1139 ost->resample_width = dec->width;
1140 ost->resample_height = dec->height;
1141 ost->resample_pix_fmt = dec->pix_fmt;
1144 ost->video_resample = dec->width != enc->width ||
1145 dec->height != enc->height ||
1146 dec->pix_fmt != enc->pix_fmt;
1148 if (ost->video_resample) {
1149 *out_picture = &ost->resample_frame;
1150 if (!ost->img_resample_ctx || resample_changed) {
1151 /* initialize the destination picture */
1152 if (!ost->resample_frame.data[0]) {
1153 avcodec_get_frame_defaults(&ost->resample_frame);
1154 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1155 enc->width, enc->height)) {
1156 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1160 /* initialize a new scaler context */
1161 sws_freeContext(ost->img_resample_ctx);
1162 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1163 enc->width, enc->height, enc->pix_fmt,
1164 ost->sws_flags, NULL, NULL, NULL);
1165 if (ost->img_resample_ctx == NULL) {
1166 fprintf(stderr, "Cannot get resampling context\n");
1170 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1171 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1174 if (resample_changed) {
1175 avfilter_graph_free(&ost->graph);
1176 if (configure_video_filters(ist, ost)) {
1177 fprintf(stderr, "Error reinitializing filters!\n");
1182 if (resample_changed) {
1183 ost->resample_width = dec->width;
1184 ost->resample_height = dec->height;
1185 ost->resample_pix_fmt = dec->pix_fmt;
1190 static void do_video_out(AVFormatContext *s,
1193 AVFrame *in_picture,
1194 int *frame_size, float quality)
1196 int nb_frames, i, ret, format_video_sync;
1197 AVFrame *final_picture;
1198 AVCodecContext *enc;
1201 enc = ost->st->codec;
1203 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1205 /* by default, we output a single frame */
1210 format_video_sync = video_sync_method;
1211 if (format_video_sync < 0)
1212 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1214 if (format_video_sync) {
1215 double vdelta = sync_ipts - ost->sync_opts;
1216 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1219 else if (format_video_sync == 2) {
1222 }else if(vdelta>0.6)
1223 ost->sync_opts= lrintf(sync_ipts);
1224 }else if (vdelta > 1.1)
1225 nb_frames = lrintf(vdelta);
1226 //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);
1227 if (nb_frames == 0){
1230 fprintf(stderr, "*** drop!\n");
1231 }else if (nb_frames > 1) {
1232 nb_frames_dup += nb_frames - 1;
1234 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1237 ost->sync_opts= lrintf(sync_ipts);
1239 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1243 do_video_resample(ost, ist, in_picture, &final_picture);
1245 /* duplicates frame if needed */
1246 for(i=0;i<nb_frames;i++) {
1248 av_init_packet(&pkt);
1249 pkt.stream_index= ost->index;
1251 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1252 /* raw pictures are written as AVPicture structure to
1253 avoid any copies. We support temporarily the older
1255 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1256 enc->coded_frame->top_field_first = in_picture->top_field_first;
1257 pkt.data= (uint8_t *)final_picture;
1258 pkt.size= sizeof(AVPicture);
1259 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1260 pkt.flags |= AV_PKT_FLAG_KEY;
1262 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1264 AVFrame big_picture;
1266 big_picture= *final_picture;
1267 /* better than nothing: use input picture interlaced
1269 big_picture.interlaced_frame = in_picture->interlaced_frame;
1270 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1271 if (ost->top_field_first == -1)
1272 big_picture.top_field_first = in_picture->top_field_first;
1274 big_picture.top_field_first = !!ost->top_field_first;
1277 /* handles same_quant here. This is not correct because it may
1278 not be a global option */
1279 big_picture.quality = quality;
1280 if (!enc->me_threshold)
1281 big_picture.pict_type = 0;
1282 // big_picture.pts = AV_NOPTS_VALUE;
1283 big_picture.pts= ost->sync_opts;
1284 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1285 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1286 if (ost->forced_kf_index < ost->forced_kf_count &&
1287 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1288 big_picture.pict_type = AV_PICTURE_TYPE_I;
1289 ost->forced_kf_index++;
1291 ret = avcodec_encode_video(enc,
1292 bit_buffer, bit_buffer_size,
1295 fprintf(stderr, "Video encoding failed\n");
1300 pkt.data= bit_buffer;
1302 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1303 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1304 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1305 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1306 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1308 if(enc->coded_frame->key_frame)
1309 pkt.flags |= AV_PKT_FLAG_KEY;
1310 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1313 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1314 // enc->frame_number-1, ret, enc->pict_type);
1315 /* if two pass, output log */
1316 if (ost->logfile && enc->stats_out) {
1317 fprintf(ost->logfile, "%s", enc->stats_out);
1322 ost->frame_number++;
1326 static double psnr(double d){
1327 return -10.0*log(d)/log(10.0);
1330 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1333 AVCodecContext *enc;
1335 double ti1, bitrate, avg_bitrate;
1337 /* this is executed just the first time do_video_stats is called */
1339 vstats_file = fopen(vstats_filename, "w");
1346 enc = ost->st->codec;
1347 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1348 frame_number = ost->frame_number;
1349 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1350 if (enc->flags&CODEC_FLAG_PSNR)
1351 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1353 fprintf(vstats_file,"f_size= %6d ", frame_size);
1354 /* compute pts value */
1355 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1359 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1360 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1361 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1362 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1363 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1367 static void print_report(OutputFile *output_files,
1368 OutputStream *ost_table, int nb_ostreams,
1369 int is_last_report, int64_t timer_start)
1373 AVFormatContext *oc;
1375 AVCodecContext *enc;
1376 int frame_number, vid, i;
1378 int64_t pts = INT64_MAX;
1379 static int64_t last_time = -1;
1380 static int qp_histogram[52];
1382 if (!is_last_report) {
1384 /* display the report every 0.5 seconds */
1385 cur_time = av_gettime();
1386 if (last_time == -1) {
1387 last_time = cur_time;
1390 if ((cur_time - last_time) < 500000)
1392 last_time = cur_time;
1396 oc = output_files[0].ctx;
1398 total_size = avio_size(oc->pb);
1399 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1400 total_size= avio_tell(oc->pb);
1404 for(i=0;i<nb_ostreams;i++) {
1406 ost = &ost_table[i];
1407 enc = ost->st->codec;
1408 if (!ost->st->stream_copy && enc->coded_frame)
1409 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1410 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1411 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1413 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1414 float t = (av_gettime()-timer_start) / 1000000.0;
1416 frame_number = ost->frame_number;
1417 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1418 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1420 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1424 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1427 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1429 if (enc->flags&CODEC_FLAG_PSNR){
1431 double error, error_sum=0;
1432 double scale, scale_sum=0;
1433 char type[3]= {'Y','U','V'};
1434 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1437 error= enc->error[j];
1438 scale= enc->width*enc->height*255.0*255.0*frame_number;
1440 error= enc->coded_frame->error[j];
1441 scale= enc->width*enc->height*255.0*255.0;
1446 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1448 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1452 /* compute min output value */
1453 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1454 ost->st->time_base, AV_TIME_BASE_Q));
1457 if (verbose > 0 || is_last_report) {
1458 int hours, mins, secs, us;
1459 secs = pts / AV_TIME_BASE;
1460 us = pts % AV_TIME_BASE;
1466 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1468 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1469 "size=%8.0fkB time=", total_size / 1024.0);
1470 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1471 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1472 (100 * us) / AV_TIME_BASE);
1473 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1474 "bitrate=%6.1fkbits/s", bitrate);
1476 if (nb_frames_dup || nb_frames_drop)
1477 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1478 nb_frames_dup, nb_frames_drop);
1481 fprintf(stderr, "%s \r", buf);
1486 if (is_last_report && verbose >= 0){
1487 int64_t raw= audio_size + video_size + extra_size;
1488 fprintf(stderr, "\n");
1489 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1493 100.0*(total_size - raw)/raw
1498 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1500 int fill_char = 0x00;
1501 if (sample_fmt == AV_SAMPLE_FMT_U8)
1503 memset(buf, fill_char, size);
1506 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1510 for (i = 0; i < nb_ostreams; i++) {
1511 OutputStream *ost = &ost_table[i];
1512 AVCodecContext *enc = ost->st->codec;
1513 AVFormatContext *os = output_files[ost->file_index].ctx;
1515 if (!ost->encoding_needed)
1518 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1520 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1526 av_init_packet(&pkt);
1527 pkt.stream_index= ost->index;
1529 switch (ost->st->codec->codec_type) {
1530 case AVMEDIA_TYPE_AUDIO:
1531 fifo_bytes = av_fifo_size(ost->fifo);
1533 /* encode any samples remaining in fifo */
1534 if (fifo_bytes > 0) {
1535 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1536 int fs_tmp = enc->frame_size;
1538 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1539 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1540 enc->frame_size = fifo_bytes / (osize * enc->channels);
1542 int frame_bytes = enc->frame_size*osize*enc->channels;
1543 if (allocated_audio_buf_size < frame_bytes)
1545 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1548 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1549 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1550 ost->st->time_base.num, enc->sample_rate);
1551 enc->frame_size = fs_tmp;
1554 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1557 fprintf(stderr, "Audio encoding failed\n");
1561 pkt.flags |= AV_PKT_FLAG_KEY;
1563 case AVMEDIA_TYPE_VIDEO:
1564 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1566 fprintf(stderr, "Video encoding failed\n");
1570 if(enc->coded_frame && enc->coded_frame->key_frame)
1571 pkt.flags |= AV_PKT_FLAG_KEY;
1572 if (ost->logfile && enc->stats_out) {
1573 fprintf(ost->logfile, "%s", enc->stats_out);
1582 pkt.data = bit_buffer;
1584 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1585 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1586 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1591 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1592 static int output_packet(InputStream *ist, int ist_index,
1593 OutputStream *ost_table, int nb_ostreams,
1594 const AVPacket *pkt)
1596 AVFormatContext *os;
1601 void *buffer_to_free = NULL;
1602 static unsigned int samples_size= 0;
1603 AVSubtitle subtitle, *subtitle_to_free;
1604 int64_t pkt_pts = AV_NOPTS_VALUE;
1606 int frame_available;
1611 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1613 if(ist->next_pts == AV_NOPTS_VALUE)
1614 ist->next_pts= ist->pts;
1618 av_init_packet(&avpkt);
1626 if(pkt->dts != AV_NOPTS_VALUE)
1627 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1628 if(pkt->pts != AV_NOPTS_VALUE)
1629 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1631 //while we have more to decode or while the decoder did output something on EOF
1632 while (avpkt.size > 0 || (!pkt && got_output)) {
1633 uint8_t *data_buf, *decoded_data_buf;
1634 int data_size, decoded_data_size;
1636 ist->pts= ist->next_pts;
1638 if(avpkt.size && avpkt.size != pkt->size &&
1639 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1640 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1641 ist->showed_multi_packet_warning=1;
1644 /* decode the packet if needed */
1645 decoded_data_buf = NULL; /* fail safe */
1646 decoded_data_size= 0;
1647 data_buf = avpkt.data;
1648 data_size = avpkt.size;
1649 subtitle_to_free = NULL;
1650 if (ist->decoding_needed) {
1651 switch(ist->st->codec->codec_type) {
1652 case AVMEDIA_TYPE_AUDIO:{
1653 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1654 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1656 samples= av_malloc(samples_size);
1658 decoded_data_size= samples_size;
1659 /* XXX: could avoid copy if PCM 16 bits with same
1660 endianness as CPU */
1661 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1668 got_output = decoded_data_size > 0;
1669 /* Some bug in mpeg audio decoder gives */
1670 /* decoded_data_size < 0, it seems they are overflows */
1672 /* no audio frame */
1675 decoded_data_buf = (uint8_t *)samples;
1676 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1677 (ist->st->codec->sample_rate * ist->st->codec->channels);
1679 case AVMEDIA_TYPE_VIDEO:
1680 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1681 /* XXX: allocate picture correctly */
1682 avcodec_get_frame_defaults(&picture);
1683 avpkt.pts = pkt_pts;
1684 avpkt.dts = ist->pts;
1685 pkt_pts = AV_NOPTS_VALUE;
1687 ret = avcodec_decode_video2(ist->st->codec,
1688 &picture, &got_output, &avpkt);
1689 quality = same_quant ? picture.quality : 0;
1693 /* no picture yet */
1694 goto discard_packet;
1696 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1697 if (ist->st->codec->time_base.num != 0) {
1698 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1699 ist->next_pts += ((int64_t)AV_TIME_BASE *
1700 ist->st->codec->time_base.num * ticks) /
1701 ist->st->codec->time_base.den;
1704 buffer_to_free = NULL;
1705 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1707 case AVMEDIA_TYPE_SUBTITLE:
1708 ret = avcodec_decode_subtitle2(ist->st->codec,
1709 &subtitle, &got_output, &avpkt);
1713 goto discard_packet;
1715 subtitle_to_free = &subtitle;
1722 switch(ist->st->codec->codec_type) {
1723 case AVMEDIA_TYPE_AUDIO:
1724 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1725 ist->st->codec->sample_rate;
1727 case AVMEDIA_TYPE_VIDEO:
1728 if (ist->st->codec->time_base.num != 0) {
1729 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1730 ist->next_pts += ((int64_t)AV_TIME_BASE *
1731 ist->st->codec->time_base.num * ticks) /
1732 ist->st->codec->time_base.den;
1739 // preprocess audio (volume)
1740 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1741 if (audio_volume != 256) {
1744 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1745 int v = ((*volp) * audio_volume + 128) >> 8;
1746 *volp++ = av_clip_int16(v);
1751 /* frame rate emulation */
1752 if (input_files[ist->file_index].rate_emu) {
1753 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1754 int64_t now = av_gettime() - ist->start;
1758 /* if output time reached then transcode raw format,
1759 encode packets and output them */
1760 for (i = 0; i < nb_ostreams; i++) {
1761 OutputFile *of = &output_files[ost_table[i].file_index];
1764 ost = &ost_table[i];
1765 if (ost->source_index != ist_index)
1768 if (of->start_time && ist->pts < of->start_time)
1771 if (of->recording_time != INT64_MAX &&
1772 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1773 (AVRational){1, 1000000}) >= 0) {
1774 ost->is_past_recording_time = 1;
1779 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1780 ost->input_video_filter) {
1781 if (!picture.sample_aspect_ratio.num)
1782 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1783 picture.pts = ist->pts;
1785 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1787 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1788 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1789 while (frame_available) {
1790 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1791 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1792 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1795 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1796 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1800 os = output_files[ost->file_index].ctx;
1802 /* set the input output pts pairs */
1803 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1805 if (ost->encoding_needed) {
1806 av_assert0(ist->decoding_needed);
1807 switch(ost->st->codec->codec_type) {
1808 case AVMEDIA_TYPE_AUDIO:
1809 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1811 case AVMEDIA_TYPE_VIDEO:
1813 if (ost->picref->video && !ost->frame_aspect_ratio)
1814 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1816 do_video_out(os, ost, ist, &picture, &frame_size,
1817 same_quant ? quality : ost->st->codec->global_quality);
1818 if (vstats_filename && frame_size)
1819 do_video_stats(os, ost, frame_size);
1821 case AVMEDIA_TYPE_SUBTITLE:
1822 do_subtitle_out(os, ost, ist, &subtitle,
1829 AVFrame avframe; //FIXME/XXX remove this
1832 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1833 av_init_packet(&opkt);
1835 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1836 #if !CONFIG_AVFILTER
1842 /* no reencoding needed : output the packet directly */
1843 /* force the input stream PTS */
1845 avcodec_get_frame_defaults(&avframe);
1846 ost->st->codec->coded_frame= &avframe;
1847 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1849 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1850 audio_size += data_size;
1851 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1852 video_size += data_size;
1856 opkt.stream_index= ost->index;
1857 if(pkt->pts != AV_NOPTS_VALUE)
1858 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1860 opkt.pts= AV_NOPTS_VALUE;
1862 if (pkt->dts == AV_NOPTS_VALUE)
1863 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1865 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1866 opkt.dts -= ost_tb_start_time;
1868 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1869 opkt.flags= pkt->flags;
1871 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1872 if( ost->st->codec->codec_id != CODEC_ID_H264
1873 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1874 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1876 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1877 opkt.destruct= av_destruct_packet;
1879 opkt.data = data_buf;
1880 opkt.size = data_size;
1883 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1884 /* store AVPicture in AVPacket, as expected by the output format */
1885 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1886 opkt.data = (uint8_t *)&pict;
1887 opkt.size = sizeof(AVPicture);
1888 opkt.flags |= AV_PKT_FLAG_KEY;
1890 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1891 ost->st->codec->frame_number++;
1892 ost->frame_number++;
1893 av_free_packet(&opkt);
1897 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1898 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1900 avfilter_unref_buffer(ost->picref);
1905 av_free(buffer_to_free);
1906 /* XXX: allocate the subtitles in the codec ? */
1907 if (subtitle_to_free) {
1908 avsubtitle_free(subtitle_to_free);
1909 subtitle_to_free = NULL;
1917 static void print_sdp(OutputFile *output_files, int n)
1921 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1925 for (i = 0; i < n; i++)
1926 avc[i] = output_files[i].ctx;
1928 av_sdp_create(avc, n, sdp, sizeof(sdp));
1929 printf("SDP:\n%s\n", sdp);
1934 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1935 char *error, int error_len)
1938 InputStream *ist = &input_streams[ist_index];
1939 if (ist->decoding_needed) {
1940 AVCodec *codec = ist->dec;
1942 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1943 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1944 return AVERROR(EINVAL);
1947 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1948 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1949 ist->file_index, ist->st->index);
1950 return AVERROR(EINVAL);
1952 assert_codec_experimental(ist->st->codec, 0);
1953 assert_avoptions(ist->opts);
1956 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;
1957 ist->next_pts = AV_NOPTS_VALUE;
1963 static int transcode_init(OutputFile *output_files,
1964 int nb_output_files,
1965 InputFile *input_files,
1968 int ret = 0, i, j, k;
1969 AVFormatContext *os;
1970 AVCodecContext *codec, *icodec;
1976 /* init framerate emulation */
1977 for (i = 0; i < nb_input_files; i++) {
1978 InputFile *ifile = &input_files[i];
1979 if (ifile->rate_emu)
1980 for (j = 0; j < ifile->nb_streams; j++)
1981 input_streams[j + ifile->ist_index].start = av_gettime();
1984 /* output stream init */
1985 for(i=0;i<nb_output_files;i++) {
1986 os = output_files[i].ctx;
1987 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1988 av_dump_format(os, i, os->filename, 1);
1989 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1990 return AVERROR(EINVAL);
1994 /* for each output stream, we compute the right encoding parameters */
1995 for (i = 0; i < nb_output_streams; i++) {
1996 ost = &output_streams[i];
1997 os = output_files[ost->file_index].ctx;
1998 ist = &input_streams[ost->source_index];
2000 codec = ost->st->codec;
2001 icodec = ist->st->codec;
2003 ost->st->disposition = ist->st->disposition;
2004 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2005 codec->chroma_sample_location = icodec->chroma_sample_location;
2007 if (ost->st->stream_copy) {
2008 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2010 if (extra_size > INT_MAX) {
2011 return AVERROR(EINVAL);
2014 /* if stream_copy is selected, no need to decode or encode */
2015 codec->codec_id = icodec->codec_id;
2016 codec->codec_type = icodec->codec_type;
2018 if(!codec->codec_tag){
2019 if( !os->oformat->codec_tag
2020 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2021 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2022 codec->codec_tag = icodec->codec_tag;
2025 codec->bit_rate = icodec->bit_rate;
2026 codec->rc_max_rate = icodec->rc_max_rate;
2027 codec->rc_buffer_size = icodec->rc_buffer_size;
2028 codec->extradata= av_mallocz(extra_size);
2029 if (!codec->extradata) {
2030 return AVERROR(ENOMEM);
2032 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2033 codec->extradata_size= icodec->extradata_size;
2035 codec->time_base = ist->st->time_base;
2036 if(!strcmp(os->oformat->name, "avi")) {
2037 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){
2038 codec->time_base = icodec->time_base;
2039 codec->time_base.num *= icodec->ticks_per_frame;
2040 codec->time_base.den *= 2;
2042 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2043 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){
2044 codec->time_base = icodec->time_base;
2045 codec->time_base.num *= icodec->ticks_per_frame;
2048 av_reduce(&codec->time_base.num, &codec->time_base.den,
2049 codec->time_base.num, codec->time_base.den, INT_MAX);
2051 switch(codec->codec_type) {
2052 case AVMEDIA_TYPE_AUDIO:
2053 if(audio_volume != 256) {
2054 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2057 codec->channel_layout = icodec->channel_layout;
2058 codec->sample_rate = icodec->sample_rate;
2059 codec->channels = icodec->channels;
2060 codec->frame_size = icodec->frame_size;
2061 codec->audio_service_type = icodec->audio_service_type;
2062 codec->block_align= icodec->block_align;
2063 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2064 codec->block_align= 0;
2065 if(codec->codec_id == CODEC_ID_AC3)
2066 codec->block_align= 0;
2068 case AVMEDIA_TYPE_VIDEO:
2069 codec->pix_fmt = icodec->pix_fmt;
2070 codec->width = icodec->width;
2071 codec->height = icodec->height;
2072 codec->has_b_frames = icodec->has_b_frames;
2073 if (!codec->sample_aspect_ratio.num) {
2074 codec->sample_aspect_ratio =
2075 ost->st->sample_aspect_ratio =
2076 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2077 ist->st->codec->sample_aspect_ratio.num ?
2078 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2081 case AVMEDIA_TYPE_SUBTITLE:
2082 codec->width = icodec->width;
2083 codec->height = icodec->height;
2085 case AVMEDIA_TYPE_DATA:
2092 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2093 switch(codec->codec_type) {
2094 case AVMEDIA_TYPE_AUDIO:
2095 ost->fifo= av_fifo_alloc(1024);
2097 return AVERROR(ENOMEM);
2099 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2100 if (!codec->sample_rate) {
2101 codec->sample_rate = icodec->sample_rate;
2103 choose_sample_rate(ost->st, ost->enc);
2104 codec->time_base = (AVRational){1, codec->sample_rate};
2105 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2106 codec->sample_fmt = icodec->sample_fmt;
2107 choose_sample_fmt(ost->st, ost->enc);
2108 if (!codec->channels) {
2109 codec->channels = icodec->channels;
2110 codec->channel_layout = icodec->channel_layout;
2112 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2113 codec->channel_layout = 0;
2114 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2115 icodec->request_channels = codec->channels;
2116 ist->decoding_needed = 1;
2117 ost->encoding_needed = 1;
2118 ost->resample_sample_fmt = icodec->sample_fmt;
2119 ost->resample_sample_rate = icodec->sample_rate;
2120 ost->resample_channels = icodec->channels;
2122 case AVMEDIA_TYPE_VIDEO:
2123 if (codec->pix_fmt == PIX_FMT_NONE)
2124 codec->pix_fmt = icodec->pix_fmt;
2125 choose_pixel_fmt(ost->st, ost->enc);
2127 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2128 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2132 if (!codec->width || !codec->height) {
2133 codec->width = icodec->width;
2134 codec->height = icodec->height;
2137 ost->video_resample = codec->width != icodec->width ||
2138 codec->height != icodec->height ||
2139 codec->pix_fmt != icodec->pix_fmt;
2140 if (ost->video_resample) {
2141 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2144 ost->resample_height = icodec->height;
2145 ost->resample_width = icodec->width;
2146 ost->resample_pix_fmt= icodec->pix_fmt;
2147 ost->encoding_needed = 1;
2148 ist->decoding_needed = 1;
2150 if (!ost->frame_rate.num)
2151 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2152 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2153 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2154 ost->frame_rate = ost->enc->supported_framerates[idx];
2156 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2157 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2158 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2159 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2160 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2164 if (configure_video_filters(ist, ost)) {
2165 fprintf(stderr, "Error opening filters!\n");
2170 case AVMEDIA_TYPE_SUBTITLE:
2171 ost->encoding_needed = 1;
2172 ist->decoding_needed = 1;
2179 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2180 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2181 char logfilename[1024];
2184 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2185 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2187 if (codec->flags & CODEC_FLAG_PASS1) {
2188 f = fopen(logfilename, "wb");
2190 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2196 size_t logbuffer_size;
2197 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2198 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2201 codec->stats_in = logbuffer;
2205 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2206 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2207 int size= codec->width * codec->height;
2208 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2213 bit_buffer = av_malloc(bit_buffer_size);
2215 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2217 return AVERROR(ENOMEM);
2220 /* open each encoder */
2221 for (i = 0; i < nb_output_streams; i++) {
2222 ost = &output_streams[i];
2223 if (ost->encoding_needed) {
2224 AVCodec *codec = ost->enc;
2225 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2227 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2228 ost->st->codec->codec_id, ost->file_index, ost->index);
2229 ret = AVERROR(EINVAL);
2232 if (dec->subtitle_header) {
2233 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2234 if (!ost->st->codec->subtitle_header) {
2235 ret = AVERROR(ENOMEM);
2238 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2239 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2241 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2242 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2243 ost->file_index, ost->index);
2244 ret = AVERROR(EINVAL);
2247 assert_codec_experimental(ost->st->codec, 1);
2248 assert_avoptions(ost->opts);
2249 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2250 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2251 "It takes bits/s as argument, not kbits/s\n");
2252 extra_size += ost->st->codec->extradata_size;
2254 if (ost->st->codec->me_threshold)
2255 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2259 /* init input streams */
2260 for (i = 0; i < nb_input_streams; i++)
2261 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2264 /* discard unused programs */
2265 for (i = 0; i < nb_input_files; i++) {
2266 InputFile *ifile = &input_files[i];
2267 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2268 AVProgram *p = ifile->ctx->programs[j];
2269 int discard = AVDISCARD_ALL;
2271 for (k = 0; k < p->nb_stream_indexes; k++)
2272 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2273 discard = AVDISCARD_DEFAULT;
2276 p->discard = discard;
2280 /* open files and write file headers */
2281 for (i = 0; i < nb_output_files; i++) {
2282 os = output_files[i].ctx;
2283 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2284 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2285 ret = AVERROR(EINVAL);
2288 // assert_avoptions(output_files[i].opts);
2289 if (strcmp(os->oformat->name, "rtp")) {
2295 /* dump the file output parameters - cannot be done before in case
2297 for(i=0;i<nb_output_files;i++) {
2298 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2301 /* dump the stream mapping */
2303 fprintf(stderr, "Stream mapping:\n");
2304 for (i = 0; i < nb_output_streams;i ++) {
2305 ost = &output_streams[i];
2306 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2307 input_streams[ost->source_index].file_index,
2308 input_streams[ost->source_index].st->index,
2311 if (ost->sync_ist != &input_streams[ost->source_index])
2312 fprintf(stderr, " [sync #%d.%d]",
2313 ost->sync_ist->file_index,
2314 ost->sync_ist->st->index);
2315 if (ost->st->stream_copy)
2316 fprintf(stderr, " (copy)");
2318 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2319 input_streams[ost->source_index].dec->name : "?",
2320 ost->enc ? ost->enc->name : "?");
2321 fprintf(stderr, "\n");
2326 fprintf(stderr, "%s\n", error);
2331 print_sdp(output_files, nb_output_files);
2338 * The following code is the main loop of the file converter
2340 static int transcode(OutputFile *output_files,
2341 int nb_output_files,
2342 InputFile *input_files,
2346 AVFormatContext *is, *os;
2350 int no_packet_count=0;
2351 int64_t timer_start;
2354 if (!(no_packet = av_mallocz(nb_input_files)))
2357 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2363 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2364 avio_set_interrupt_cb(decode_interrupt_cb);
2368 timer_start = av_gettime();
2370 for(; received_sigterm == 0;) {
2371 int file_index, ist_index;
2376 ipts_min = INT64_MAX;
2378 /* if 'q' pressed, exits */
2382 /* read_key() returns 0 on EOF */
2386 if (key == '+') verbose++;
2387 if (key == '-') verbose--;
2388 if (key == 's') qp_hist ^= 1;
2391 do_hex_dump = do_pkt_dump = 0;
2392 } else if(do_pkt_dump){
2396 av_log_set_level(AV_LOG_DEBUG);
2398 if (key == 'd' || key == 'D'){
2401 debug = input_streams[0].st->codec->debug<<1;
2402 if(!debug) debug = 1;
2403 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2406 scanf("%d", &debug);
2407 for(i=0;i<nb_input_streams;i++) {
2408 input_streams[i].st->codec->debug = debug;
2410 for(i=0;i<nb_output_streams;i++) {
2411 ost = &output_streams[i];
2412 ost->st->codec->debug = debug;
2414 if(debug) av_log_set_level(AV_LOG_DEBUG);
2415 fprintf(stderr,"debug=%d\n", debug);
2418 fprintf(stderr, "key function\n"
2419 "? show this help\n"
2420 "+ increase verbosity\n"
2421 "- decrease verbosity\n"
2422 "D cycle through available debug modes\n"
2423 "h dump packets/hex press to cycle through the 3 states\n"
2425 "s Show QP histogram\n"
2430 /* select the stream that we must read now by looking at the
2431 smallest output pts */
2433 for (i = 0; i < nb_output_streams; i++) {
2437 ost = &output_streams[i];
2438 of = &output_files[ost->file_index];
2439 os = output_files[ost->file_index].ctx;
2440 ist = &input_streams[ost->source_index];
2441 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2442 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2444 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2446 if (!input_files[ist->file_index].eof_reached){
2447 if(ipts < ipts_min) {
2449 if(input_sync ) file_index = ist->file_index;
2451 if(opts < opts_min) {
2453 if(!input_sync) file_index = ist->file_index;
2456 if (ost->frame_number >= ost->max_frames) {
2458 for (j = of->ost_index; j < of->ctx->nb_streams; j++)
2459 output_streams[j].is_past_recording_time = 1;
2463 /* if none, if is finished */
2464 if (file_index < 0) {
2465 if(no_packet_count){
2467 memset(no_packet, 0, nb_input_files);
2474 /* read a frame from it and output it in the fifo */
2475 is = input_files[file_index].ctx;
2476 ret= av_read_frame(is, &pkt);
2477 if(ret == AVERROR(EAGAIN)){
2478 no_packet[file_index]=1;
2483 input_files[file_index].eof_reached = 1;
2491 memset(no_packet, 0, nb_input_files);
2494 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2495 is->streams[pkt.stream_index]);
2497 /* the following test is needed in case new streams appear
2498 dynamically in stream : we ignore them */
2499 if (pkt.stream_index >= input_files[file_index].nb_streams)
2500 goto discard_packet;
2501 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2502 ist = &input_streams[ist_index];
2504 goto discard_packet;
2506 if (pkt.dts != AV_NOPTS_VALUE)
2507 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2508 if (pkt.pts != AV_NOPTS_VALUE)
2509 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2511 if(pkt.pts != AV_NOPTS_VALUE)
2512 pkt.pts *= ist->ts_scale;
2513 if(pkt.dts != AV_NOPTS_VALUE)
2514 pkt.dts *= ist->ts_scale;
2516 // 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);
2517 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2518 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2519 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2520 int64_t delta= pkt_dts - ist->next_pts;
2521 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2522 input_files[ist->file_index].ts_offset -= delta;
2524 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2525 delta, input_files[ist->file_index].ts_offset);
2526 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2527 if(pkt.pts != AV_NOPTS_VALUE)
2528 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2532 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2533 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2536 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2537 ist->file_index, ist->st->index);
2540 av_free_packet(&pkt);
2545 av_free_packet(&pkt);
2547 /* dump report by using the output first video and audio streams */
2548 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2551 /* at the end of stream, we must flush the decoder buffers */
2552 for (i = 0; i < nb_input_streams; i++) {
2553 ist = &input_streams[i];
2554 if (ist->decoding_needed) {
2555 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2558 flush_encoders(output_streams, nb_output_streams);
2562 /* write the trailer if needed and close file */
2563 for(i=0;i<nb_output_files;i++) {
2564 os = output_files[i].ctx;
2565 av_write_trailer(os);
2568 /* dump report by using the first video and audio streams */
2569 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2571 /* close each encoder */
2572 for (i = 0; i < nb_output_streams; i++) {
2573 ost = &output_streams[i];
2574 if (ost->encoding_needed) {
2575 av_freep(&ost->st->codec->stats_in);
2576 avcodec_close(ost->st->codec);
2579 avfilter_graph_free(&ost->graph);
2583 /* close each decoder */
2584 for (i = 0; i < nb_input_streams; i++) {
2585 ist = &input_streams[i];
2586 if (ist->decoding_needed) {
2587 avcodec_close(ist->st->codec);
2595 av_freep(&bit_buffer);
2596 av_freep(&no_packet);
2598 if (output_streams) {
2599 for (i = 0; i < nb_output_streams; i++) {
2600 ost = &output_streams[i];
2602 if (ost->st->stream_copy)
2603 av_freep(&ost->st->codec->extradata);
2605 fclose(ost->logfile);
2606 ost->logfile = NULL;
2608 av_fifo_free(ost->fifo); /* works even if fifo is not
2609 initialized but set to zero */
2610 av_freep(&ost->st->codec->subtitle_header);
2611 av_free(ost->resample_frame.data[0]);
2612 av_free(ost->forced_kf_pts);
2613 if (ost->video_resample)
2614 sws_freeContext(ost->img_resample_ctx);
2616 audio_resample_close(ost->resample);
2617 if (ost->reformat_ctx)
2618 av_audio_convert_free(ost->reformat_ctx);
2619 av_dict_free(&ost->opts);
2626 static int opt_verbose(const char *opt, const char *arg)
2628 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2632 static double parse_frame_aspect_ratio(const char *arg)
2639 p = strchr(arg, ':');
2641 x = strtol(arg, &end, 10);
2643 y = strtol(end+1, &end, 10);
2645 ar = (double)x / (double)y;
2647 ar = strtod(arg, NULL);
2650 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2656 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2658 return parse_option(o, "codec:a", arg, options);
2661 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2663 return parse_option(o, "codec:v", arg, options);
2666 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2668 return parse_option(o, "codec:s", arg, options);
2671 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2673 return parse_option(o, "codec:d", arg, options);
2676 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2678 StreamMap *m = NULL;
2679 int i, negative = 0, file_idx;
2680 int sync_file_idx = -1, sync_stream_idx;
2688 map = av_strdup(arg);
2690 /* parse sync stream first, just pick first matching stream */
2691 if (sync = strchr(map, ',')) {
2693 sync_file_idx = strtol(sync + 1, &sync, 0);
2694 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2695 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2700 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2701 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2702 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2703 sync_stream_idx = i;
2706 if (i == input_files[sync_file_idx].nb_streams) {
2707 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2708 "match any streams.\n", arg);
2714 file_idx = strtol(map, &p, 0);
2715 if (file_idx >= nb_input_files || file_idx < 0) {
2716 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2720 /* disable some already defined maps */
2721 for (i = 0; i < o->nb_stream_maps; i++) {
2722 m = &o->stream_maps[i];
2723 if (check_stream_specifier(input_files[m->file_index].ctx,
2724 input_files[m->file_index].ctx->streams[m->stream_index],
2725 *p == ':' ? p + 1 : p) > 0)
2729 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2730 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2731 *p == ':' ? p + 1 : p) <= 0)
2733 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2734 &o->nb_stream_maps, o->nb_stream_maps + 1);
2735 m = &o->stream_maps[o->nb_stream_maps - 1];
2737 m->file_index = file_idx;
2738 m->stream_index = i;
2740 if (sync_file_idx >= 0) {
2741 m->sync_file_index = sync_file_idx;
2742 m->sync_stream_index = sync_stream_idx;
2744 m->sync_file_index = file_idx;
2745 m->sync_stream_index = i;
2750 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2758 static void parse_meta_type(char *arg, char *type, int *index)
2768 if (*(++arg) == ':')
2769 *index = strtol(++arg, NULL, 0);
2772 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2779 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2781 MetadataMap *m, *m1;
2784 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2785 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2787 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2788 m->file = strtol(arg, &p, 0);
2789 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2791 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2792 if (p = strchr(opt, ':'))
2793 parse_meta_type(p + 1, &m1->type, &m1->index);
2797 if (m->type == 'g' || m1->type == 'g')
2798 o->metadata_global_manual = 1;
2799 if (m->type == 's' || m1->type == 's')
2800 o->metadata_streams_manual = 1;
2801 if (m->type == 'c' || m1->type == 'c')
2802 o->metadata_chapters_manual = 1;
2807 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2809 const char *codec_string = encoder ? "encoder" : "decoder";
2813 return CODEC_ID_NONE;
2815 avcodec_find_encoder_by_name(name) :
2816 avcodec_find_decoder_by_name(name);
2818 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2821 if(codec->type != type) {
2822 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2828 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2830 char *codec_name = NULL;
2832 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2836 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2837 return avcodec_find_encoder(st->codec->codec_id);
2839 } else if (!strcmp(codec_name, "copy"))
2840 st->stream_copy = 1;
2842 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2843 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2844 avcodec_find_decoder_by_name(codec_name);
2851 * Add all the streams from the given input file to the global
2852 * list of input streams.
2854 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2856 int i, rfps, rfps_base;
2858 for (i = 0; i < ic->nb_streams; i++) {
2859 AVStream *st = ic->streams[i];
2860 AVCodecContext *dec = st->codec;
2864 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2865 ist = &input_streams[nb_input_streams - 1];
2867 ist->file_index = nb_input_files;
2869 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2871 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2872 ist->ts_scale = scale;
2874 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2876 ist->dec = avcodec_find_decoder(dec->codec_id);
2878 switch (dec->codec_type) {
2879 case AVMEDIA_TYPE_AUDIO:
2881 ist->dec = avcodec_find_decoder(dec->codec_id);
2882 if(o->audio_disable)
2883 st->discard= AVDISCARD_ALL;
2885 case AVMEDIA_TYPE_VIDEO:
2887 ist->dec = avcodec_find_decoder(dec->codec_id);
2888 rfps = ic->streams[i]->r_frame_rate.num;
2889 rfps_base = ic->streams[i]->r_frame_rate.den;
2891 dec->flags |= CODEC_FLAG_EMU_EDGE;
2894 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2897 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2898 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2900 (float)rfps / rfps_base, rfps, rfps_base);
2903 if (o->video_disable)
2904 st->discard= AVDISCARD_ALL;
2905 else if(video_discard)
2906 st->discard= video_discard;
2908 case AVMEDIA_TYPE_DATA:
2910 case AVMEDIA_TYPE_SUBTITLE:
2912 ist->dec = avcodec_find_decoder(dec->codec_id);
2913 if(o->subtitle_disable)
2914 st->discard = AVDISCARD_ALL;
2916 case AVMEDIA_TYPE_ATTACHMENT:
2917 case AVMEDIA_TYPE_UNKNOWN:
2925 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2927 AVFormatContext *ic;
2928 AVInputFormat *file_iformat = NULL;
2932 AVDictionary **opts;
2933 int orig_nb_streams; // number of streams before avformat_find_stream_info
2936 if (!(file_iformat = av_find_input_format(o->format))) {
2937 fprintf(stderr, "Unknown input format: '%s'\n", o->format);
2942 if (!strcmp(filename, "-"))
2945 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2946 !strcmp(filename, "/dev/stdin");
2948 /* get default parameters from command line */
2949 ic = avformat_alloc_context();
2951 print_error(filename, AVERROR(ENOMEM));
2954 if (o->nb_audio_sample_rate) {
2955 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2956 av_dict_set(&format_opts, "sample_rate", buf, 0);
2958 if (o->nb_audio_channels) {
2959 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2960 av_dict_set(&format_opts, "channels", buf, 0);
2962 if (o->nb_frame_rates) {
2963 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2965 if (o->nb_frame_sizes) {
2966 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2968 if (o->nb_frame_pix_fmts)
2969 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
2971 ic->flags |= AVFMT_FLAG_NONBLOCK;
2973 /* open the input file with generic libav function */
2974 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2976 print_error(filename, err);
2979 assert_avoptions(format_opts);
2981 /* apply forced codec ids */
2982 for (i = 0; i < ic->nb_streams; i++)
2983 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
2985 /* Set AVCodecContext options for avformat_find_stream_info */
2986 opts = setup_find_stream_info_opts(ic, codec_opts);
2987 orig_nb_streams = ic->nb_streams;
2989 /* If not enough info to get the stream parameters, we decode the
2990 first frames to get it. (used in mpeg case for example) */
2991 ret = avformat_find_stream_info(ic, opts);
2992 if (ret < 0 && verbose >= 0) {
2993 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2994 av_close_input_file(ic);
2998 timestamp = o->start_time;
2999 /* add the stream start time */
3000 if (ic->start_time != AV_NOPTS_VALUE)
3001 timestamp += ic->start_time;
3003 /* if seeking requested, we execute it */
3004 if (o->start_time != 0) {
3005 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3007 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3008 filename, (double)timestamp / AV_TIME_BASE);
3012 /* update the current parameters so that they match the one of the input stream */
3013 add_input_streams(o, ic);
3015 /* dump the file content */
3017 av_dump_format(ic, nb_input_files, filename, 0);
3019 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3020 input_files[nb_input_files - 1].ctx = ic;
3021 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3022 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3023 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3025 for (i = 0; i < orig_nb_streams; i++)
3026 av_dict_free(&opts[i]);
3033 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3034 AVCodecContext *avctx)
3040 for (p = kf; *p; p++)
3043 ost->forced_kf_count = n;
3044 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3045 if (!ost->forced_kf_pts) {
3046 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3049 for (i = 0; i < n; i++) {
3050 p = i ? strchr(p, ',') + 1 : kf;
3051 t = parse_time_or_die("force_key_frames", p, 1);
3052 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3056 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3059 AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
3060 int idx = oc->nb_streams - 1;
3061 int64_t max_frames = INT64_MAX;
3062 char *bsf = NULL, *next, *codec_tag = NULL;
3063 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3067 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3071 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3072 nb_output_streams + 1);
3073 ost = &output_streams[nb_output_streams - 1];
3074 ost->file_index = nb_output_files;
3077 st->codec->codec_type = type;
3078 ost->enc = choose_codec(o, oc, st, type);
3080 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3083 avcodec_get_context_defaults3(st->codec, ost->enc);
3084 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3086 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3087 ost->max_frames = max_frames;
3089 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3091 if (next = strchr(bsf, ','))
3093 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3094 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter %s\n", bsf);
3098 bsfc_prev->next = bsfc;
3100 ost->bitstream_filters = bsfc;
3106 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3108 uint32_t tag = strtol(codec_tag, &next, 0);
3110 tag = AV_RL32(codec_tag);
3111 st->codec->codec_tag = tag;
3114 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3115 if (qscale >= 0 || same_quant) {
3116 st->codec->flags |= CODEC_FLAG_QSCALE;
3117 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3120 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3124 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3127 const char *p = str;
3134 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3141 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3145 AVCodecContext *video_enc;
3147 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3149 video_enc = st->codec;
3151 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3152 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3155 if (!st->stream_copy) {
3156 const char *p = NULL;
3157 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3158 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3159 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3160 int i, force_fps = 0, top_field_first = -1;
3162 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3163 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3164 av_log(NULL, AV_LOG_ERROR, "Invalid framerate value: %s\n", frame_rate);
3168 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3169 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3170 av_log(NULL, AV_LOG_ERROR, "Invalid frame size: %s.\n", frame_size);
3174 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3175 if (frame_aspect_ratio)
3176 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3178 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3179 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3180 av_log(NULL, AV_LOG_ERROR, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3183 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3185 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3187 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3188 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for intra matrix.\n");
3191 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3193 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3195 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3196 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for inter matrix.\n");
3199 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3202 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3205 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3207 fprintf(stderr, "error parsing rc_override\n");
3210 video_enc->rc_override=
3211 av_realloc(video_enc->rc_override,
3212 sizeof(RcOverride)*(i+1));
3213 video_enc->rc_override[i].start_frame= start;
3214 video_enc->rc_override[i].end_frame = end;
3216 video_enc->rc_override[i].qscale= q;
3217 video_enc->rc_override[i].quality_factor= 1.0;
3220 video_enc->rc_override[i].qscale= 0;
3221 video_enc->rc_override[i].quality_factor= -q/100.0;
3226 video_enc->rc_override_count=i;
3227 if (!video_enc->rc_initial_buffer_occupancy)
3228 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3229 video_enc->intra_dc_precision= intra_dc_precision - 8;
3234 video_enc->flags |= CODEC_FLAG_PASS1;
3236 video_enc->flags |= CODEC_FLAG_PASS2;
3240 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3241 if (forced_key_frames)
3242 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3244 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3245 ost->force_fps = force_fps;
3247 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3248 ost->top_field_first = top_field_first;
3251 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3253 ost->avfilter = av_strdup(filters);
3260 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3264 AVCodecContext *audio_enc;
3266 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3269 audio_enc = st->codec;
3270 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3272 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3273 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3275 if (!st->stream_copy) {
3276 char *sample_fmt = NULL;
3278 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3280 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3282 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3283 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", sample_fmt);
3287 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3293 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3297 AVCodecContext *data_enc;
3299 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3301 data_enc = st->codec;
3302 if (!st->stream_copy) {
3303 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3307 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3308 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3314 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3318 AVCodecContext *subtitle_enc;
3320 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3322 subtitle_enc = st->codec;
3324 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3326 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3327 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3333 /* arg format is "output-stream-index:streamid-value". */
3334 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3340 av_strlcpy(idx_str, arg, sizeof(idx_str));
3341 p = strchr(idx_str, ':');
3344 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3349 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3350 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3351 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3355 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3357 AVFormatContext *is = ifile->ctx;
3358 AVFormatContext *os = ofile->ctx;
3361 for (i = 0; i < is->nb_chapters; i++) {
3362 AVChapter *in_ch = is->chapters[i], *out_ch;
3363 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3364 AV_TIME_BASE_Q, in_ch->time_base);
3365 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3366 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3369 if (in_ch->end < ts_off)
3371 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3374 out_ch = av_mallocz(sizeof(AVChapter));
3376 return AVERROR(ENOMEM);
3378 out_ch->id = in_ch->id;
3379 out_ch->time_base = in_ch->time_base;
3380 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3381 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3384 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3387 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3389 return AVERROR(ENOMEM);
3390 os->chapters[os->nb_chapters - 1] = out_ch;
3395 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3398 AVFormatContext *ic = NULL;
3400 err = avformat_open_input(&ic, filename, NULL, NULL);
3403 /* copy stream format */
3404 for(i=0;i<ic->nb_streams;i++) {
3409 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3410 ost = new_output_stream(o, s, codec->type);
3413 // FIXME: a more elegant solution is needed
3414 memcpy(st, ic->streams[i], sizeof(AVStream));
3415 st->info = av_malloc(sizeof(*st->info));
3416 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3417 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3419 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3420 choose_sample_fmt(st, codec);
3421 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3422 choose_pixel_fmt(st, codec);
3425 av_close_input_file(ic);
3429 static void opt_output_file(void *optctx, const char *filename)
3431 OptionsContext *o = optctx;
3432 AVFormatContext *oc;
3434 AVOutputFormat *file_oformat;
3438 if (!strcmp(filename, "-"))
3441 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3443 print_error(filename, err);
3447 file_oformat= oc->oformat;
3449 if (!strcmp(file_oformat->name, "ffm") &&
3450 av_strstart(filename, "http:", NULL)) {
3451 /* special case for files sent to ffserver: we get the stream
3452 parameters from ffserver */
3453 int err = read_ffserver_streams(o, oc, filename);
3455 print_error(filename, err);
3458 } else if (!o->nb_stream_maps) {
3459 /* pick the "best" stream of each type */
3460 #define NEW_STREAM(type, index)\
3462 ost = new_ ## type ## _stream(o, oc);\
3463 ost->source_index = index;\
3464 ost->sync_ist = &input_streams[index];\
3465 input_streams[index].discard = 0;\
3468 /* video: highest resolution */
3469 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3470 int area = 0, idx = -1;
3471 for (i = 0; i < nb_input_streams; i++) {
3472 ist = &input_streams[i];
3473 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3474 ist->st->codec->width * ist->st->codec->height > area) {
3475 area = ist->st->codec->width * ist->st->codec->height;
3479 NEW_STREAM(video, idx);
3482 /* audio: most channels */
3483 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3484 int channels = 0, idx = -1;
3485 for (i = 0; i < nb_input_streams; i++) {
3486 ist = &input_streams[i];
3487 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3488 ist->st->codec->channels > channels) {
3489 channels = ist->st->codec->channels;
3493 NEW_STREAM(audio, idx);
3496 /* subtitles: pick first */
3497 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3498 for (i = 0; i < nb_input_streams; i++)
3499 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3500 NEW_STREAM(subtitle, i);
3504 /* do something with data? */
3506 for (i = 0; i < o->nb_stream_maps; i++) {
3507 StreamMap *map = &o->stream_maps[i];
3512 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3513 switch (ist->st->codec->codec_type) {
3514 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3515 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3516 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3517 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3519 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3520 map->file_index, map->stream_index);
3524 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3525 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3526 map->sync_stream_index];
3531 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3532 output_files[nb_output_files - 1].ctx = oc;
3533 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3534 output_files[nb_output_files - 1].recording_time = o->recording_time;
3535 output_files[nb_output_files - 1].start_time = o->start_time;
3536 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3537 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3539 /* check filename in case of an image number is expected */
3540 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3541 if (!av_filename_number_test(oc->filename)) {
3542 print_error(oc->filename, AVERROR(EINVAL));
3547 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3548 /* test if it already exists to avoid loosing precious files */
3549 if (!file_overwrite &&
3550 (strchr(filename, ':') == NULL ||
3551 filename[1] == ':' ||
3552 av_strstart(filename, "file:", NULL))) {
3553 if (avio_check(filename, 0) == 0) {
3555 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3557 if (!read_yesno()) {
3558 fprintf(stderr, "Not overwriting - exiting\n");
3563 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3570 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3571 print_error(filename, err);
3576 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3577 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3580 if (o->chapters_input_file >= nb_input_files) {
3581 if (o->chapters_input_file == INT_MAX) {
3582 /* copy chapters from the first input file that has them*/
3583 o->chapters_input_file = -1;
3584 for (i = 0; i < nb_input_files; i++)
3585 if (input_files[i].ctx->nb_chapters) {
3586 o->chapters_input_file = i;
3590 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3591 o->chapters_input_file);
3595 if (o->chapters_input_file >= 0)
3596 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3597 !o->metadata_chapters_manual);
3600 for (i = 0; i < o->nb_meta_data_maps; i++) {
3601 AVFormatContext *files[2];
3602 AVDictionary **meta[2];
3605 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3606 if ((index) < 0 || (index) >= (nb_elems)) {\
3607 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3612 int in_file_index = o->meta_data_maps[i][1].file;
3613 if (in_file_index < 0)
3615 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3618 files[1] = input_files[in_file_index].ctx;
3620 for (j = 0; j < 2; j++) {
3621 MetadataMap *map = &o->meta_data_maps[i][j];
3623 switch (map->type) {
3625 meta[j] = &files[j]->metadata;
3628 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3629 meta[j] = &files[j]->streams[map->index]->metadata;
3632 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3633 meta[j] = &files[j]->chapters[map->index]->metadata;
3636 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3637 meta[j] = &files[j]->programs[map->index]->metadata;
3642 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3645 /* copy global metadata by default */
3646 if (!o->metadata_global_manual && nb_input_files)
3647 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3648 AV_DICT_DONT_OVERWRITE);
3649 if (!o->metadata_streams_manual)
3650 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3651 InputStream *ist = &input_streams[output_streams[i].source_index];
3652 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3655 /* process manually set metadata */
3656 for (i = 0; i < o->nb_metadata; i++) {
3661 val = strchr(o->metadata[i].u.str, '=');
3663 av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3664 o->metadata[i].u.str);
3669 parse_meta_type(o->metadata[i].specifier, &type, &index);
3675 if (index < 0 || index >= oc->nb_streams) {
3676 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3679 m = &oc->streams[index]->metadata;
3682 if (index < 0 || index >= oc->nb_chapters) {
3683 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3686 m = &oc->chapters[index]->metadata;
3689 av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3693 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3699 /* same option as mencoder */
3700 static int opt_pass(const char *opt, const char *arg)
3702 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3706 static int64_t getutime(void)
3709 struct rusage rusage;
3711 getrusage(RUSAGE_SELF, &rusage);
3712 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3713 #elif HAVE_GETPROCESSTIMES
3715 FILETIME c, e, k, u;
3716 proc = GetCurrentProcess();
3717 GetProcessTimes(proc, &c, &e, &k, &u);
3718 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3720 return av_gettime();
3724 static int64_t getmaxrss(void)
3726 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3727 struct rusage rusage;
3728 getrusage(RUSAGE_SELF, &rusage);
3729 return (int64_t)rusage.ru_maxrss * 1024;
3730 #elif HAVE_GETPROCESSMEMORYINFO
3732 PROCESS_MEMORY_COUNTERS memcounters;
3733 proc = GetCurrentProcess();
3734 memcounters.cb = sizeof(memcounters);
3735 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3736 return memcounters.PeakPagefileUsage;
3742 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3744 return parse_option(o, "q:a", arg, options);
3747 static void show_usage(void)
3749 printf("Hyper fast Audio and Video encoder\n");
3750 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3754 static int opt_help(const char *opt, const char *arg)
3757 AVOutputFormat *oformat = NULL;
3758 AVInputFormat *iformat = NULL;
3759 const AVClass *class;
3761 av_log_set_callback(log_callback_help);
3763 show_help_options(options, "Main options:\n",
3764 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3765 show_help_options(options, "\nAdvanced options:\n",
3766 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3768 show_help_options(options, "\nVideo options:\n",
3769 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3771 show_help_options(options, "\nAdvanced Video options:\n",
3772 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3773 OPT_VIDEO | OPT_EXPERT);
3774 show_help_options(options, "\nAudio options:\n",
3775 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3777 show_help_options(options, "\nAdvanced Audio options:\n",
3778 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3779 OPT_AUDIO | OPT_EXPERT);
3780 show_help_options(options, "\nSubtitle options:\n",
3781 OPT_SUBTITLE | OPT_GRAB,
3783 show_help_options(options, "\nAudio/Video grab options:\n",
3787 class = avcodec_get_class();
3788 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3791 /* individual codec options */
3793 while ((c = av_codec_next(c))) {
3794 if (c->priv_class) {
3795 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3800 class = avformat_get_class();
3801 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3804 /* individual muxer options */
3805 while ((oformat = av_oformat_next(oformat))) {
3806 if (oformat->priv_class) {
3807 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3812 /* individual demuxer options */
3813 while ((iformat = av_iformat_next(iformat))) {
3814 if (iformat->priv_class) {
3815 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3820 class = sws_get_class();
3821 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3825 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3827 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3828 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3830 if(!strncmp(arg, "pal-", 4)) {
3833 } else if(!strncmp(arg, "ntsc-", 5)) {
3836 } else if(!strncmp(arg, "film-", 5)) {
3840 /* Try to determine PAL/NTSC by peeking in the input files */
3841 if(nb_input_files) {
3843 for (j = 0; j < nb_input_files; j++) {
3844 for (i = 0; i < input_files[j].nb_streams; i++) {
3845 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3846 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3848 fr = c->time_base.den * 1000 / c->time_base.num;
3852 } else if((fr == 29970) || (fr == 23976)) {
3861 if(verbose > 0 && norm != UNKNOWN)
3862 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3865 if(norm == UNKNOWN) {
3866 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3867 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3868 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3872 if(!strcmp(arg, "vcd")) {
3873 opt_video_codec(o, "c:v", "mpeg1video");
3874 opt_audio_codec(o, "c:a", "mp2");
3875 parse_option(o, "f", "vcd", options);
3877 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3878 parse_option(o, "r", frame_rates[norm], options);
3879 opt_default("g", norm == PAL ? "15" : "18");
3881 opt_default("b", "1150000");
3882 opt_default("maxrate", "1150000");
3883 opt_default("minrate", "1150000");
3884 opt_default("bufsize", "327680"); // 40*1024*8;
3886 opt_default("b:a", "224000");
3887 parse_option(o, "ar", "44100", options);
3888 parse_option(o, "ac", "2", options);
3890 opt_default("packetsize", "2324");
3891 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3893 /* We have to offset the PTS, so that it is consistent with the SCR.
3894 SCR starts at 36000, but the first two packs contain only padding
3895 and the first pack from the other stream, respectively, may also have
3896 been written before.
3897 So the real data starts at SCR 36000+3*1200. */
3898 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3899 } else if(!strcmp(arg, "svcd")) {
3901 opt_video_codec(o, "c:v", "mpeg2video");
3902 opt_audio_codec(o, "c:a", "mp2");
3903 parse_option(o, "f", "svcd", options);
3905 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3906 parse_option(o, "r", frame_rates[norm], options);
3907 opt_default("g", norm == PAL ? "15" : "18");
3909 opt_default("b", "2040000");
3910 opt_default("maxrate", "2516000");
3911 opt_default("minrate", "0"); //1145000;
3912 opt_default("bufsize", "1835008"); //224*1024*8;
3913 opt_default("flags", "+scan_offset");
3916 opt_default("b:a", "224000");
3917 parse_option(o, "ar", "44100", options);
3919 opt_default("packetsize", "2324");
3921 } else if(!strcmp(arg, "dvd")) {
3923 opt_video_codec(o, "c:v", "mpeg2video");
3924 opt_audio_codec(o, "c:a", "ac3");
3925 parse_option(o, "f", "dvd", options);
3927 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3928 parse_option(o, "r", frame_rates[norm], options);
3929 opt_default("g", norm == PAL ? "15" : "18");
3931 opt_default("b", "6000000");
3932 opt_default("maxrate", "9000000");
3933 opt_default("minrate", "0"); //1500000;
3934 opt_default("bufsize", "1835008"); //224*1024*8;
3936 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3937 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3939 opt_default("b:a", "448000");
3940 parse_option(o, "ar", "48000", options);
3942 } else if(!strncmp(arg, "dv", 2)) {
3944 parse_option(o, "f", "dv", options);
3946 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3947 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3948 norm == PAL ? "yuv420p" : "yuv411p", options);
3949 parse_option(o, "r", frame_rates[norm], options);
3951 parse_option(o, "ar", "48000", options);
3952 parse_option(o, "ac", "2", options);
3955 fprintf(stderr, "Unknown target: %s\n", arg);
3956 return AVERROR(EINVAL);
3961 static int opt_vstats_file(const char *opt, const char *arg)
3963 av_free (vstats_filename);
3964 vstats_filename=av_strdup (arg);
3968 static int opt_vstats(const char *opt, const char *arg)
3971 time_t today2 = time(NULL);
3972 struct tm *today = localtime(&today2);
3974 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3976 return opt_vstats_file(opt, filename);
3979 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
3981 return parse_option(o, "frames:v", arg, options);
3984 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
3986 return parse_option(o, "frames:a", arg, options);
3989 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
3991 return parse_option(o, "frames:d", arg, options);
3994 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
3998 static int opt_passlogfile(const char *opt, const char *arg)
4000 pass_logfilename_prefix = arg;
4001 #if CONFIG_LIBX264_ENCODER
4002 return opt_default("passlogfile", arg);
4008 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4010 return parse_option(o, "tag:v", arg, options);
4013 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4015 return parse_option(o, "tag:a", arg, options);
4018 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4020 return parse_option(o, "tag:s", arg, options);
4023 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4025 return parse_option(o, "filter:v", arg, options);
4028 #define OFFSET(x) offsetof(OptionsContext, x)
4029 static const OptionDef options[] = {
4031 #include "cmdutils_common_opts.h"
4032 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4033 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4034 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4035 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4036 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4037 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4038 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4039 "outfile[,metadata]:infile[,metadata]" },
4040 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4041 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4042 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4043 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4044 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4045 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4046 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4047 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4048 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4049 "add timings for benchmarking" },
4050 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4051 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4052 "dump each input packet" },
4053 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4054 "when dumping packets, also dump the payload" },
4055 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4056 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4057 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4058 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4059 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4060 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4061 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4062 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4063 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4064 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4065 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4066 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4067 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4068 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4069 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4070 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4072 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4076 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4077 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4078 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4079 { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4080 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4081 { "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" },
4082 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4083 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4084 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4085 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4086 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4087 "use same quantizer as source (implies VBR)" },
4088 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4089 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4090 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4091 "deinterlace pictures" },
4092 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4093 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4095 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4097 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4098 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4099 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4100 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4101 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4102 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4103 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4104 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4105 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
4108 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4109 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4110 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4111 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4112 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4113 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4114 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4115 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4116 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4118 /* subtitle options */
4119 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4120 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4121 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4124 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4127 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4128 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4130 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4132 /* data codec support */
4133 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4135 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4139 int main(int argc, char **argv)
4141 OptionsContext o = { 0 };
4146 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4148 if(argc>1 && !strcmp(argv[1], "-d")){
4151 av_log_set_callback(log_callback_null);
4156 avcodec_register_all();
4158 avdevice_register_all();
4161 avfilter_register_all();
4166 if(isatty(STDIN_FILENO))
4167 avio_set_interrupt_cb(decode_interrupt_cb);
4174 parse_options(&o, argc, argv, options, opt_output_file);
4176 if(nb_output_files <= 0 && nb_input_files == 0) {
4178 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4182 /* file converter / grab */
4183 if (nb_output_files <= 0) {
4184 fprintf(stderr, "At least one output file must be specified\n");
4188 if (nb_input_files == 0) {
4189 fprintf(stderr, "At least one input file must be specified\n");
4194 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4196 ti = getutime() - ti;
4198 int maxrss = getmaxrss() / 1024;
4199 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);