3 * Copyright (c) 2000-2011 The libav developers.
5 * This file is part of Libav.
7 * Libav 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 * Libav 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 Libav; 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"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "avconv";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
82 int disabled; /** 1 is this mapping is disabled by a negative map */
86 int sync_stream_index;
90 * select an input file for an output file
92 typedef struct MetadataMap {
93 int file; ///< file index
94 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
95 int index; ///< stream/chapter/program number
98 static const OptionDef options[];
100 static int video_discard = 0;
101 static int same_quant = 0;
102 static int do_deinterlace = 0;
103 static int intra_dc_precision = 8;
104 static int qp_hist = 0;
106 static int file_overwrite = 0;
107 static int do_benchmark = 0;
108 static int do_hex_dump = 0;
109 static int do_pkt_dump = 0;
110 static int do_pass = 0;
111 static char *pass_logfilename_prefix = NULL;
112 static int video_sync_method= -1;
113 static int audio_sync_method= 0;
114 static float audio_drift_threshold= 0.1;
115 static int copy_ts= 0;
117 static int opt_shortest = 0;
118 static char *vstats_filename;
119 static FILE *vstats_file;
120 static int copy_initial_nonkeyframes = 0;
122 static int audio_volume = 256;
124 static int exit_on_error = 0;
125 static int using_stdin = 0;
126 static int64_t video_size = 0;
127 static int64_t audio_size = 0;
128 static int64_t extra_size = 0;
129 static int nb_frames_dup = 0;
130 static int nb_frames_drop = 0;
131 static int input_sync;
133 static float dts_delta_threshold = 10;
135 static int print_stats = 1;
137 static uint8_t *audio_buf;
138 static uint8_t *audio_out;
139 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
141 static void *samples;
143 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
145 typedef struct InputStream {
148 int discard; /* true if stream data should be discarded */
149 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
152 int64_t start; /* time when read started */
153 int64_t next_pts; /* synthetic pts for cases where pkt.pts
155 int64_t pts; /* current pts */
156 PtsCorrectionContext pts_ctx;
158 int is_start; /* is 1 at the start and after a discontinuity */
159 int showed_multi_packet_warning;
163 typedef struct InputFile {
164 AVFormatContext *ctx;
165 int eof_reached; /* true if eof reached */
166 int ist_index; /* index of first stream in ist_table */
167 int buffer_size; /* current total buffer size */
169 int nb_streams; /* number of stream that avconv is aware of; may be different
170 from ctx.nb_streams if new streams appear during av_read_frame() */
174 typedef struct OutputStream {
175 int file_index; /* file index */
176 int index; /* stream index in the output file */
177 int source_index; /* InputStream index */
178 AVStream *st; /* stream in the output file */
179 int encoding_needed; /* true if encoding needed for this stream */
181 /* input pts and corresponding output pts
183 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
184 struct InputStream *sync_ist; /* input stream to sync against */
185 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
186 AVBitStreamFilterContext *bitstream_filters;
192 AVFrame pict_tmp; /* temporary image for resampling */
193 struct SwsContext *img_resample_ctx; /* for image resampling */
196 int resample_pix_fmt;
197 AVRational frame_rate;
201 float frame_aspect_ratio;
203 /* forced key frames */
204 int64_t *forced_kf_pts;
210 ReSampleContext *resample; /* for audio resampling */
211 int resample_sample_fmt;
212 int resample_channels;
213 int resample_sample_rate;
215 AVAudioConvert *reformat_ctx;
216 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
220 AVFilterContext *output_video_filter;
221 AVFilterContext *input_video_filter;
222 AVFilterBufferRef *picref;
224 AVFilterGraph *graph;
229 int is_past_recording_time;
234 typedef struct OutputFile {
235 AVFormatContext *ctx;
237 int ost_index; /* index of the first stream in output_streams */
238 int64_t recording_time; /* desired length of the resulting file in microseconds */
239 int64_t start_time; /* start time in microseconds */
240 uint64_t limit_filesize;
243 static InputStream *input_streams = NULL;
244 static int nb_input_streams = 0;
245 static InputFile *input_files = NULL;
246 static int nb_input_files = 0;
248 static OutputStream *output_streams = NULL;
249 static int nb_output_streams = 0;
250 static OutputFile *output_files = NULL;
251 static int nb_output_files = 0;
253 typedef struct OptionsContext {
254 /* input/output options */
258 SpecifierOpt *codec_names;
260 SpecifierOpt *audio_channels;
261 int nb_audio_channels;
262 SpecifierOpt *audio_sample_rate;
263 int nb_audio_sample_rate;
264 SpecifierOpt *frame_rates;
266 SpecifierOpt *frame_sizes;
268 SpecifierOpt *frame_pix_fmts;
269 int nb_frame_pix_fmts;
272 int64_t input_ts_offset;
275 SpecifierOpt *ts_scale;
279 StreamMap *stream_maps;
281 /* first item specifies output metadata, second is input */
282 MetadataMap (*meta_data_maps)[2];
283 int nb_meta_data_maps;
284 int metadata_global_manual;
285 int metadata_streams_manual;
286 int metadata_chapters_manual;
288 int chapters_input_file;
290 int64_t recording_time;
291 uint64_t limit_filesize;
297 int subtitle_disable;
300 /* indexed by output file stream index */
304 SpecifierOpt *metadata;
306 SpecifierOpt *max_frames;
308 SpecifierOpt *bitstream_filters;
309 int nb_bitstream_filters;
310 SpecifierOpt *codec_tags;
312 SpecifierOpt *sample_fmts;
314 SpecifierOpt *qscale;
316 SpecifierOpt *forced_key_frames;
317 int nb_forced_key_frames;
318 SpecifierOpt *force_fps;
320 SpecifierOpt *frame_aspect_ratios;
321 int nb_frame_aspect_ratios;
322 SpecifierOpt *rc_overrides;
324 SpecifierOpt *intra_matrices;
325 int nb_intra_matrices;
326 SpecifierOpt *inter_matrices;
327 int nb_inter_matrices;
328 SpecifierOpt *top_field_first;
329 int nb_top_field_first;
330 SpecifierOpt *presets;
333 SpecifierOpt *filters;
338 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
341 for (i = 0; i < o->nb_ ## name; i++) {\
342 char *spec = o->name[i].specifier;\
343 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
344 outvar = o->name[i].u.type;\
350 static void reset_options(OptionsContext *o)
352 const OptionDef *po = options;
354 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
356 void *dst = (uint8_t*)o + po->u.off;
358 if (po->flags & OPT_SPEC) {
359 SpecifierOpt **so = dst;
360 int i, *count = (int*)(so + 1);
361 for (i = 0; i < *count; i++) {
362 av_freep(&(*so)[i].specifier);
363 if (po->flags & OPT_STRING)
364 av_freep(&(*so)[i].u.str);
368 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
373 av_freep(&o->stream_maps);
374 av_freep(&o->meta_data_maps);
375 av_freep(&o->streamid_map);
377 memset(o, 0, sizeof(*o));
379 o->mux_max_delay = 0.7;
380 o->recording_time = INT64_MAX;
381 o->limit_filesize = UINT64_MAX;
382 o->chapters_input_file = INT_MAX;
390 static int configure_video_filters(InputStream *ist, OutputStream *ost)
392 AVFilterContext *last_filter, *filter;
393 /** filter graph containing all filters including input & output */
394 AVCodecContext *codec = ost->st->codec;
395 AVCodecContext *icodec = ist->st->codec;
396 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
397 AVRational sample_aspect_ratio;
401 ost->graph = avfilter_graph_alloc();
403 if (ist->st->sample_aspect_ratio.num){
404 sample_aspect_ratio = ist->st->sample_aspect_ratio;
406 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
408 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
409 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
410 sample_aspect_ratio.num, sample_aspect_ratio.den);
412 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
413 "src", args, NULL, ost->graph);
416 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
417 "out", NULL, &ffsink_ctx, ost->graph);
420 last_filter = ost->input_video_filter;
422 if (codec->width != icodec->width || codec->height != icodec->height) {
423 snprintf(args, 255, "%d:%d:flags=0x%X",
426 (unsigned)ost->sws_flags);
427 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
428 NULL, args, NULL, ost->graph)) < 0)
430 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
432 last_filter = filter;
435 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
436 ost->graph->scale_sws_opts = av_strdup(args);
439 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
440 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
442 outputs->name = av_strdup("in");
443 outputs->filter_ctx = last_filter;
444 outputs->pad_idx = 0;
445 outputs->next = NULL;
447 inputs->name = av_strdup("out");
448 inputs->filter_ctx = ost->output_video_filter;
452 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
454 av_freep(&ost->avfilter);
456 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
460 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
463 codec->width = ost->output_video_filter->inputs[0]->w;
464 codec->height = ost->output_video_filter->inputs[0]->h;
465 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
466 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
467 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
468 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
472 #endif /* CONFIG_AVFILTER */
474 static void term_exit(void)
476 av_log(NULL, AV_LOG_QUIET, "");
479 static volatile int received_sigterm = 0;
480 static volatile int received_nb_signals = 0;
483 sigterm_handler(int sig)
485 received_sigterm = sig;
486 received_nb_signals++;
490 static void term_init(void)
492 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
493 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
495 signal(SIGXCPU, sigterm_handler);
499 static int decode_interrupt_cb(void)
501 return received_nb_signals > 1;
504 void exit_program(int ret)
509 for(i=0;i<nb_output_files;i++) {
510 AVFormatContext *s = output_files[i].ctx;
511 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
513 avformat_free_context(s);
514 av_dict_free(&output_files[i].opts);
516 for(i=0;i<nb_input_files;i++) {
517 av_close_input_file(input_files[i].ctx);
519 for (i = 0; i < nb_input_streams; i++)
520 av_dict_free(&input_streams[i].opts);
524 av_free(vstats_filename);
526 av_freep(&input_streams);
527 av_freep(&input_files);
528 av_freep(&output_streams);
529 av_freep(&output_files);
534 allocated_audio_buf_size= allocated_audio_out_size= 0;
541 if (received_sigterm) {
542 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
543 (int) received_sigterm);
547 exit(ret); /* not all OS-es handle main() return value */
550 static void assert_avoptions(AVDictionary *m)
552 AVDictionaryEntry *t;
553 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
554 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
559 static void assert_codec_experimental(AVCodecContext *c, int encoder)
561 const char *codec_string = encoder ? "encoder" : "decoder";
563 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
564 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
565 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
566 "results.\nAdd '-strict experimental' if you want to use it.\n",
567 codec_string, c->codec->name);
568 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
569 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
570 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
571 codec_string, codec->name);
576 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
578 if(codec && codec->sample_fmts){
579 const enum AVSampleFormat *p= codec->sample_fmts;
581 if(*p == st->codec->sample_fmt)
585 av_log(NULL, AV_LOG_WARNING,
586 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
587 av_get_sample_fmt_name(st->codec->sample_fmt),
589 av_get_sample_fmt_name(codec->sample_fmts[0]));
590 st->codec->sample_fmt = codec->sample_fmts[0];
596 * Update the requested input sample format based on the output sample format.
597 * This is currently only used to request float output from decoders which
598 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
599 * Ideally this will be removed in the future when decoders do not do format
600 * conversion and only output in their native format.
602 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
605 /* if sample formats match or a decoder sample format has already been
606 requested, just return */
607 if (enc->sample_fmt == dec->sample_fmt ||
608 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
611 /* if decoder supports more than one output format */
612 if (dec_codec && dec_codec->sample_fmts &&
613 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
614 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
615 const enum AVSampleFormat *p;
616 int min_dec = -1, min_inc = -1;
618 /* find a matching sample format in the encoder */
619 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
620 if (*p == enc->sample_fmt) {
621 dec->request_sample_fmt = *p;
623 } else if (*p > enc->sample_fmt) {
624 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
626 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
629 /* if none match, provide the one that matches quality closest */
630 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
631 enc->sample_fmt - min_dec;
635 static void choose_sample_rate(AVStream *st, AVCodec *codec)
637 if(codec && codec->supported_samplerates){
638 const int *p= codec->supported_samplerates;
640 int best_dist=INT_MAX;
642 int dist= abs(st->codec->sample_rate - *p);
643 if(dist < best_dist){
649 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
651 st->codec->sample_rate= best;
655 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
657 if(codec && codec->pix_fmts){
658 const enum PixelFormat *p= codec->pix_fmts;
659 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
660 if(st->codec->codec_id==CODEC_ID_MJPEG){
661 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
662 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
663 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};
667 if(*p == st->codec->pix_fmt)
671 if(st->codec->pix_fmt != PIX_FMT_NONE)
672 av_log(NULL, AV_LOG_WARNING,
673 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
674 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
676 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
677 st->codec->pix_fmt = codec->pix_fmts[0];
683 get_sync_ipts(const OutputStream *ost)
685 const InputStream *ist = ost->sync_ist;
686 OutputFile *of = &output_files[ost->file_index];
687 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
690 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
694 AVPacket new_pkt= *pkt;
695 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
696 &new_pkt.data, &new_pkt.size,
697 pkt->data, pkt->size,
698 pkt->flags & AV_PKT_FLAG_KEY);
701 new_pkt.destruct= av_destruct_packet;
703 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
704 bsfc->filter->name, pkt->stream_index,
705 avctx->codec ? avctx->codec->name : "copy");
715 ret= av_interleaved_write_frame(s, pkt);
717 print_error("av_interleaved_write_frame()", ret);
722 static void do_audio_out(AVFormatContext *s,
725 unsigned char *buf, int size)
728 int64_t audio_out_size, audio_buf_size;
729 int64_t allocated_for_size= size;
731 int size_out, frame_bytes, ret, resample_changed;
732 AVCodecContext *enc= ost->st->codec;
733 AVCodecContext *dec= ist->st->codec;
734 int osize = av_get_bytes_per_sample(enc->sample_fmt);
735 int isize = av_get_bytes_per_sample(dec->sample_fmt);
736 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
739 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
740 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
741 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
742 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
743 audio_buf_size*= osize*enc->channels;
745 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
746 if(coded_bps > 8*osize)
747 audio_out_size= audio_out_size * coded_bps / (8*osize);
748 audio_out_size += FF_MIN_BUFFER_SIZE;
750 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
751 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
755 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
756 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
757 if (!audio_buf || !audio_out){
758 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
762 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
763 ost->audio_resample = 1;
765 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
766 ost->resample_channels != dec->channels ||
767 ost->resample_sample_rate != dec->sample_rate;
769 if ((ost->audio_resample && !ost->resample) || resample_changed) {
770 if (resample_changed) {
771 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",
772 ist->file_index, ist->st->index,
773 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
774 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
775 ost->resample_sample_fmt = dec->sample_fmt;
776 ost->resample_channels = dec->channels;
777 ost->resample_sample_rate = dec->sample_rate;
779 audio_resample_close(ost->resample);
781 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
782 if (audio_sync_method <= 1 &&
783 ost->resample_sample_fmt == enc->sample_fmt &&
784 ost->resample_channels == enc->channels &&
785 ost->resample_sample_rate == enc->sample_rate) {
786 ost->resample = NULL;
787 ost->audio_resample = 0;
788 } else if (ost->audio_resample) {
789 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
790 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
791 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
792 enc->sample_rate, dec->sample_rate,
793 enc->sample_fmt, dec->sample_fmt,
795 if (!ost->resample) {
796 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
797 dec->channels, dec->sample_rate,
798 enc->channels, enc->sample_rate);
804 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
805 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
806 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
807 if (ost->reformat_ctx)
808 av_audio_convert_free(ost->reformat_ctx);
809 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
810 dec->sample_fmt, 1, NULL, 0);
811 if (!ost->reformat_ctx) {
812 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
813 av_get_sample_fmt_name(dec->sample_fmt),
814 av_get_sample_fmt_name(enc->sample_fmt));
817 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
820 if(audio_sync_method){
821 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
822 - av_fifo_size(ost->fifo)/(enc->channels * 2);
823 double idelta= delta*dec->sample_rate / enc->sample_rate;
824 int byte_delta= ((int)idelta)*2*dec->channels;
826 //FIXME resample delay
827 if(fabs(delta) > 50){
828 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
830 byte_delta= FFMAX(byte_delta, -size);
833 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
838 static uint8_t *input_tmp= NULL;
839 input_tmp= av_realloc(input_tmp, byte_delta + size);
841 if(byte_delta > allocated_for_size - size){
842 allocated_for_size= byte_delta + (int64_t)size;
847 memset(input_tmp, 0, byte_delta);
848 memcpy(input_tmp + byte_delta, buf, size);
851 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
853 }else if(audio_sync_method>1){
854 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
855 av_assert0(ost->audio_resample);
856 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
857 delta, comp, enc->sample_rate);
858 // 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));
859 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
863 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
864 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
866 if (ost->audio_resample) {
868 size_out = audio_resample(ost->resample,
869 (short *)buftmp, (short *)buf,
870 size / (dec->channels * isize));
871 size_out = size_out * enc->channels * osize;
877 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
878 const void *ibuf[6]= {buftmp};
879 void *obuf[6]= {audio_buf};
880 int istride[6]= {isize};
881 int ostride[6]= {osize};
882 int len= size_out/istride[0];
883 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
884 printf("av_audio_convert() failed\n");
890 size_out = len*osize;
893 /* now encode as many frames as possible */
894 if (enc->frame_size > 1) {
895 /* output resampled raw samples */
896 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
897 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
900 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
902 frame_bytes = enc->frame_size * osize * enc->channels;
904 while (av_fifo_size(ost->fifo) >= frame_bytes) {
906 av_init_packet(&pkt);
908 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
910 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
912 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
915 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
919 pkt.stream_index= ost->index;
922 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
923 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
924 pkt.flags |= AV_PKT_FLAG_KEY;
925 write_frame(s, &pkt, enc, ost->bitstream_filters);
927 ost->sync_opts += enc->frame_size;
931 av_init_packet(&pkt);
933 ost->sync_opts += size_out / (osize * enc->channels);
935 /* output a pcm frame */
936 /* determine the size of the coded buffer */
939 size_out = size_out*coded_bps/8;
941 if(size_out > audio_out_size){
942 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
946 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
947 ret = avcodec_encode_audio(enc, audio_out, size_out,
950 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
954 pkt.stream_index= ost->index;
957 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
958 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
959 pkt.flags |= AV_PKT_FLAG_KEY;
960 write_frame(s, &pkt, enc, ost->bitstream_filters);
964 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
968 AVPicture picture_tmp;
971 dec = ist->st->codec;
973 /* deinterlace : must be done before any resize */
974 if (do_deinterlace) {
977 /* create temporary picture */
978 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
979 buf = av_malloc(size);
983 picture2 = &picture_tmp;
984 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
986 if(avpicture_deinterlace(picture2, picture,
987 dec->pix_fmt, dec->width, dec->height) < 0) {
988 /* if error, do not deinterlace */
989 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
998 if (picture != picture2)
999 *picture = *picture2;
1003 static void do_subtitle_out(AVFormatContext *s,
1009 static uint8_t *subtitle_out = NULL;
1010 int subtitle_out_max_size = 1024 * 1024;
1011 int subtitle_out_size, nb, i;
1012 AVCodecContext *enc;
1015 if (pts == AV_NOPTS_VALUE) {
1016 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1022 enc = ost->st->codec;
1024 if (!subtitle_out) {
1025 subtitle_out = av_malloc(subtitle_out_max_size);
1028 /* Note: DVB subtitle need one packet to draw them and one other
1029 packet to clear them */
1030 /* XXX: signal it in the codec context ? */
1031 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1036 for(i = 0; i < nb; i++) {
1037 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1038 // start_display_time is required to be 0
1039 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1040 sub->end_display_time -= sub->start_display_time;
1041 sub->start_display_time = 0;
1042 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1043 subtitle_out_max_size, sub);
1044 if (subtitle_out_size < 0) {
1045 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1049 av_init_packet(&pkt);
1050 pkt.stream_index = ost->index;
1051 pkt.data = subtitle_out;
1052 pkt.size = subtitle_out_size;
1053 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1054 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1055 /* XXX: the pts correction is handled here. Maybe handling
1056 it in the codec would be better */
1058 pkt.pts += 90 * sub->start_display_time;
1060 pkt.pts += 90 * sub->end_display_time;
1062 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1066 static int bit_buffer_size= 1024*256;
1067 static uint8_t *bit_buffer= NULL;
1069 static void do_video_resample(OutputStream *ost,
1071 AVFrame *in_picture,
1072 AVFrame **out_picture)
1074 int resample_changed = 0;
1075 AVCodecContext *dec = ist->st->codec;
1076 *out_picture = in_picture;
1078 resample_changed = ost->resample_width != dec->width ||
1079 ost->resample_height != dec->height ||
1080 ost->resample_pix_fmt != dec->pix_fmt;
1082 if (resample_changed) {
1083 av_log(NULL, AV_LOG_INFO,
1084 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1085 ist->file_index, ist->st->index,
1086 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1087 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1088 if(!ost->video_resample)
1089 ost->video_resample = 1;
1092 #if !CONFIG_AVFILTER
1093 if (ost->video_resample) {
1094 *out_picture = &ost->pict_tmp;
1095 if (resample_changed) {
1096 /* initialize a new scaler context */
1097 sws_freeContext(ost->img_resample_ctx);
1098 ost->img_resample_ctx = sws_getContext(
1099 ist->st->codec->width,
1100 ist->st->codec->height,
1101 ist->st->codec->pix_fmt,
1102 ost->st->codec->width,
1103 ost->st->codec->height,
1104 ost->st->codec->pix_fmt,
1105 ost->sws_flags, NULL, NULL, NULL);
1106 if (ost->img_resample_ctx == NULL) {
1107 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1111 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1112 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1115 if (resample_changed) {
1116 avfilter_graph_free(&ost->graph);
1117 if (configure_video_filters(ist, ost)) {
1118 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1123 if (resample_changed) {
1124 ost->resample_width = dec->width;
1125 ost->resample_height = dec->height;
1126 ost->resample_pix_fmt = dec->pix_fmt;
1131 static void do_video_out(AVFormatContext *s,
1134 AVFrame *in_picture,
1135 int *frame_size, float quality)
1137 int nb_frames, i, ret, format_video_sync;
1138 AVFrame *final_picture;
1139 AVCodecContext *enc;
1142 enc = ost->st->codec;
1144 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1146 /* by default, we output a single frame */
1151 format_video_sync = video_sync_method;
1152 if (format_video_sync < 0)
1153 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1155 if (format_video_sync) {
1156 double vdelta = sync_ipts - ost->sync_opts;
1157 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1160 else if (format_video_sync == 2) {
1163 }else if(vdelta>0.6)
1164 ost->sync_opts= lrintf(sync_ipts);
1165 }else if (vdelta > 1.1)
1166 nb_frames = lrintf(vdelta);
1167 //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);
1168 if (nb_frames == 0){
1170 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1171 }else if (nb_frames > 1) {
1172 nb_frames_dup += nb_frames - 1;
1173 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1176 ost->sync_opts= lrintf(sync_ipts);
1178 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1182 do_video_resample(ost, ist, in_picture, &final_picture);
1184 /* duplicates frame if needed */
1185 for(i=0;i<nb_frames;i++) {
1187 av_init_packet(&pkt);
1188 pkt.stream_index= ost->index;
1190 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1191 /* raw pictures are written as AVPicture structure to
1192 avoid any copies. We support temporarily the older
1194 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1195 enc->coded_frame->top_field_first = in_picture->top_field_first;
1196 pkt.data= (uint8_t *)final_picture;
1197 pkt.size= sizeof(AVPicture);
1198 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1199 pkt.flags |= AV_PKT_FLAG_KEY;
1201 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1203 AVFrame big_picture;
1205 big_picture= *final_picture;
1206 /* better than nothing: use input picture interlaced
1208 big_picture.interlaced_frame = in_picture->interlaced_frame;
1209 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1210 if (ost->top_field_first == -1)
1211 big_picture.top_field_first = in_picture->top_field_first;
1213 big_picture.top_field_first = !!ost->top_field_first;
1216 /* handles same_quant here. This is not correct because it may
1217 not be a global option */
1218 big_picture.quality = quality;
1219 if (!enc->me_threshold)
1220 big_picture.pict_type = 0;
1221 // big_picture.pts = AV_NOPTS_VALUE;
1222 big_picture.pts= ost->sync_opts;
1223 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1224 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1225 if (ost->forced_kf_index < ost->forced_kf_count &&
1226 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1227 big_picture.pict_type = AV_PICTURE_TYPE_I;
1228 ost->forced_kf_index++;
1230 ret = avcodec_encode_video(enc,
1231 bit_buffer, bit_buffer_size,
1234 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1239 pkt.data= bit_buffer;
1241 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1242 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1243 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1244 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1245 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1247 if(enc->coded_frame->key_frame)
1248 pkt.flags |= AV_PKT_FLAG_KEY;
1249 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1252 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1253 // enc->frame_number-1, ret, enc->pict_type);
1254 /* if two pass, output log */
1255 if (ost->logfile && enc->stats_out) {
1256 fprintf(ost->logfile, "%s", enc->stats_out);
1261 ost->frame_number++;
1265 static double psnr(double d){
1266 return -10.0*log(d)/log(10.0);
1269 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1272 AVCodecContext *enc;
1274 double ti1, bitrate, avg_bitrate;
1276 /* this is executed just the first time do_video_stats is called */
1278 vstats_file = fopen(vstats_filename, "w");
1285 enc = ost->st->codec;
1286 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1287 frame_number = ost->frame_number;
1288 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1289 if (enc->flags&CODEC_FLAG_PSNR)
1290 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1292 fprintf(vstats_file,"f_size= %6d ", frame_size);
1293 /* compute pts value */
1294 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1298 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1299 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1300 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1301 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1302 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1306 static void print_report(OutputFile *output_files,
1307 OutputStream *ost_table, int nb_ostreams,
1308 int is_last_report, int64_t timer_start)
1312 AVFormatContext *oc;
1314 AVCodecContext *enc;
1315 int frame_number, vid, i;
1316 double bitrate, ti1, pts;
1317 static int64_t last_time = -1;
1318 static int qp_histogram[52];
1320 if (!print_stats && !is_last_report)
1323 if (!is_last_report) {
1325 /* display the report every 0.5 seconds */
1326 cur_time = av_gettime();
1327 if (last_time == -1) {
1328 last_time = cur_time;
1331 if ((cur_time - last_time) < 500000)
1333 last_time = cur_time;
1337 oc = output_files[0].ctx;
1339 total_size = avio_size(oc->pb);
1340 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1341 total_size= avio_tell(oc->pb);
1346 for(i=0;i<nb_ostreams;i++) {
1348 ost = &ost_table[i];
1349 enc = ost->st->codec;
1350 if (!ost->stream_copy && enc->coded_frame)
1351 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1352 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1353 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1355 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1356 float t = (av_gettime()-timer_start) / 1000000.0;
1358 frame_number = ost->frame_number;
1359 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1360 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1362 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1366 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1369 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1371 if (enc->flags&CODEC_FLAG_PSNR){
1373 double error, error_sum=0;
1374 double scale, scale_sum=0;
1375 char type[3]= {'Y','U','V'};
1376 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1379 error= enc->error[j];
1380 scale= enc->width*enc->height*255.0*255.0*frame_number;
1382 error= enc->coded_frame->error[j];
1383 scale= enc->width*enc->height*255.0*255.0;
1388 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1390 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1394 /* compute min output value */
1395 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1396 if ((pts < ti1) && (pts > 0))
1402 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1404 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1405 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1406 (double)total_size / 1024, ti1, bitrate);
1408 if (nb_frames_dup || nb_frames_drop)
1409 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1410 nb_frames_dup, nb_frames_drop);
1412 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1416 if (is_last_report) {
1417 int64_t raw= audio_size + video_size + extra_size;
1418 av_log(NULL, AV_LOG_INFO, "\n");
1419 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1423 100.0*(total_size - raw)/raw
1428 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1430 int fill_char = 0x00;
1431 if (sample_fmt == AV_SAMPLE_FMT_U8)
1433 memset(buf, fill_char, size);
1436 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1440 for (i = 0; i < nb_ostreams; i++) {
1441 OutputStream *ost = &ost_table[i];
1442 AVCodecContext *enc = ost->st->codec;
1443 AVFormatContext *os = output_files[ost->file_index].ctx;
1445 if (!ost->encoding_needed)
1448 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1450 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1456 av_init_packet(&pkt);
1457 pkt.stream_index= ost->index;
1459 switch (ost->st->codec->codec_type) {
1460 case AVMEDIA_TYPE_AUDIO:
1461 fifo_bytes = av_fifo_size(ost->fifo);
1463 /* encode any samples remaining in fifo */
1464 if (fifo_bytes > 0) {
1465 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1466 int fs_tmp = enc->frame_size;
1468 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1469 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1470 enc->frame_size = fifo_bytes / (osize * enc->channels);
1472 int frame_bytes = enc->frame_size*osize*enc->channels;
1473 if (allocated_audio_buf_size < frame_bytes)
1475 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1478 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1479 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1480 ost->st->time_base.num, enc->sample_rate);
1481 enc->frame_size = fs_tmp;
1484 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1487 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1491 pkt.flags |= AV_PKT_FLAG_KEY;
1493 case AVMEDIA_TYPE_VIDEO:
1494 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1496 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1500 if(enc->coded_frame && enc->coded_frame->key_frame)
1501 pkt.flags |= AV_PKT_FLAG_KEY;
1502 if (ost->logfile && enc->stats_out) {
1503 fprintf(ost->logfile, "%s", enc->stats_out);
1512 pkt.data = bit_buffer;
1514 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1515 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1516 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1521 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1522 static int output_packet(InputStream *ist, int ist_index,
1523 OutputStream *ost_table, int nb_ostreams,
1524 const AVPacket *pkt)
1526 AVFormatContext *os;
1530 void *buffer_to_free = NULL;
1531 static unsigned int samples_size= 0;
1532 AVSubtitle subtitle, *subtitle_to_free;
1533 int64_t pkt_pts = AV_NOPTS_VALUE;
1535 int frame_available;
1540 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1542 if(ist->next_pts == AV_NOPTS_VALUE)
1543 ist->next_pts= ist->pts;
1547 av_init_packet(&avpkt);
1555 if(pkt->dts != AV_NOPTS_VALUE)
1556 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1557 if(pkt->pts != AV_NOPTS_VALUE)
1558 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1560 //while we have more to decode or while the decoder did output something on EOF
1561 while (avpkt.size > 0 || (!pkt && got_output)) {
1562 uint8_t *data_buf, *decoded_data_buf;
1563 int data_size, decoded_data_size;
1564 AVFrame *decoded_frame, *filtered_frame;
1566 ist->pts= ist->next_pts;
1568 if(avpkt.size && avpkt.size != pkt->size)
1569 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1570 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1571 ist->showed_multi_packet_warning=1;
1573 /* decode the packet if needed */
1574 decoded_frame = filtered_frame = NULL;
1575 decoded_data_buf = NULL; /* fail safe */
1576 decoded_data_size= 0;
1577 data_buf = avpkt.data;
1578 data_size = avpkt.size;
1579 subtitle_to_free = NULL;
1580 if (ist->decoding_needed) {
1581 switch(ist->st->codec->codec_type) {
1582 case AVMEDIA_TYPE_AUDIO:{
1583 if(pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1584 samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1586 samples= av_malloc(samples_size);
1588 decoded_data_size= samples_size;
1589 /* XXX: could avoid copy if PCM 16 bits with same
1590 endianness as CPU */
1591 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1598 got_output = decoded_data_size > 0;
1599 /* Some bug in mpeg audio decoder gives */
1600 /* decoded_data_size < 0, it seems they are overflows */
1602 /* no audio frame */
1605 decoded_data_buf = (uint8_t *)samples;
1606 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1607 (ist->st->codec->sample_rate * ist->st->codec->channels);
1609 case AVMEDIA_TYPE_VIDEO:
1610 if (!(decoded_frame = avcodec_alloc_frame()))
1611 return AVERROR(ENOMEM);
1612 avpkt.pts = pkt_pts;
1613 avpkt.dts = ist->pts;
1614 pkt_pts = AV_NOPTS_VALUE;
1616 ret = avcodec_decode_video2(ist->st->codec,
1617 decoded_frame, &got_output, &avpkt);
1618 quality = same_quant ? decoded_frame->quality : 0;
1622 /* no picture yet */
1623 av_freep(&decoded_frame);
1624 goto discard_packet;
1626 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1627 decoded_frame->pkt_dts);
1628 if (ist->st->codec->time_base.num != 0) {
1629 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1630 ist->next_pts += ((int64_t)AV_TIME_BASE *
1631 ist->st->codec->time_base.num * ticks) /
1632 ist->st->codec->time_base.den;
1635 buffer_to_free = NULL;
1636 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1638 case AVMEDIA_TYPE_SUBTITLE:
1639 ret = avcodec_decode_subtitle2(ist->st->codec,
1640 &subtitle, &got_output, &avpkt);
1644 goto discard_packet;
1646 subtitle_to_free = &subtitle;
1653 switch(ist->st->codec->codec_type) {
1654 case AVMEDIA_TYPE_AUDIO:
1655 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1656 ist->st->codec->sample_rate;
1658 case AVMEDIA_TYPE_VIDEO:
1659 if (ist->st->codec->time_base.num != 0) {
1660 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1661 ist->next_pts += ((int64_t)AV_TIME_BASE *
1662 ist->st->codec->time_base.num * ticks) /
1663 ist->st->codec->time_base.den;
1670 // preprocess audio (volume)
1671 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1672 if (audio_volume != 256) {
1673 switch (ist->st->codec->sample_fmt) {
1674 case AV_SAMPLE_FMT_U8:
1676 uint8_t *volp = samples;
1677 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1678 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1679 *volp++ = av_clip_uint8(v);
1683 case AV_SAMPLE_FMT_S16:
1685 int16_t *volp = samples;
1686 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1687 int v = ((*volp) * audio_volume + 128) >> 8;
1688 *volp++ = av_clip_int16(v);
1692 case AV_SAMPLE_FMT_S32:
1694 int32_t *volp = samples;
1695 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1696 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1697 *volp++ = av_clipl_int32(v);
1701 case AV_SAMPLE_FMT_FLT:
1703 float *volp = samples;
1704 float scale = audio_volume / 256.f;
1705 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1710 case AV_SAMPLE_FMT_DBL:
1712 double *volp = samples;
1713 double scale = audio_volume / 256.;
1714 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1720 av_log(NULL, AV_LOG_FATAL,
1721 "Audio volume adjustment on sample format %s is not supported.\n",
1722 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1728 /* frame rate emulation */
1729 if (input_files[ist->file_index].rate_emu) {
1730 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1731 int64_t now = av_gettime() - ist->start;
1735 /* if output time reached then transcode raw format,
1736 encode packets and output them */
1737 for (i = 0; i < nb_ostreams; i++) {
1738 OutputFile *of = &output_files[ost_table[i].file_index];
1741 ost = &ost_table[i];
1742 if (ost->source_index != ist_index)
1745 if (of->start_time && ist->pts < of->start_time)
1748 if (of->recording_time != INT64_MAX &&
1749 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1750 (AVRational){1, 1000000}) >= 0) {
1751 ost->is_past_recording_time = 1;
1756 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1757 ost->input_video_filter) {
1759 if (ist->st->sample_aspect_ratio.num)
1760 sar = ist->st->sample_aspect_ratio;
1762 sar = ist->st->codec->sample_aspect_ratio;
1763 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, ist->pts, sar);
1764 if (!(filtered_frame = avcodec_alloc_frame())) {
1765 ret = AVERROR(ENOMEM);
1769 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1770 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1771 while (frame_available) {
1772 AVRational ist_pts_tb;
1773 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1774 get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
1776 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1778 filtered_frame = decoded_frame;
1780 os = output_files[ost->file_index].ctx;
1782 /* set the input output pts pairs */
1783 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1785 if (ost->encoding_needed) {
1786 av_assert0(ist->decoding_needed);
1787 switch(ost->st->codec->codec_type) {
1788 case AVMEDIA_TYPE_AUDIO:
1789 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1791 case AVMEDIA_TYPE_VIDEO:
1793 if (ost->picref->video && !ost->frame_aspect_ratio)
1794 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1796 do_video_out(os, ost, ist, filtered_frame, &frame_size,
1797 same_quant ? quality : ost->st->codec->global_quality);
1798 if (vstats_filename && frame_size)
1799 do_video_stats(os, ost, frame_size);
1801 case AVMEDIA_TYPE_SUBTITLE:
1802 do_subtitle_out(os, ost, ist, &subtitle,
1810 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1812 av_init_packet(&opkt);
1814 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1815 #if !CONFIG_AVFILTER
1821 /* no reencoding needed : output the packet directly */
1822 /* force the input stream PTS */
1824 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1825 audio_size += data_size;
1826 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1827 video_size += data_size;
1831 opkt.stream_index= ost->index;
1832 if(pkt->pts != AV_NOPTS_VALUE)
1833 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1835 opkt.pts= AV_NOPTS_VALUE;
1837 if (pkt->dts == AV_NOPTS_VALUE)
1838 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1840 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1841 opkt.dts -= ost_tb_start_time;
1843 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1844 opkt.flags= pkt->flags;
1846 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1847 if( ost->st->codec->codec_id != CODEC_ID_H264
1848 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1849 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1851 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1852 opkt.destruct= av_destruct_packet;
1854 opkt.data = data_buf;
1855 opkt.size = data_size;
1858 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1859 ost->st->codec->frame_number++;
1860 ost->frame_number++;
1861 av_free_packet(&opkt);
1865 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1866 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1868 avfilter_unref_buffer(ost->picref);
1870 av_freep(&filtered_frame);
1875 av_free(buffer_to_free);
1876 /* XXX: allocate the subtitles in the codec ? */
1877 if (subtitle_to_free) {
1878 avsubtitle_free(subtitle_to_free);
1879 subtitle_to_free = NULL;
1881 av_freep(&decoded_frame);
1890 static void print_sdp(OutputFile *output_files, int n)
1894 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1898 for (i = 0; i < n; i++)
1899 avc[i] = output_files[i].ctx;
1901 av_sdp_create(avc, n, sdp, sizeof(sdp));
1902 printf("SDP:\n%s\n", sdp);
1907 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1908 char *error, int error_len)
1911 InputStream *ist = &input_streams[ist_index];
1912 if (ist->decoding_needed) {
1913 AVCodec *codec = ist->dec;
1915 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1916 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1917 return AVERROR(EINVAL);
1920 /* update requested sample format for the decoder based on the
1921 corresponding encoder sample format */
1922 for (i = 0; i < nb_output_streams; i++) {
1923 OutputStream *ost = &output_streams[i];
1924 if (ost->source_index == ist_index) {
1925 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1930 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1931 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1932 ist->file_index, ist->st->index);
1933 return AVERROR(EINVAL);
1935 assert_codec_experimental(ist->st->codec, 0);
1936 assert_avoptions(ist->opts);
1939 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;
1940 ist->next_pts = AV_NOPTS_VALUE;
1941 init_pts_correction(&ist->pts_ctx);
1947 static int transcode_init(OutputFile *output_files,
1948 int nb_output_files,
1949 InputFile *input_files,
1952 int ret = 0, i, j, k;
1953 AVFormatContext *os;
1954 AVCodecContext *codec, *icodec;
1960 /* init framerate emulation */
1961 for (i = 0; i < nb_input_files; i++) {
1962 InputFile *ifile = &input_files[i];
1963 if (ifile->rate_emu)
1964 for (j = 0; j < ifile->nb_streams; j++)
1965 input_streams[j + ifile->ist_index].start = av_gettime();
1968 /* output stream init */
1969 for(i=0;i<nb_output_files;i++) {
1970 os = output_files[i].ctx;
1971 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1972 av_dump_format(os, i, os->filename, 1);
1973 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
1974 return AVERROR(EINVAL);
1978 /* for each output stream, we compute the right encoding parameters */
1979 for (i = 0; i < nb_output_streams; i++) {
1980 ost = &output_streams[i];
1981 os = output_files[ost->file_index].ctx;
1982 ist = &input_streams[ost->source_index];
1984 codec = ost->st->codec;
1985 icodec = ist->st->codec;
1987 ost->st->disposition = ist->st->disposition;
1988 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1989 codec->chroma_sample_location = icodec->chroma_sample_location;
1991 if (ost->stream_copy) {
1992 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1994 if (extra_size > INT_MAX) {
1995 return AVERROR(EINVAL);
1998 /* if stream_copy is selected, no need to decode or encode */
1999 codec->codec_id = icodec->codec_id;
2000 codec->codec_type = icodec->codec_type;
2002 if(!codec->codec_tag){
2003 if( !os->oformat->codec_tag
2004 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2005 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2006 codec->codec_tag = icodec->codec_tag;
2009 codec->bit_rate = icodec->bit_rate;
2010 codec->rc_max_rate = icodec->rc_max_rate;
2011 codec->rc_buffer_size = icodec->rc_buffer_size;
2012 codec->extradata= av_mallocz(extra_size);
2013 if (!codec->extradata) {
2014 return AVERROR(ENOMEM);
2016 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2017 codec->extradata_size= icodec->extradata_size;
2018 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){
2019 codec->time_base = icodec->time_base;
2020 codec->time_base.num *= icodec->ticks_per_frame;
2021 av_reduce(&codec->time_base.num, &codec->time_base.den,
2022 codec->time_base.num, codec->time_base.den, INT_MAX);
2024 codec->time_base = ist->st->time_base;
2025 switch(codec->codec_type) {
2026 case AVMEDIA_TYPE_AUDIO:
2027 if(audio_volume != 256) {
2028 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2031 codec->channel_layout = icodec->channel_layout;
2032 codec->sample_rate = icodec->sample_rate;
2033 codec->channels = icodec->channels;
2034 codec->frame_size = icodec->frame_size;
2035 codec->audio_service_type = icodec->audio_service_type;
2036 codec->block_align= icodec->block_align;
2037 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2038 codec->block_align= 0;
2039 if(codec->codec_id == CODEC_ID_AC3)
2040 codec->block_align= 0;
2042 case AVMEDIA_TYPE_VIDEO:
2043 codec->pix_fmt = icodec->pix_fmt;
2044 codec->width = icodec->width;
2045 codec->height = icodec->height;
2046 codec->has_b_frames = icodec->has_b_frames;
2047 if (!codec->sample_aspect_ratio.num) {
2048 codec->sample_aspect_ratio =
2049 ost->st->sample_aspect_ratio =
2050 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2051 ist->st->codec->sample_aspect_ratio.num ?
2052 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2055 case AVMEDIA_TYPE_SUBTITLE:
2056 codec->width = icodec->width;
2057 codec->height = icodec->height;
2059 case AVMEDIA_TYPE_DATA:
2060 case AVMEDIA_TYPE_ATTACHMENT:
2067 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2068 ist->decoding_needed = 1;
2069 ost->encoding_needed = 1;
2070 switch(codec->codec_type) {
2071 case AVMEDIA_TYPE_AUDIO:
2072 ost->fifo= av_fifo_alloc(1024);
2074 return AVERROR(ENOMEM);
2076 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2077 if (!codec->sample_rate)
2078 codec->sample_rate = icodec->sample_rate;
2079 choose_sample_rate(ost->st, ost->enc);
2080 codec->time_base = (AVRational){1, codec->sample_rate};
2081 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2082 codec->sample_fmt = icodec->sample_fmt;
2083 choose_sample_fmt(ost->st, ost->enc);
2084 if (!codec->channels)
2085 codec->channels = icodec->channels;
2086 codec->channel_layout = icodec->channel_layout;
2087 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2088 codec->channel_layout = 0;
2089 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2090 icodec->request_channels = codec->channels;
2091 ost->resample_sample_fmt = icodec->sample_fmt;
2092 ost->resample_sample_rate = icodec->sample_rate;
2093 ost->resample_channels = icodec->channels;
2095 case AVMEDIA_TYPE_VIDEO:
2096 if (codec->pix_fmt == PIX_FMT_NONE)
2097 codec->pix_fmt = icodec->pix_fmt;
2098 choose_pixel_fmt(ost->st, ost->enc);
2100 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2101 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2105 if (!codec->width || !codec->height) {
2106 codec->width = icodec->width;
2107 codec->height = icodec->height;
2110 ost->video_resample = codec->width != icodec->width ||
2111 codec->height != icodec->height ||
2112 codec->pix_fmt != icodec->pix_fmt;
2113 if (ost->video_resample) {
2114 #if !CONFIG_AVFILTER
2115 avcodec_get_frame_defaults(&ost->pict_tmp);
2116 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2117 codec->width, codec->height)) {
2118 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2121 ost->img_resample_ctx = sws_getContext(
2128 ost->sws_flags, NULL, NULL, NULL);
2129 if (ost->img_resample_ctx == NULL) {
2130 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2134 codec->bits_per_raw_sample= 0;
2137 ost->resample_height = icodec->height;
2138 ost->resample_width = icodec->width;
2139 ost->resample_pix_fmt= icodec->pix_fmt;
2141 if (!ost->frame_rate.num)
2142 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2143 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2144 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2145 ost->frame_rate = ost->enc->supported_framerates[idx];
2147 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2150 if (configure_video_filters(ist, ost)) {
2151 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2156 case AVMEDIA_TYPE_SUBTITLE:
2163 if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2164 char logfilename[1024];
2167 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2168 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2170 if (codec->flags & CODEC_FLAG_PASS1) {
2171 f = fopen(logfilename, "wb");
2173 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2174 logfilename, strerror(errno));
2180 size_t logbuffer_size;
2181 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2182 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2186 codec->stats_in = logbuffer;
2190 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2191 int size= codec->width * codec->height;
2192 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2197 bit_buffer = av_malloc(bit_buffer_size);
2199 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2201 return AVERROR(ENOMEM);
2204 /* open each encoder */
2205 for (i = 0; i < nb_output_streams; i++) {
2206 ost = &output_streams[i];
2207 if (ost->encoding_needed) {
2208 AVCodec *codec = ost->enc;
2209 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2211 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2212 ost->st->codec->codec_id, ost->file_index, ost->index);
2213 ret = AVERROR(EINVAL);
2216 if (dec->subtitle_header) {
2217 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2218 if (!ost->st->codec->subtitle_header) {
2219 ret = AVERROR(ENOMEM);
2222 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2223 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2225 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2226 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2227 ost->file_index, ost->index);
2228 ret = AVERROR(EINVAL);
2231 assert_codec_experimental(ost->st->codec, 1);
2232 assert_avoptions(ost->opts);
2233 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2234 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2235 "It takes bits/s as argument, not kbits/s\n");
2236 extra_size += ost->st->codec->extradata_size;
2238 if (ost->st->codec->me_threshold)
2239 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2243 /* init input streams */
2244 for (i = 0; i < nb_input_streams; i++)
2245 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2248 /* discard unused programs */
2249 for (i = 0; i < nb_input_files; i++) {
2250 InputFile *ifile = &input_files[i];
2251 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2252 AVProgram *p = ifile->ctx->programs[j];
2253 int discard = AVDISCARD_ALL;
2255 for (k = 0; k < p->nb_stream_indexes; k++)
2256 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2257 discard = AVDISCARD_DEFAULT;
2260 p->discard = discard;
2264 /* open files and write file headers */
2265 for (i = 0; i < nb_output_files; i++) {
2266 os = output_files[i].ctx;
2267 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2268 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2269 ret = AVERROR(EINVAL);
2272 assert_avoptions(output_files[i].opts);
2273 if (strcmp(os->oformat->name, "rtp")) {
2279 /* dump the file output parameters - cannot be done before in case
2281 for(i=0;i<nb_output_files;i++) {
2282 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2285 /* dump the stream mapping */
2286 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2287 for (i = 0; i < nb_output_streams; i++) {
2288 ost = &output_streams[i];
2289 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d -> #%d.%d",
2290 input_streams[ost->source_index].file_index,
2291 input_streams[ost->source_index].st->index,
2294 if (ost->sync_ist != &input_streams[ost->source_index])
2295 av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
2296 ost->sync_ist->file_index,
2297 ost->sync_ist->st->index);
2298 if (ost->stream_copy)
2299 av_log(NULL, AV_LOG_INFO, " (copy)");
2301 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2302 input_streams[ost->source_index].dec->name : "?",
2303 ost->enc ? ost->enc->name : "?");
2304 av_log(NULL, AV_LOG_INFO, "\n");
2308 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2313 print_sdp(output_files, nb_output_files);
2320 * The following code is the main loop of the file converter
2322 static int transcode(OutputFile *output_files,
2323 int nb_output_files,
2324 InputFile *input_files,
2328 AVFormatContext *is, *os;
2332 int no_packet_count=0;
2333 int64_t timer_start;
2335 if (!(no_packet = av_mallocz(nb_input_files)))
2338 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2342 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2345 timer_start = av_gettime();
2347 for(; received_sigterm == 0;) {
2348 int file_index, ist_index;
2353 ipts_min = INT64_MAX;
2356 /* select the stream that we must read now by looking at the
2357 smallest output pts */
2359 for (i = 0; i < nb_output_streams; i++) {
2363 ost = &output_streams[i];
2364 of = &output_files[ost->file_index];
2365 os = output_files[ost->file_index].ctx;
2366 ist = &input_streams[ost->source_index];
2367 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2368 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2370 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2372 if (!input_files[ist->file_index].eof_reached){
2373 if(ipts < ipts_min) {
2375 if(input_sync ) file_index = ist->file_index;
2377 if(opts < opts_min) {
2379 if(!input_sync) file_index = ist->file_index;
2382 if (ost->frame_number >= ost->max_frames) {
2384 for (j = 0; j < of->ctx->nb_streams; j++)
2385 output_streams[of->ost_index + j].is_past_recording_time = 1;
2389 /* if none, if is finished */
2390 if (file_index < 0) {
2391 if(no_packet_count){
2393 memset(no_packet, 0, nb_input_files);
2400 /* read a frame from it and output it in the fifo */
2401 is = input_files[file_index].ctx;
2402 ret= av_read_frame(is, &pkt);
2403 if(ret == AVERROR(EAGAIN)){
2404 no_packet[file_index]=1;
2409 input_files[file_index].eof_reached = 1;
2417 memset(no_packet, 0, nb_input_files);
2420 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2421 is->streams[pkt.stream_index]);
2423 /* the following test is needed in case new streams appear
2424 dynamically in stream : we ignore them */
2425 if (pkt.stream_index >= input_files[file_index].nb_streams)
2426 goto discard_packet;
2427 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2428 ist = &input_streams[ist_index];
2430 goto discard_packet;
2432 if (pkt.dts != AV_NOPTS_VALUE)
2433 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2434 if (pkt.pts != AV_NOPTS_VALUE)
2435 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2437 if(pkt.pts != AV_NOPTS_VALUE)
2438 pkt.pts *= ist->ts_scale;
2439 if(pkt.dts != AV_NOPTS_VALUE)
2440 pkt.dts *= ist->ts_scale;
2442 // 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);
2443 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2444 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2445 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2446 int64_t delta= pkt_dts - ist->next_pts;
2447 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2448 input_files[ist->file_index].ts_offset -= delta;
2449 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2450 delta, input_files[ist->file_index].ts_offset);
2451 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2452 if(pkt.pts != AV_NOPTS_VALUE)
2453 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2457 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2458 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2460 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d.%d\n",
2461 ist->file_index, ist->st->index);
2464 av_free_packet(&pkt);
2469 av_free_packet(&pkt);
2471 /* dump report by using the output first video and audio streams */
2472 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2475 /* at the end of stream, we must flush the decoder buffers */
2476 for (i = 0; i < nb_input_streams; i++) {
2477 ist = &input_streams[i];
2478 if (ist->decoding_needed) {
2479 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2482 flush_encoders(output_streams, nb_output_streams);
2486 /* write the trailer if needed and close file */
2487 for(i=0;i<nb_output_files;i++) {
2488 os = output_files[i].ctx;
2489 av_write_trailer(os);
2492 /* dump report by using the first video and audio streams */
2493 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2495 /* close each encoder */
2496 for (i = 0; i < nb_output_streams; i++) {
2497 ost = &output_streams[i];
2498 if (ost->encoding_needed) {
2499 av_freep(&ost->st->codec->stats_in);
2500 avcodec_close(ost->st->codec);
2503 avfilter_graph_free(&ost->graph);
2507 /* close each decoder */
2508 for (i = 0; i < nb_input_streams; i++) {
2509 ist = &input_streams[i];
2510 if (ist->decoding_needed) {
2511 avcodec_close(ist->st->codec);
2519 av_freep(&bit_buffer);
2520 av_freep(&no_packet);
2522 if (output_streams) {
2523 for (i = 0; i < nb_output_streams; i++) {
2524 ost = &output_streams[i];
2526 if (ost->stream_copy)
2527 av_freep(&ost->st->codec->extradata);
2529 fclose(ost->logfile);
2530 ost->logfile = NULL;
2532 av_fifo_free(ost->fifo); /* works even if fifo is not
2533 initialized but set to zero */
2534 av_freep(&ost->st->codec->subtitle_header);
2535 av_free(ost->pict_tmp.data[0]);
2536 av_free(ost->forced_kf_pts);
2537 if (ost->video_resample)
2538 sws_freeContext(ost->img_resample_ctx);
2540 audio_resample_close(ost->resample);
2541 if (ost->reformat_ctx)
2542 av_audio_convert_free(ost->reformat_ctx);
2543 av_dict_free(&ost->opts);
2550 static double parse_frame_aspect_ratio(const char *arg)
2557 p = strchr(arg, ':');
2559 x = strtol(arg, &end, 10);
2561 y = strtol(end+1, &end, 10);
2563 ar = (double)x / (double)y;
2565 ar = strtod(arg, NULL);
2568 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2574 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2576 return parse_option(o, "codec:a", arg, options);
2579 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2581 return parse_option(o, "codec:v", arg, options);
2584 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2586 return parse_option(o, "codec:s", arg, options);
2589 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2591 return parse_option(o, "codec:d", arg, options);
2594 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2596 StreamMap *m = NULL;
2597 int i, negative = 0, file_idx;
2598 int sync_file_idx = -1, sync_stream_idx;
2606 map = av_strdup(arg);
2608 /* parse sync stream first, just pick first matching stream */
2609 if (sync = strchr(map, ',')) {
2611 sync_file_idx = strtol(sync + 1, &sync, 0);
2612 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2613 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2618 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2619 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2620 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2621 sync_stream_idx = i;
2624 if (i == input_files[sync_file_idx].nb_streams) {
2625 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2626 "match any streams.\n", arg);
2632 file_idx = strtol(map, &p, 0);
2633 if (file_idx >= nb_input_files || file_idx < 0) {
2634 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2638 /* disable some already defined maps */
2639 for (i = 0; i < o->nb_stream_maps; i++) {
2640 m = &o->stream_maps[i];
2641 if (file_idx == m->file_index &&
2642 check_stream_specifier(input_files[m->file_index].ctx,
2643 input_files[m->file_index].ctx->streams[m->stream_index],
2644 *p == ':' ? p + 1 : p) > 0)
2648 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2649 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2650 *p == ':' ? p + 1 : p) <= 0)
2652 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2653 &o->nb_stream_maps, o->nb_stream_maps + 1);
2654 m = &o->stream_maps[o->nb_stream_maps - 1];
2656 m->file_index = file_idx;
2657 m->stream_index = i;
2659 if (sync_file_idx >= 0) {
2660 m->sync_file_index = sync_file_idx;
2661 m->sync_stream_index = sync_stream_idx;
2663 m->sync_file_index = file_idx;
2664 m->sync_stream_index = i;
2669 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2677 static void parse_meta_type(char *arg, char *type, int *index)
2687 if (*(++arg) == ':')
2688 *index = strtol(++arg, NULL, 0);
2691 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2698 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2700 MetadataMap *m, *m1;
2703 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2704 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2706 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2707 m->file = strtol(arg, &p, 0);
2708 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2710 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2711 if (p = strchr(opt, ':'))
2712 parse_meta_type(p + 1, &m1->type, &m1->index);
2716 if (m->type == 'g' || m1->type == 'g')
2717 o->metadata_global_manual = 1;
2718 if (m->type == 's' || m1->type == 's')
2719 o->metadata_streams_manual = 1;
2720 if (m->type == 'c' || m1->type == 'c')
2721 o->metadata_chapters_manual = 1;
2726 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2728 const char *codec_string = encoder ? "encoder" : "decoder";
2732 avcodec_find_encoder_by_name(name) :
2733 avcodec_find_decoder_by_name(name);
2735 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2738 if(codec->type != type) {
2739 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2745 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
2747 char *codec_name = NULL;
2749 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2751 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
2752 st->codec->codec_id = codec->id;
2755 return avcodec_find_decoder(st->codec->codec_id);
2759 * Add all the streams from the given input file to the global
2760 * list of input streams.
2762 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2764 int i, rfps, rfps_base;
2766 for (i = 0; i < ic->nb_streams; i++) {
2767 AVStream *st = ic->streams[i];
2768 AVCodecContext *dec = st->codec;
2772 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2773 ist = &input_streams[nb_input_streams - 1];
2775 ist->file_index = nb_input_files;
2777 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2779 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2780 ist->ts_scale = scale;
2782 ist->dec = choose_decoder(o, ic, st);
2784 switch (dec->codec_type) {
2785 case AVMEDIA_TYPE_AUDIO:
2786 if (o->audio_disable)
2787 st->discard= AVDISCARD_ALL;
2789 case AVMEDIA_TYPE_VIDEO:
2790 rfps = ic->streams[i]->r_frame_rate.num;
2791 rfps_base = ic->streams[i]->r_frame_rate.den;
2793 dec->flags |= CODEC_FLAG_EMU_EDGE;
2794 dec->height >>= dec->lowres;
2795 dec->width >>= dec->lowres;
2798 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2800 av_log(NULL, AV_LOG_INFO,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2801 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2802 (float)rfps / rfps_base, rfps, rfps_base);
2805 if (o->video_disable)
2806 st->discard= AVDISCARD_ALL;
2807 else if(video_discard)
2808 st->discard= video_discard;
2810 case AVMEDIA_TYPE_DATA:
2812 case AVMEDIA_TYPE_SUBTITLE:
2813 if (o->subtitle_disable)
2814 st->discard = AVDISCARD_ALL;
2816 case AVMEDIA_TYPE_ATTACHMENT:
2817 case AVMEDIA_TYPE_UNKNOWN:
2825 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2827 AVFormatContext *ic;
2828 AVInputFormat *file_iformat = NULL;
2832 AVDictionary **opts;
2833 int orig_nb_streams; // number of streams before avformat_find_stream_info
2836 if (!(file_iformat = av_find_input_format(o->format))) {
2837 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
2842 if (!strcmp(filename, "-"))
2845 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2846 !strcmp(filename, "/dev/stdin");
2848 /* get default parameters from command line */
2849 ic = avformat_alloc_context();
2851 print_error(filename, AVERROR(ENOMEM));
2854 if (o->nb_audio_sample_rate) {
2855 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2856 av_dict_set(&format_opts, "sample_rate", buf, 0);
2858 if (o->nb_audio_channels) {
2859 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2860 av_dict_set(&format_opts, "channels", buf, 0);
2862 if (o->nb_frame_rates) {
2863 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2865 if (o->nb_frame_sizes) {
2866 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2868 if (o->nb_frame_pix_fmts)
2869 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
2871 ic->flags |= AVFMT_FLAG_NONBLOCK;
2873 /* open the input file with generic libav function */
2874 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2876 print_error(filename, err);
2879 assert_avoptions(format_opts);
2881 /* apply forced codec ids */
2882 for (i = 0; i < ic->nb_streams; i++)
2883 choose_decoder(o, ic, ic->streams[i]);
2885 /* Set AVCodecContext options for avformat_find_stream_info */
2886 opts = setup_find_stream_info_opts(ic, codec_opts);
2887 orig_nb_streams = ic->nb_streams;
2889 /* If not enough info to get the stream parameters, we decode the
2890 first frames to get it. (used in mpeg case for example) */
2891 ret = avformat_find_stream_info(ic, opts);
2893 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
2894 av_close_input_file(ic);
2898 timestamp = o->start_time;
2899 /* add the stream start time */
2900 if (ic->start_time != AV_NOPTS_VALUE)
2901 timestamp += ic->start_time;
2903 /* if seeking requested, we execute it */
2904 if (o->start_time != 0) {
2905 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2907 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2908 filename, (double)timestamp / AV_TIME_BASE);
2912 /* update the current parameters so that they match the one of the input stream */
2913 add_input_streams(o, ic);
2915 /* dump the file content */
2916 av_dump_format(ic, nb_input_files, filename, 0);
2918 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
2919 input_files[nb_input_files - 1].ctx = ic;
2920 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
2921 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
2922 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
2923 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
2925 for (i = 0; i < orig_nb_streams; i++)
2926 av_dict_free(&opts[i]);
2933 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2934 AVCodecContext *avctx)
2940 for (p = kf; *p; p++)
2943 ost->forced_kf_count = n;
2944 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2945 if (!ost->forced_kf_pts) {
2946 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2949 for (i = 0; i < n; i++) {
2950 p = i ? strchr(p, ',') + 1 : kf;
2951 t = parse_time_or_die("force_key_frames", p, 1);
2952 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2956 static uint8_t *get_line(AVIOContext *s)
2962 if (avio_open_dyn_buf(&line) < 0) {
2963 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
2967 while ((c = avio_r8(s)) && c != '\n')
2970 avio_close_dyn_buf(line, &buf);
2975 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
2978 char filename[1000];
2979 const char *base[3] = { getenv("AVCONV_DATADIR"),
2984 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
2988 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
2989 i != 1 ? "" : "/.avconv", codec_name, preset_name);
2990 ret = avio_open(s, filename, AVIO_FLAG_READ);
2993 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
2994 i != 1 ? "" : "/.avconv", preset_name);
2995 ret = avio_open(s, filename, AVIO_FLAG_READ);
3001 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3003 char *codec_name = NULL;
3005 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3007 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3008 NULL, ost->st->codec->codec_type);
3009 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3010 } else if (!strcmp(codec_name, "copy"))
3011 ost->stream_copy = 1;
3013 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3014 ost->st->codec->codec_id = ost->enc->id;
3018 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3021 AVStream *st = avformat_new_stream(oc, NULL);
3022 int idx = oc->nb_streams - 1, ret = 0;
3023 int64_t max_frames = INT64_MAX;
3024 char *bsf = NULL, *next, *codec_tag = NULL;
3025 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3027 char *buf = NULL, *arg = NULL, *preset = NULL;
3028 AVIOContext *s = NULL;
3031 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3035 if (oc->nb_streams - 1 < o->nb_streamid_map)
3036 st->id = o->streamid_map[oc->nb_streams - 1];
3038 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3039 nb_output_streams + 1);
3040 ost = &output_streams[nb_output_streams - 1];
3041 ost->file_index = nb_output_files;
3044 st->codec->codec_type = type;
3045 choose_encoder(o, oc, ost);
3047 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3050 avcodec_get_context_defaults3(st->codec, ost->enc);
3051 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3053 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3054 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3057 if (!buf[0] || buf[0] == '#') {
3061 if (!(arg = strchr(buf, '='))) {
3062 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3066 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3068 } while (!s->eof_reached);
3072 av_log(NULL, AV_LOG_FATAL,
3073 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3074 preset, ost->file_index, ost->index);
3078 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3079 ost->max_frames = max_frames;
3081 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3083 if (next = strchr(bsf, ','))
3085 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3086 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3090 bsfc_prev->next = bsfc;
3092 ost->bitstream_filters = bsfc;
3098 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3100 uint32_t tag = strtol(codec_tag, &next, 0);
3102 tag = AV_RL32(codec_tag);
3103 st->codec->codec_tag = tag;
3106 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3107 if (qscale >= 0 || same_quant) {
3108 st->codec->flags |= CODEC_FLAG_QSCALE;
3109 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3112 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3113 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3115 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3119 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3122 const char *p = str;
3129 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3136 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3140 AVCodecContext *video_enc;
3142 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3144 video_enc = st->codec;
3146 if (!ost->stream_copy) {
3147 const char *p = NULL;
3148 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3149 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3150 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3151 int i, force_fps = 0, top_field_first = -1;
3153 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3154 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3155 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3159 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3160 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3161 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3165 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3166 if (frame_aspect_ratio)
3167 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3169 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3170 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3171 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3174 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3176 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3178 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3179 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3182 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3184 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3186 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3187 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3190 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3193 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3196 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3198 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3201 video_enc->rc_override=
3202 av_realloc(video_enc->rc_override,
3203 sizeof(RcOverride)*(i+1));
3204 video_enc->rc_override[i].start_frame= start;
3205 video_enc->rc_override[i].end_frame = end;
3207 video_enc->rc_override[i].qscale= q;
3208 video_enc->rc_override[i].quality_factor= 1.0;
3211 video_enc->rc_override[i].qscale= 0;
3212 video_enc->rc_override[i].quality_factor= -q/100.0;
3217 video_enc->rc_override_count=i;
3218 if (!video_enc->rc_initial_buffer_occupancy)
3219 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3220 video_enc->intra_dc_precision= intra_dc_precision - 8;
3225 video_enc->flags |= CODEC_FLAG_PASS1;
3227 video_enc->flags |= CODEC_FLAG_PASS2;
3231 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3232 if (forced_key_frames)
3233 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3235 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3236 ost->force_fps = force_fps;
3238 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3239 ost->top_field_first = top_field_first;
3242 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3244 ost->avfilter = av_strdup(filters);
3251 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3255 AVCodecContext *audio_enc;
3257 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3260 audio_enc = st->codec;
3261 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3263 if (!ost->stream_copy) {
3264 char *sample_fmt = NULL;
3266 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3268 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3270 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3271 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3275 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3281 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3285 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3286 if (!ost->stream_copy) {
3287 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3294 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3296 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3297 ost->stream_copy = 1;
3301 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3305 AVCodecContext *subtitle_enc;
3307 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3309 subtitle_enc = st->codec;
3311 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3316 /* arg format is "output-stream-index:streamid-value". */
3317 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3323 av_strlcpy(idx_str, arg, sizeof(idx_str));
3324 p = strchr(idx_str, ':');
3326 av_log(NULL, AV_LOG_FATAL,
3327 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3332 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3333 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3334 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3338 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3340 AVFormatContext *is = ifile->ctx;
3341 AVFormatContext *os = ofile->ctx;
3344 for (i = 0; i < is->nb_chapters; i++) {
3345 AVChapter *in_ch = is->chapters[i], *out_ch;
3346 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3347 AV_TIME_BASE_Q, in_ch->time_base);
3348 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3349 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3352 if (in_ch->end < ts_off)
3354 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3357 out_ch = av_mallocz(sizeof(AVChapter));
3359 return AVERROR(ENOMEM);
3361 out_ch->id = in_ch->id;
3362 out_ch->time_base = in_ch->time_base;
3363 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3364 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3367 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3370 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3372 return AVERROR(ENOMEM);
3373 os->chapters[os->nb_chapters - 1] = out_ch;
3378 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3381 AVFormatContext *ic = NULL;
3383 err = avformat_open_input(&ic, filename, NULL, NULL);
3386 /* copy stream format */
3387 for(i=0;i<ic->nb_streams;i++) {
3392 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3393 ost = new_output_stream(o, s, codec->type);
3396 // FIXME: a more elegant solution is needed
3397 memcpy(st, ic->streams[i], sizeof(AVStream));
3399 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3401 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3402 choose_sample_fmt(st, codec);
3403 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3404 choose_pixel_fmt(st, codec);
3407 av_close_input_file(ic);
3411 static void opt_output_file(void *optctx, const char *filename)
3413 OptionsContext *o = optctx;
3414 AVFormatContext *oc;
3416 AVOutputFormat *file_oformat;
3420 if (!strcmp(filename, "-"))
3423 oc = avformat_alloc_context();
3425 print_error(filename, AVERROR(ENOMEM));
3430 file_oformat = av_guess_format(o->format, NULL, NULL);
3431 if (!file_oformat) {
3432 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3436 file_oformat = av_guess_format(NULL, filename, NULL);
3437 if (!file_oformat) {
3438 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3444 oc->oformat = file_oformat;
3445 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3447 if (!strcmp(file_oformat->name, "ffm") &&
3448 av_strstart(filename, "http:", NULL)) {
3449 /* special case for files sent to avserver: we get the stream
3450 parameters from avserver */
3451 int err = read_avserver_streams(o, oc, filename);
3453 print_error(filename, err);
3456 } else if (!o->nb_stream_maps) {
3457 /* pick the "best" stream of each type */
3458 #define NEW_STREAM(type, index)\
3460 ost = new_ ## type ## _stream(o, oc);\
3461 ost->source_index = index;\
3462 ost->sync_ist = &input_streams[index];\
3463 input_streams[index].discard = 0;\
3466 /* video: highest resolution */
3467 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3468 int area = 0, idx = -1;
3469 for (i = 0; i < nb_input_streams; i++) {
3470 ist = &input_streams[i];
3471 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3472 ist->st->codec->width * ist->st->codec->height > area) {
3473 area = ist->st->codec->width * ist->st->codec->height;
3477 NEW_STREAM(video, idx);
3480 /* audio: most channels */
3481 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3482 int channels = 0, idx = -1;
3483 for (i = 0; i < nb_input_streams; i++) {
3484 ist = &input_streams[i];
3485 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3486 ist->st->codec->channels > channels) {
3487 channels = ist->st->codec->channels;
3491 NEW_STREAM(audio, idx);
3494 /* subtitles: pick first */
3495 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3496 for (i = 0; i < nb_input_streams; i++)
3497 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3498 NEW_STREAM(subtitle, i);
3502 /* do something with data? */
3504 for (i = 0; i < o->nb_stream_maps; i++) {
3505 StreamMap *map = &o->stream_maps[i];
3510 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3511 switch (ist->st->codec->codec_type) {
3512 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3513 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3514 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3515 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3516 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3518 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3519 map->file_index, map->stream_index);
3523 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3524 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3525 map->sync_stream_index];
3530 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3531 output_files[nb_output_files - 1].ctx = oc;
3532 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3533 output_files[nb_output_files - 1].recording_time = o->recording_time;
3534 output_files[nb_output_files - 1].start_time = o->start_time;
3535 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3536 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3538 /* check filename in case of an image number is expected */
3539 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3540 if (!av_filename_number_test(oc->filename)) {
3541 print_error(oc->filename, AVERROR(EINVAL));
3546 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3547 /* test if it already exists to avoid loosing precious files */
3548 if (!file_overwrite &&
3549 (strchr(filename, ':') == NULL ||
3550 filename[1] == ':' ||
3551 av_strstart(filename, "file:", NULL))) {
3552 if (avio_check(filename, 0) == 0) {
3554 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3556 if (!read_yesno()) {
3557 fprintf(stderr, "Not overwriting - exiting\n");
3562 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3569 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3570 print_error(filename, err);
3575 if (o->mux_preload) {
3577 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3578 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3580 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3581 oc->flags |= AVFMT_FLAG_NONBLOCK;
3584 if (o->chapters_input_file >= nb_input_files) {
3585 if (o->chapters_input_file == INT_MAX) {
3586 /* copy chapters from the first input file that has them*/
3587 o->chapters_input_file = -1;
3588 for (i = 0; i < nb_input_files; i++)
3589 if (input_files[i].ctx->nb_chapters) {
3590 o->chapters_input_file = i;
3594 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3595 o->chapters_input_file);
3599 if (o->chapters_input_file >= 0)
3600 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3601 !o->metadata_chapters_manual);
3604 for (i = 0; i < o->nb_meta_data_maps; i++) {
3605 AVFormatContext *files[2];
3606 AVDictionary **meta[2];
3609 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3610 if ((index) < 0 || (index) >= (nb_elems)) {\
3611 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3616 int in_file_index = o->meta_data_maps[i][1].file;
3617 if (in_file_index < 0)
3619 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3622 files[1] = input_files[in_file_index].ctx;
3624 for (j = 0; j < 2; j++) {
3625 MetadataMap *map = &o->meta_data_maps[i][j];
3627 switch (map->type) {
3629 meta[j] = &files[j]->metadata;
3632 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3633 meta[j] = &files[j]->streams[map->index]->metadata;
3636 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3637 meta[j] = &files[j]->chapters[map->index]->metadata;
3640 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3641 meta[j] = &files[j]->programs[map->index]->metadata;
3646 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3649 /* copy global metadata by default */
3650 if (!o->metadata_global_manual && nb_input_files)
3651 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3652 AV_DICT_DONT_OVERWRITE);
3653 if (!o->metadata_streams_manual)
3654 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3655 InputStream *ist = &input_streams[output_streams[i].source_index];
3656 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3659 /* process manually set metadata */
3660 for (i = 0; i < o->nb_metadata; i++) {
3665 val = strchr(o->metadata[i].u.str, '=');
3667 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3668 o->metadata[i].u.str);
3673 parse_meta_type(o->metadata[i].specifier, &type, &index);
3679 if (index < 0 || index >= oc->nb_streams) {
3680 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3683 m = &oc->streams[index]->metadata;
3686 if (index < 0 || index >= oc->nb_chapters) {
3687 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3690 m = &oc->chapters[index]->metadata;
3693 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3697 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3703 /* same option as mencoder */
3704 static int opt_pass(const char *opt, const char *arg)
3706 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3710 static int64_t getutime(void)
3713 struct rusage rusage;
3715 getrusage(RUSAGE_SELF, &rusage);
3716 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3717 #elif HAVE_GETPROCESSTIMES
3719 FILETIME c, e, k, u;
3720 proc = GetCurrentProcess();
3721 GetProcessTimes(proc, &c, &e, &k, &u);
3722 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3724 return av_gettime();
3728 static int64_t getmaxrss(void)
3730 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3731 struct rusage rusage;
3732 getrusage(RUSAGE_SELF, &rusage);
3733 return (int64_t)rusage.ru_maxrss * 1024;
3734 #elif HAVE_GETPROCESSMEMORYINFO
3736 PROCESS_MEMORY_COUNTERS memcounters;
3737 proc = GetCurrentProcess();
3738 memcounters.cb = sizeof(memcounters);
3739 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3740 return memcounters.PeakPagefileUsage;
3746 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3748 return parse_option(o, "q:a", arg, options);
3751 static void show_usage(void)
3753 printf("Hyper fast Audio and Video encoder\n");
3754 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3758 static void show_help(void)
3760 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
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 show_help_children(avcodec_get_class(), flags);
3788 show_help_children(avformat_get_class(), flags);
3789 show_help_children(sws_get_class(), flags);
3792 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3794 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3795 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3797 if(!strncmp(arg, "pal-", 4)) {
3800 } else if(!strncmp(arg, "ntsc-", 5)) {
3803 } else if(!strncmp(arg, "film-", 5)) {
3807 /* Try to determine PAL/NTSC by peeking in the input files */
3808 if(nb_input_files) {
3810 for (j = 0; j < nb_input_files; j++) {
3811 for (i = 0; i < input_files[j].nb_streams; i++) {
3812 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3813 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3815 fr = c->time_base.den * 1000 / c->time_base.num;
3819 } else if((fr == 29970) || (fr == 23976)) {
3828 if (norm != UNKNOWN)
3829 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3832 if(norm == UNKNOWN) {
3833 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3834 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3835 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3839 if(!strcmp(arg, "vcd")) {
3840 opt_video_codec(o, "c:v", "mpeg1video");
3841 opt_audio_codec(o, "c:a", "mp2");
3842 parse_option(o, "f", "vcd", options);
3844 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3845 parse_option(o, "r", frame_rates[norm], options);
3846 opt_default("g", norm == PAL ? "15" : "18");
3848 opt_default("b", "1150000");
3849 opt_default("maxrate", "1150000");
3850 opt_default("minrate", "1150000");
3851 opt_default("bufsize", "327680"); // 40*1024*8;
3853 opt_default("b:a", "224000");
3854 parse_option(o, "ar", "44100", options);
3855 parse_option(o, "ac", "2", options);
3857 opt_default("packetsize", "2324");
3858 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3860 /* We have to offset the PTS, so that it is consistent with the SCR.
3861 SCR starts at 36000, but the first two packs contain only padding
3862 and the first pack from the other stream, respectively, may also have
3863 been written before.
3864 So the real data starts at SCR 36000+3*1200. */
3865 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3866 } else if(!strcmp(arg, "svcd")) {
3868 opt_video_codec(o, "c:v", "mpeg2video");
3869 opt_audio_codec(o, "c:a", "mp2");
3870 parse_option(o, "f", "svcd", options);
3872 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3873 parse_option(o, "r", frame_rates[norm], options);
3874 opt_default("g", norm == PAL ? "15" : "18");
3876 opt_default("b", "2040000");
3877 opt_default("maxrate", "2516000");
3878 opt_default("minrate", "0"); //1145000;
3879 opt_default("bufsize", "1835008"); //224*1024*8;
3880 opt_default("flags", "+scan_offset");
3883 opt_default("b:a", "224000");
3884 parse_option(o, "ar", "44100", options);
3886 opt_default("packetsize", "2324");
3888 } else if(!strcmp(arg, "dvd")) {
3890 opt_video_codec(o, "c:v", "mpeg2video");
3891 opt_audio_codec(o, "c:a", "ac3");
3892 parse_option(o, "f", "dvd", options);
3894 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3895 parse_option(o, "r", frame_rates[norm], options);
3896 opt_default("g", norm == PAL ? "15" : "18");
3898 opt_default("b", "6000000");
3899 opt_default("maxrate", "9000000");
3900 opt_default("minrate", "0"); //1500000;
3901 opt_default("bufsize", "1835008"); //224*1024*8;
3903 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3904 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3906 opt_default("b:a", "448000");
3907 parse_option(o, "ar", "48000", options);
3909 } else if(!strncmp(arg, "dv", 2)) {
3911 parse_option(o, "f", "dv", options);
3913 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3914 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3915 norm == PAL ? "yuv420p" : "yuv411p", options);
3916 parse_option(o, "r", frame_rates[norm], options);
3918 parse_option(o, "ar", "48000", options);
3919 parse_option(o, "ac", "2", options);
3922 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
3923 return AVERROR(EINVAL);
3928 static int opt_vstats_file(const char *opt, const char *arg)
3930 av_free (vstats_filename);
3931 vstats_filename=av_strdup (arg);
3935 static int opt_vstats(const char *opt, const char *arg)
3938 time_t today2 = time(NULL);
3939 struct tm *today = localtime(&today2);
3941 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3943 return opt_vstats_file(opt, filename);
3946 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
3948 return parse_option(o, "frames:v", arg, options);
3951 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
3953 return parse_option(o, "frames:a", arg, options);
3956 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
3958 return parse_option(o, "frames:d", arg, options);
3961 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
3963 return parse_option(o, "tag:v", arg, options);
3966 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
3968 return parse_option(o, "tag:a", arg, options);
3971 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
3973 return parse_option(o, "tag:s", arg, options);
3976 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
3978 return parse_option(o, "filter:v", arg, options);
3981 #define OFFSET(x) offsetof(OptionsContext, x)
3982 static const OptionDef options[] = {
3984 #include "cmdutils_common_opts.h"
3985 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
3986 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
3987 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3988 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3989 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3990 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
3991 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
3992 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
3993 "outfile[,metadata]:infile[,metadata]" },
3994 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
3995 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3996 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
3997 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
3998 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
3999 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4000 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4001 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4002 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4003 "add timings for benchmarking" },
4004 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4005 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4006 "dump each input packet" },
4007 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4008 "when dumping packets, also dump the payload" },
4009 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4010 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4011 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4012 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4013 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4014 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4015 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4016 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4017 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4018 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4019 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4020 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4021 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4022 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4023 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4025 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4027 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4030 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4031 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4032 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4033 { "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" },
4034 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4035 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4036 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4037 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4038 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4039 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4040 "use same quantizer as source (implies VBR)" },
4041 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4042 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4043 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4044 "deinterlace pictures" },
4045 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4046 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4048 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4050 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4051 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4052 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4053 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4054 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4055 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4056 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4057 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4058 { "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" },
4061 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4062 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4063 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4064 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4065 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4066 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4067 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4068 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4069 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4071 /* subtitle options */
4072 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4073 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4074 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4077 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4080 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4081 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4083 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4085 /* data codec support */
4086 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4088 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4092 int main(int argc, char **argv)
4094 OptionsContext o = { 0 };
4099 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4100 parse_loglevel(argc, argv, options);
4102 avcodec_register_all();
4104 avdevice_register_all();
4107 avfilter_register_all();
4111 avio_set_interrupt_cb(decode_interrupt_cb);
4116 parse_options(&o, argc, argv, options, opt_output_file);
4118 if(nb_output_files <= 0 && nb_input_files == 0) {
4120 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4124 /* file converter / grab */
4125 if (nb_output_files <= 0) {
4126 fprintf(stderr, "At least one output file must be specified\n");
4130 if (nb_input_files == 0) {
4131 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4136 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4138 ti = getutime() - ti;
4140 int maxrss = getmaxrss() / 1024;
4141 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);