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;
233 typedef struct OutputFile {
234 AVFormatContext *ctx;
236 int ost_index; /* index of the first stream in output_streams */
237 int64_t recording_time; /* desired length of the resulting file in microseconds */
238 int64_t start_time; /* start time in microseconds */
239 uint64_t limit_filesize;
242 static InputStream *input_streams = NULL;
243 static int nb_input_streams = 0;
244 static InputFile *input_files = NULL;
245 static int nb_input_files = 0;
247 static OutputStream *output_streams = NULL;
248 static int nb_output_streams = 0;
249 static OutputFile *output_files = NULL;
250 static int nb_output_files = 0;
252 typedef struct OptionsContext {
253 /* input/output options */
257 SpecifierOpt *codec_names;
259 SpecifierOpt *audio_channels;
260 int nb_audio_channels;
261 SpecifierOpt *audio_sample_rate;
262 int nb_audio_sample_rate;
263 SpecifierOpt *frame_rates;
265 SpecifierOpt *frame_sizes;
267 SpecifierOpt *frame_pix_fmts;
268 int nb_frame_pix_fmts;
271 int64_t input_ts_offset;
274 SpecifierOpt *ts_scale;
278 StreamMap *stream_maps;
280 /* first item specifies output metadata, second is input */
281 MetadataMap (*meta_data_maps)[2];
282 int nb_meta_data_maps;
283 int metadata_global_manual;
284 int metadata_streams_manual;
285 int metadata_chapters_manual;
287 int chapters_input_file;
289 int64_t recording_time;
290 uint64_t limit_filesize;
296 int subtitle_disable;
299 /* indexed by output file stream index */
303 SpecifierOpt *metadata;
305 SpecifierOpt *max_frames;
307 SpecifierOpt *bitstream_filters;
308 int nb_bitstream_filters;
309 SpecifierOpt *codec_tags;
311 SpecifierOpt *sample_fmts;
313 SpecifierOpt *qscale;
315 SpecifierOpt *forced_key_frames;
316 int nb_forced_key_frames;
317 SpecifierOpt *force_fps;
319 SpecifierOpt *frame_aspect_ratios;
320 int nb_frame_aspect_ratios;
321 SpecifierOpt *rc_overrides;
323 SpecifierOpt *intra_matrices;
324 int nb_intra_matrices;
325 SpecifierOpt *inter_matrices;
326 int nb_inter_matrices;
327 SpecifierOpt *top_field_first;
328 int nb_top_field_first;
330 SpecifierOpt *filters;
335 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
338 for (i = 0; i < o->nb_ ## name; i++) {\
339 char *spec = o->name[i].specifier;\
340 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
341 outvar = o->name[i].u.type;\
347 static void reset_options(OptionsContext *o)
349 const OptionDef *po = options;
351 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
353 void *dst = (uint8_t*)o + po->u.off;
355 if (po->flags & OPT_SPEC) {
356 SpecifierOpt **so = dst;
357 int i, *count = (int*)(so + 1);
358 for (i = 0; i < *count; i++) {
359 av_freep(&(*so)[i].specifier);
360 if (po->flags & OPT_STRING)
361 av_freep(&(*so)[i].u.str);
365 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
370 av_freep(&o->stream_maps);
371 av_freep(&o->meta_data_maps);
372 av_freep(&o->streamid_map);
374 memset(o, 0, sizeof(*o));
376 o->mux_preload = 0.5;
377 o->mux_max_delay = 0.7;
378 o->recording_time = INT64_MAX;
379 o->limit_filesize = UINT64_MAX;
380 o->chapters_input_file = INT_MAX;
388 static int configure_video_filters(InputStream *ist, OutputStream *ost)
390 AVFilterContext *last_filter, *filter;
391 /** filter graph containing all filters including input & output */
392 AVCodecContext *codec = ost->st->codec;
393 AVCodecContext *icodec = ist->st->codec;
394 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
395 AVRational sample_aspect_ratio;
399 ost->graph = avfilter_graph_alloc();
401 if (ist->st->sample_aspect_ratio.num){
402 sample_aspect_ratio = ist->st->sample_aspect_ratio;
404 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
406 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
407 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
408 sample_aspect_ratio.num, sample_aspect_ratio.den);
410 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
411 "src", args, NULL, ost->graph);
414 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
415 "out", NULL, &ffsink_ctx, ost->graph);
418 last_filter = ost->input_video_filter;
420 if (codec->width != icodec->width || codec->height != icodec->height) {
421 snprintf(args, 255, "%d:%d:flags=0x%X",
425 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
426 NULL, args, NULL, ost->graph)) < 0)
428 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
430 last_filter = filter;
433 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
434 ost->graph->scale_sws_opts = av_strdup(args);
437 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
438 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
440 outputs->name = av_strdup("in");
441 outputs->filter_ctx = last_filter;
442 outputs->pad_idx = 0;
443 outputs->next = NULL;
445 inputs->name = av_strdup("out");
446 inputs->filter_ctx = ost->output_video_filter;
450 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
452 av_freep(&ost->avfilter);
454 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
458 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
461 codec->width = ost->output_video_filter->inputs[0]->w;
462 codec->height = ost->output_video_filter->inputs[0]->h;
463 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
464 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
465 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
466 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
470 #endif /* CONFIG_AVFILTER */
472 static void term_exit(void)
474 av_log(NULL, AV_LOG_QUIET, "");
477 static volatile int received_sigterm = 0;
478 static volatile int received_nb_signals = 0;
481 sigterm_handler(int sig)
483 received_sigterm = sig;
484 received_nb_signals++;
488 static void term_init(void)
490 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
491 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
493 signal(SIGXCPU, sigterm_handler);
497 static int decode_interrupt_cb(void)
499 return received_nb_signals > 1;
502 void exit_program(int ret)
507 for(i=0;i<nb_output_files;i++) {
508 AVFormatContext *s = output_files[i].ctx;
509 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
511 avformat_free_context(s);
512 av_dict_free(&output_files[i].opts);
514 for(i=0;i<nb_input_files;i++) {
515 av_close_input_file(input_files[i].ctx);
517 for (i = 0; i < nb_input_streams; i++)
518 av_dict_free(&input_streams[i].opts);
522 av_free(vstats_filename);
524 av_freep(&input_streams);
525 av_freep(&input_files);
526 av_freep(&output_streams);
527 av_freep(&output_files);
532 allocated_audio_buf_size= allocated_audio_out_size= 0;
539 if (received_sigterm) {
540 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
541 (int) received_sigterm);
545 exit(ret); /* not all OS-es handle main() return value */
548 static void assert_avoptions(AVDictionary *m)
550 AVDictionaryEntry *t;
551 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
552 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
557 static void assert_codec_experimental(AVCodecContext *c, int encoder)
559 const char *codec_string = encoder ? "encoder" : "decoder";
561 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
562 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
563 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
564 "results.\nAdd '-strict experimental' if you want to use it.\n",
565 codec_string, c->codec->name);
566 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
567 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
568 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
569 codec_string, codec->name);
574 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
576 if(codec && codec->sample_fmts){
577 const enum AVSampleFormat *p= codec->sample_fmts;
579 if(*p == st->codec->sample_fmt)
583 av_log(NULL, AV_LOG_WARNING,
584 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
585 av_get_sample_fmt_name(st->codec->sample_fmt),
587 av_get_sample_fmt_name(codec->sample_fmts[0]));
588 st->codec->sample_fmt = codec->sample_fmts[0];
594 * Update the requested input sample format based on the output sample format.
595 * This is currently only used to request float output from decoders which
596 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
597 * Ideally this will be removed in the future when decoders do not do format
598 * conversion and only output in their native format.
600 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
603 /* if sample formats match or a decoder sample format has already been
604 requested, just return */
605 if (enc->sample_fmt == dec->sample_fmt ||
606 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
609 /* if decoder supports more than one output format */
610 if (dec_codec && dec_codec->sample_fmts &&
611 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
612 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
613 const enum AVSampleFormat *p;
614 int min_dec = -1, min_inc = -1;
616 /* find a matching sample format in the encoder */
617 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
618 if (*p == enc->sample_fmt) {
619 dec->request_sample_fmt = *p;
621 } else if (*p > enc->sample_fmt) {
622 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
624 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
627 /* if none match, provide the one that matches quality closest */
628 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
629 enc->sample_fmt - min_dec;
633 static void choose_sample_rate(AVStream *st, AVCodec *codec)
635 if(codec && codec->supported_samplerates){
636 const int *p= codec->supported_samplerates;
638 int best_dist=INT_MAX;
640 int dist= abs(st->codec->sample_rate - *p);
641 if(dist < best_dist){
647 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
649 st->codec->sample_rate= best;
653 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
655 if(codec && codec->pix_fmts){
656 const enum PixelFormat *p= codec->pix_fmts;
657 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
658 if(st->codec->codec_id==CODEC_ID_MJPEG){
659 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
660 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
661 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};
665 if(*p == st->codec->pix_fmt)
669 if(st->codec->pix_fmt != PIX_FMT_NONE)
670 av_log(NULL, AV_LOG_WARNING,
671 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
672 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
674 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
675 st->codec->pix_fmt = codec->pix_fmts[0];
681 get_sync_ipts(const OutputStream *ost)
683 const InputStream *ist = ost->sync_ist;
684 OutputFile *of = &output_files[ost->file_index];
685 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
688 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
692 AVPacket new_pkt= *pkt;
693 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
694 &new_pkt.data, &new_pkt.size,
695 pkt->data, pkt->size,
696 pkt->flags & AV_PKT_FLAG_KEY);
699 new_pkt.destruct= av_destruct_packet;
701 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
702 bsfc->filter->name, pkt->stream_index,
703 avctx->codec ? avctx->codec->name : "copy");
713 ret= av_interleaved_write_frame(s, pkt);
715 print_error("av_interleaved_write_frame()", ret);
720 static void do_audio_out(AVFormatContext *s,
723 unsigned char *buf, int size)
726 int64_t audio_out_size, audio_buf_size;
727 int64_t allocated_for_size= size;
729 int size_out, frame_bytes, ret, resample_changed;
730 AVCodecContext *enc= ost->st->codec;
731 AVCodecContext *dec= ist->st->codec;
732 int osize = av_get_bytes_per_sample(enc->sample_fmt);
733 int isize = av_get_bytes_per_sample(dec->sample_fmt);
734 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
737 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
738 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
739 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
740 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
741 audio_buf_size*= osize*enc->channels;
743 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
744 if(coded_bps > 8*osize)
745 audio_out_size= audio_out_size * coded_bps / (8*osize);
746 audio_out_size += FF_MIN_BUFFER_SIZE;
748 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
749 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
753 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
754 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
755 if (!audio_buf || !audio_out){
756 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
760 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
761 ost->audio_resample = 1;
763 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
764 ost->resample_channels != dec->channels ||
765 ost->resample_sample_rate != dec->sample_rate;
767 if ((ost->audio_resample && !ost->resample) || resample_changed) {
768 if (resample_changed) {
769 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",
770 ist->file_index, ist->st->index,
771 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
772 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
773 ost->resample_sample_fmt = dec->sample_fmt;
774 ost->resample_channels = dec->channels;
775 ost->resample_sample_rate = dec->sample_rate;
777 audio_resample_close(ost->resample);
779 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
780 if (audio_sync_method <= 1 &&
781 ost->resample_sample_fmt == enc->sample_fmt &&
782 ost->resample_channels == enc->channels &&
783 ost->resample_sample_rate == enc->sample_rate) {
784 ost->resample = NULL;
785 ost->audio_resample = 0;
786 } else if (ost->audio_resample) {
787 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
788 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
789 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
790 enc->sample_rate, dec->sample_rate,
791 enc->sample_fmt, dec->sample_fmt,
793 if (!ost->resample) {
794 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
795 dec->channels, dec->sample_rate,
796 enc->channels, enc->sample_rate);
802 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
803 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
804 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
805 if (ost->reformat_ctx)
806 av_audio_convert_free(ost->reformat_ctx);
807 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
808 dec->sample_fmt, 1, NULL, 0);
809 if (!ost->reformat_ctx) {
810 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
811 av_get_sample_fmt_name(dec->sample_fmt),
812 av_get_sample_fmt_name(enc->sample_fmt));
815 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
818 if(audio_sync_method){
819 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
820 - av_fifo_size(ost->fifo)/(enc->channels * 2);
821 double idelta= delta*dec->sample_rate / enc->sample_rate;
822 int byte_delta= ((int)idelta)*2*dec->channels;
824 //FIXME resample delay
825 if(fabs(delta) > 50){
826 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
828 byte_delta= FFMAX(byte_delta, -size);
831 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
836 static uint8_t *input_tmp= NULL;
837 input_tmp= av_realloc(input_tmp, byte_delta + size);
839 if(byte_delta > allocated_for_size - size){
840 allocated_for_size= byte_delta + (int64_t)size;
845 memset(input_tmp, 0, byte_delta);
846 memcpy(input_tmp + byte_delta, buf, size);
849 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
851 }else if(audio_sync_method>1){
852 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
853 av_assert0(ost->audio_resample);
854 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
855 delta, comp, enc->sample_rate);
856 // 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));
857 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
861 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
862 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
864 if (ost->audio_resample) {
866 size_out = audio_resample(ost->resample,
867 (short *)buftmp, (short *)buf,
868 size / (dec->channels * isize));
869 size_out = size_out * enc->channels * osize;
875 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
876 const void *ibuf[6]= {buftmp};
877 void *obuf[6]= {audio_buf};
878 int istride[6]= {isize};
879 int ostride[6]= {osize};
880 int len= size_out/istride[0];
881 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
882 printf("av_audio_convert() failed\n");
888 size_out = len*osize;
891 /* now encode as many frames as possible */
892 if (enc->frame_size > 1) {
893 /* output resampled raw samples */
894 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
895 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
898 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
900 frame_bytes = enc->frame_size * osize * enc->channels;
902 while (av_fifo_size(ost->fifo) >= frame_bytes) {
904 av_init_packet(&pkt);
906 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
908 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
910 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
913 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
917 pkt.stream_index= ost->index;
920 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
921 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
922 pkt.flags |= AV_PKT_FLAG_KEY;
923 write_frame(s, &pkt, enc, ost->bitstream_filters);
925 ost->sync_opts += enc->frame_size;
929 av_init_packet(&pkt);
931 ost->sync_opts += size_out / (osize * enc->channels);
933 /* output a pcm frame */
934 /* determine the size of the coded buffer */
937 size_out = size_out*coded_bps/8;
939 if(size_out > audio_out_size){
940 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
944 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
945 ret = avcodec_encode_audio(enc, audio_out, size_out,
948 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
952 pkt.stream_index= ost->index;
955 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
956 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
957 pkt.flags |= AV_PKT_FLAG_KEY;
958 write_frame(s, &pkt, enc, ost->bitstream_filters);
962 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
966 AVPicture picture_tmp;
969 dec = ist->st->codec;
971 /* deinterlace : must be done before any resize */
972 if (do_deinterlace) {
975 /* create temporary picture */
976 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
977 buf = av_malloc(size);
981 picture2 = &picture_tmp;
982 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
984 if(avpicture_deinterlace(picture2, picture,
985 dec->pix_fmt, dec->width, dec->height) < 0) {
986 /* if error, do not deinterlace */
987 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
996 if (picture != picture2)
997 *picture = *picture2;
1001 static void do_subtitle_out(AVFormatContext *s,
1007 static uint8_t *subtitle_out = NULL;
1008 int subtitle_out_max_size = 1024 * 1024;
1009 int subtitle_out_size, nb, i;
1010 AVCodecContext *enc;
1013 if (pts == AV_NOPTS_VALUE) {
1014 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1020 enc = ost->st->codec;
1022 if (!subtitle_out) {
1023 subtitle_out = av_malloc(subtitle_out_max_size);
1026 /* Note: DVB subtitle need one packet to draw them and one other
1027 packet to clear them */
1028 /* XXX: signal it in the codec context ? */
1029 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1034 for(i = 0; i < nb; i++) {
1035 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1036 // start_display_time is required to be 0
1037 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1038 sub->end_display_time -= sub->start_display_time;
1039 sub->start_display_time = 0;
1040 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1041 subtitle_out_max_size, sub);
1042 if (subtitle_out_size < 0) {
1043 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1047 av_init_packet(&pkt);
1048 pkt.stream_index = ost->index;
1049 pkt.data = subtitle_out;
1050 pkt.size = subtitle_out_size;
1051 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1052 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1053 /* XXX: the pts correction is handled here. Maybe handling
1054 it in the codec would be better */
1056 pkt.pts += 90 * sub->start_display_time;
1058 pkt.pts += 90 * sub->end_display_time;
1060 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1064 static int bit_buffer_size= 1024*256;
1065 static uint8_t *bit_buffer= NULL;
1067 static void do_video_resample(OutputStream *ost,
1069 AVFrame *in_picture,
1070 AVFrame **out_picture)
1072 int resample_changed = 0;
1073 AVCodecContext *dec = ist->st->codec;
1074 *out_picture = in_picture;
1076 resample_changed = ost->resample_width != dec->width ||
1077 ost->resample_height != dec->height ||
1078 ost->resample_pix_fmt != dec->pix_fmt;
1080 if (resample_changed) {
1081 av_log(NULL, AV_LOG_INFO,
1082 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1083 ist->file_index, ist->st->index,
1084 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1085 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1086 if(!ost->video_resample)
1087 ost->video_resample = 1;
1090 #if !CONFIG_AVFILTER
1091 if (ost->video_resample) {
1092 *out_picture = &ost->pict_tmp;
1093 if (resample_changed) {
1094 /* initialize a new scaler context */
1095 sws_freeContext(ost->img_resample_ctx);
1096 ost->img_resample_ctx = sws_getContext(
1097 ist->st->codec->width,
1098 ist->st->codec->height,
1099 ist->st->codec->pix_fmt,
1100 ost->st->codec->width,
1101 ost->st->codec->height,
1102 ost->st->codec->pix_fmt,
1103 ost->sws_flags, NULL, NULL, NULL);
1104 if (ost->img_resample_ctx == NULL) {
1105 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1109 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1110 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1113 if (resample_changed) {
1114 avfilter_graph_free(&ost->graph);
1115 if (configure_video_filters(ist, ost)) {
1116 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1121 if (resample_changed) {
1122 ost->resample_width = dec->width;
1123 ost->resample_height = dec->height;
1124 ost->resample_pix_fmt = dec->pix_fmt;
1129 static void do_video_out(AVFormatContext *s,
1132 AVFrame *in_picture,
1133 int *frame_size, float quality)
1135 int nb_frames, i, ret, format_video_sync;
1136 AVFrame *final_picture;
1137 AVCodecContext *enc;
1140 enc = ost->st->codec;
1142 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1144 /* by default, we output a single frame */
1149 format_video_sync = video_sync_method;
1150 if (format_video_sync < 0)
1151 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1153 if (format_video_sync) {
1154 double vdelta = sync_ipts - ost->sync_opts;
1155 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1158 else if (format_video_sync == 2) {
1161 }else if(vdelta>0.6)
1162 ost->sync_opts= lrintf(sync_ipts);
1163 }else if (vdelta > 1.1)
1164 nb_frames = lrintf(vdelta);
1165 //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);
1166 if (nb_frames == 0){
1168 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1169 }else if (nb_frames > 1) {
1170 nb_frames_dup += nb_frames - 1;
1171 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1174 ost->sync_opts= lrintf(sync_ipts);
1176 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1180 do_video_resample(ost, ist, in_picture, &final_picture);
1182 /* duplicates frame if needed */
1183 for(i=0;i<nb_frames;i++) {
1185 av_init_packet(&pkt);
1186 pkt.stream_index= ost->index;
1188 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1189 /* raw pictures are written as AVPicture structure to
1190 avoid any copies. We support temporarily the older
1192 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1193 enc->coded_frame->top_field_first = in_picture->top_field_first;
1194 pkt.data= (uint8_t *)final_picture;
1195 pkt.size= sizeof(AVPicture);
1196 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1197 pkt.flags |= AV_PKT_FLAG_KEY;
1199 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1201 AVFrame big_picture;
1203 big_picture= *final_picture;
1204 /* better than nothing: use input picture interlaced
1206 big_picture.interlaced_frame = in_picture->interlaced_frame;
1207 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1208 if (ost->top_field_first == -1)
1209 big_picture.top_field_first = in_picture->top_field_first;
1211 big_picture.top_field_first = !!ost->top_field_first;
1214 /* handles same_quant here. This is not correct because it may
1215 not be a global option */
1216 big_picture.quality = quality;
1217 if (!enc->me_threshold)
1218 big_picture.pict_type = 0;
1219 // big_picture.pts = AV_NOPTS_VALUE;
1220 big_picture.pts= ost->sync_opts;
1221 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1222 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1223 if (ost->forced_kf_index < ost->forced_kf_count &&
1224 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1225 big_picture.pict_type = AV_PICTURE_TYPE_I;
1226 ost->forced_kf_index++;
1228 ret = avcodec_encode_video(enc,
1229 bit_buffer, bit_buffer_size,
1232 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1237 pkt.data= bit_buffer;
1239 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1240 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1241 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1242 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1243 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1245 if(enc->coded_frame->key_frame)
1246 pkt.flags |= AV_PKT_FLAG_KEY;
1247 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1250 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1251 // enc->frame_number-1, ret, enc->pict_type);
1252 /* if two pass, output log */
1253 if (ost->logfile && enc->stats_out) {
1254 fprintf(ost->logfile, "%s", enc->stats_out);
1259 ost->frame_number++;
1263 static double psnr(double d){
1264 return -10.0*log(d)/log(10.0);
1267 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1270 AVCodecContext *enc;
1272 double ti1, bitrate, avg_bitrate;
1274 /* this is executed just the first time do_video_stats is called */
1276 vstats_file = fopen(vstats_filename, "w");
1283 enc = ost->st->codec;
1284 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1285 frame_number = ost->frame_number;
1286 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1287 if (enc->flags&CODEC_FLAG_PSNR)
1288 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1290 fprintf(vstats_file,"f_size= %6d ", frame_size);
1291 /* compute pts value */
1292 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1296 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1297 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1298 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1299 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1300 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1304 static void print_report(OutputFile *output_files,
1305 OutputStream *ost_table, int nb_ostreams,
1306 int is_last_report, int64_t timer_start)
1310 AVFormatContext *oc;
1312 AVCodecContext *enc;
1313 int frame_number, vid, i;
1314 double bitrate, ti1, pts;
1315 static int64_t last_time = -1;
1316 static int qp_histogram[52];
1318 if (!print_stats && !is_last_report)
1321 if (!is_last_report) {
1323 /* display the report every 0.5 seconds */
1324 cur_time = av_gettime();
1325 if (last_time == -1) {
1326 last_time = cur_time;
1329 if ((cur_time - last_time) < 500000)
1331 last_time = cur_time;
1335 oc = output_files[0].ctx;
1337 total_size = avio_size(oc->pb);
1338 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1339 total_size= avio_tell(oc->pb);
1344 for(i=0;i<nb_ostreams;i++) {
1346 ost = &ost_table[i];
1347 enc = ost->st->codec;
1348 if (!ost->st->stream_copy && enc->coded_frame)
1349 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1350 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1351 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1353 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1354 float t = (av_gettime()-timer_start) / 1000000.0;
1356 frame_number = ost->frame_number;
1357 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1358 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1360 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1364 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1367 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1369 if (enc->flags&CODEC_FLAG_PSNR){
1371 double error, error_sum=0;
1372 double scale, scale_sum=0;
1373 char type[3]= {'Y','U','V'};
1374 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1377 error= enc->error[j];
1378 scale= enc->width*enc->height*255.0*255.0*frame_number;
1380 error= enc->coded_frame->error[j];
1381 scale= enc->width*enc->height*255.0*255.0;
1386 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1388 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1392 /* compute min output value */
1393 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1394 if ((pts < ti1) && (pts > 0))
1400 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1402 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1403 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1404 (double)total_size / 1024, ti1, bitrate);
1406 if (nb_frames_dup || nb_frames_drop)
1407 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1408 nb_frames_dup, nb_frames_drop);
1410 av_log(NULL, is_last_report ? AV_LOG_WARNING : AV_LOG_INFO, "%s \r", buf);
1414 if (is_last_report) {
1415 int64_t raw= audio_size + video_size + extra_size;
1416 av_log(NULL, AV_LOG_INFO, "\n");
1417 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1421 100.0*(total_size - raw)/raw
1426 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1428 int fill_char = 0x00;
1429 if (sample_fmt == AV_SAMPLE_FMT_U8)
1431 memset(buf, fill_char, size);
1434 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1438 for (i = 0; i < nb_ostreams; i++) {
1439 OutputStream *ost = &ost_table[i];
1440 AVCodecContext *enc = ost->st->codec;
1441 AVFormatContext *os = output_files[ost->file_index].ctx;
1443 if (!ost->encoding_needed)
1446 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1448 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1454 av_init_packet(&pkt);
1455 pkt.stream_index= ost->index;
1457 switch (ost->st->codec->codec_type) {
1458 case AVMEDIA_TYPE_AUDIO:
1459 fifo_bytes = av_fifo_size(ost->fifo);
1461 /* encode any samples remaining in fifo */
1462 if (fifo_bytes > 0) {
1463 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1464 int fs_tmp = enc->frame_size;
1466 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1467 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1468 enc->frame_size = fifo_bytes / (osize * enc->channels);
1470 int frame_bytes = enc->frame_size*osize*enc->channels;
1471 if (allocated_audio_buf_size < frame_bytes)
1473 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1476 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1477 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1478 ost->st->time_base.num, enc->sample_rate);
1479 enc->frame_size = fs_tmp;
1482 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1485 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1489 pkt.flags |= AV_PKT_FLAG_KEY;
1491 case AVMEDIA_TYPE_VIDEO:
1492 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1494 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1498 if(enc->coded_frame && enc->coded_frame->key_frame)
1499 pkt.flags |= AV_PKT_FLAG_KEY;
1500 if (ost->logfile && enc->stats_out) {
1501 fprintf(ost->logfile, "%s", enc->stats_out);
1510 pkt.data = bit_buffer;
1512 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1513 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1514 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1519 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1520 static int output_packet(InputStream *ist, int ist_index,
1521 OutputStream *ost_table, int nb_ostreams,
1522 const AVPacket *pkt)
1524 AVFormatContext *os;
1528 void *buffer_to_free = NULL;
1529 static unsigned int samples_size= 0;
1530 AVSubtitle subtitle, *subtitle_to_free;
1531 int64_t pkt_pts = AV_NOPTS_VALUE;
1533 int frame_available;
1538 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1540 if(ist->next_pts == AV_NOPTS_VALUE)
1541 ist->next_pts= ist->pts;
1545 av_init_packet(&avpkt);
1553 if(pkt->dts != AV_NOPTS_VALUE)
1554 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1555 if(pkt->pts != AV_NOPTS_VALUE)
1556 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1558 //while we have more to decode or while the decoder did output something on EOF
1559 while (avpkt.size > 0 || (!pkt && got_output)) {
1560 uint8_t *data_buf, *decoded_data_buf;
1561 int data_size, decoded_data_size;
1562 AVFrame *decoded_frame, *filtered_frame;
1564 ist->pts= ist->next_pts;
1566 if(avpkt.size && avpkt.size != pkt->size)
1567 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1568 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1569 ist->showed_multi_packet_warning=1;
1571 /* decode the packet if needed */
1572 decoded_frame = filtered_frame = NULL;
1573 decoded_data_buf = NULL; /* fail safe */
1574 decoded_data_size= 0;
1575 data_buf = avpkt.data;
1576 data_size = avpkt.size;
1577 subtitle_to_free = NULL;
1578 if (ist->decoding_needed) {
1579 switch(ist->st->codec->codec_type) {
1580 case AVMEDIA_TYPE_AUDIO:{
1581 if(pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1582 samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1584 samples= av_malloc(samples_size);
1586 decoded_data_size= samples_size;
1587 /* XXX: could avoid copy if PCM 16 bits with same
1588 endianness as CPU */
1589 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1596 got_output = decoded_data_size > 0;
1597 /* Some bug in mpeg audio decoder gives */
1598 /* decoded_data_size < 0, it seems they are overflows */
1600 /* no audio frame */
1603 decoded_data_buf = (uint8_t *)samples;
1604 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1605 (ist->st->codec->sample_rate * ist->st->codec->channels);
1607 case AVMEDIA_TYPE_VIDEO:
1608 if (!(decoded_frame = avcodec_alloc_frame()))
1609 return AVERROR(ENOMEM);
1610 avpkt.pts = pkt_pts;
1611 avpkt.dts = ist->pts;
1612 pkt_pts = AV_NOPTS_VALUE;
1614 ret = avcodec_decode_video2(ist->st->codec,
1615 decoded_frame, &got_output, &avpkt);
1616 quality = same_quant ? decoded_frame->quality : 0;
1620 /* no picture yet */
1621 av_freep(&decoded_frame);
1622 goto discard_packet;
1624 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1625 decoded_frame->pkt_dts);
1626 if (ist->st->codec->time_base.num != 0) {
1627 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1628 ist->next_pts += ((int64_t)AV_TIME_BASE *
1629 ist->st->codec->time_base.num * ticks) /
1630 ist->st->codec->time_base.den;
1633 buffer_to_free = NULL;
1634 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1636 case AVMEDIA_TYPE_SUBTITLE:
1637 ret = avcodec_decode_subtitle2(ist->st->codec,
1638 &subtitle, &got_output, &avpkt);
1642 goto discard_packet;
1644 subtitle_to_free = &subtitle;
1651 switch(ist->st->codec->codec_type) {
1652 case AVMEDIA_TYPE_AUDIO:
1653 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1654 ist->st->codec->sample_rate;
1656 case AVMEDIA_TYPE_VIDEO:
1657 if (ist->st->codec->time_base.num != 0) {
1658 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1659 ist->next_pts += ((int64_t)AV_TIME_BASE *
1660 ist->st->codec->time_base.num * ticks) /
1661 ist->st->codec->time_base.den;
1668 // preprocess audio (volume)
1669 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1670 if (audio_volume != 256) {
1671 switch (ist->st->codec->sample_fmt) {
1672 case AV_SAMPLE_FMT_U8:
1674 uint8_t *volp = samples;
1675 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1676 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1677 *volp++ = av_clip_uint8(v);
1681 case AV_SAMPLE_FMT_S16:
1683 int16_t *volp = samples;
1684 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1685 int v = ((*volp) * audio_volume + 128) >> 8;
1686 *volp++ = av_clip_int16(v);
1690 case AV_SAMPLE_FMT_S32:
1692 int32_t *volp = samples;
1693 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1694 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1695 *volp++ = av_clipl_int32(v);
1699 case AV_SAMPLE_FMT_FLT:
1701 float *volp = samples;
1702 float scale = audio_volume / 256.f;
1703 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1708 case AV_SAMPLE_FMT_DBL:
1710 double *volp = samples;
1711 double scale = audio_volume / 256.;
1712 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1718 av_log(NULL, AV_LOG_FATAL,
1719 "Audio volume adjustment on sample format %s is not supported.\n",
1720 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1726 /* frame rate emulation */
1727 if (input_files[ist->file_index].rate_emu) {
1728 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1729 int64_t now = av_gettime() - ist->start;
1733 /* if output time reached then transcode raw format,
1734 encode packets and output them */
1735 for (i = 0; i < nb_ostreams; i++) {
1736 OutputFile *of = &output_files[ost_table[i].file_index];
1739 ost = &ost_table[i];
1740 if (ost->source_index != ist_index)
1743 if (of->start_time && ist->pts < of->start_time)
1746 if (of->recording_time != INT64_MAX &&
1747 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1748 (AVRational){1, 1000000}) >= 0) {
1749 ost->is_past_recording_time = 1;
1754 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1755 ost->input_video_filter) {
1757 if (ist->st->sample_aspect_ratio.num)
1758 sar = ist->st->sample_aspect_ratio;
1760 sar = ist->st->codec->sample_aspect_ratio;
1761 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, ist->pts, sar);
1762 if (!(filtered_frame = avcodec_alloc_frame())) {
1763 ret = AVERROR(ENOMEM);
1767 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1768 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1769 while (frame_available) {
1770 AVRational ist_pts_tb;
1771 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1772 get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
1774 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1776 filtered_frame = decoded_frame;
1778 os = output_files[ost->file_index].ctx;
1780 /* set the input output pts pairs */
1781 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1783 if (ost->encoding_needed) {
1784 av_assert0(ist->decoding_needed);
1785 switch(ost->st->codec->codec_type) {
1786 case AVMEDIA_TYPE_AUDIO:
1787 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1789 case AVMEDIA_TYPE_VIDEO:
1791 if (ost->picref->video && !ost->frame_aspect_ratio)
1792 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1794 do_video_out(os, ost, ist, filtered_frame, &frame_size,
1795 same_quant ? quality : ost->st->codec->global_quality);
1796 if (vstats_filename && frame_size)
1797 do_video_stats(os, ost, frame_size);
1799 case AVMEDIA_TYPE_SUBTITLE:
1800 do_subtitle_out(os, ost, ist, &subtitle,
1808 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1810 av_init_packet(&opkt);
1812 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1813 #if !CONFIG_AVFILTER
1819 /* no reencoding needed : output the packet directly */
1820 /* force the input stream PTS */
1822 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1823 audio_size += data_size;
1824 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1825 video_size += data_size;
1829 opkt.stream_index= ost->index;
1830 if(pkt->pts != AV_NOPTS_VALUE)
1831 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1833 opkt.pts= AV_NOPTS_VALUE;
1835 if (pkt->dts == AV_NOPTS_VALUE)
1836 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1838 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1839 opkt.dts -= ost_tb_start_time;
1841 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1842 opkt.flags= pkt->flags;
1844 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1845 if( ost->st->codec->codec_id != CODEC_ID_H264
1846 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1847 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1849 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1850 opkt.destruct= av_destruct_packet;
1852 opkt.data = data_buf;
1853 opkt.size = data_size;
1856 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1857 ost->st->codec->frame_number++;
1858 ost->frame_number++;
1859 av_free_packet(&opkt);
1863 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1864 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1866 avfilter_unref_buffer(ost->picref);
1868 av_freep(&filtered_frame);
1873 av_free(buffer_to_free);
1874 /* XXX: allocate the subtitles in the codec ? */
1875 if (subtitle_to_free) {
1876 avsubtitle_free(subtitle_to_free);
1877 subtitle_to_free = NULL;
1879 av_freep(&decoded_frame);
1888 static void print_sdp(OutputFile *output_files, int n)
1892 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1896 for (i = 0; i < n; i++)
1897 avc[i] = output_files[i].ctx;
1899 av_sdp_create(avc, n, sdp, sizeof(sdp));
1900 printf("SDP:\n%s\n", sdp);
1905 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1906 char *error, int error_len)
1909 InputStream *ist = &input_streams[ist_index];
1910 if (ist->decoding_needed) {
1911 AVCodec *codec = ist->dec;
1913 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1914 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1915 return AVERROR(EINVAL);
1918 /* update requested sample format for the decoder based on the
1919 corresponding encoder sample format */
1920 for (i = 0; i < nb_output_streams; i++) {
1921 OutputStream *ost = &output_streams[i];
1922 if (ost->source_index == ist_index) {
1923 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1928 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1929 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1930 ist->file_index, ist->st->index);
1931 return AVERROR(EINVAL);
1933 assert_codec_experimental(ist->st->codec, 0);
1934 assert_avoptions(ist->opts);
1937 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;
1938 ist->next_pts = AV_NOPTS_VALUE;
1939 init_pts_correction(&ist->pts_ctx);
1945 static int transcode_init(OutputFile *output_files,
1946 int nb_output_files,
1947 InputFile *input_files,
1950 int ret = 0, i, j, k;
1951 AVFormatContext *os;
1952 AVCodecContext *codec, *icodec;
1958 /* init framerate emulation */
1959 for (i = 0; i < nb_input_files; i++) {
1960 InputFile *ifile = &input_files[i];
1961 if (ifile->rate_emu)
1962 for (j = 0; j < ifile->nb_streams; j++)
1963 input_streams[j + ifile->ist_index].start = av_gettime();
1966 /* output stream init */
1967 for(i=0;i<nb_output_files;i++) {
1968 os = output_files[i].ctx;
1969 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1970 av_dump_format(os, i, os->filename, 1);
1971 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
1972 return AVERROR(EINVAL);
1976 /* for each output stream, we compute the right encoding parameters */
1977 for (i = 0; i < nb_output_streams; i++) {
1978 ost = &output_streams[i];
1979 os = output_files[ost->file_index].ctx;
1980 ist = &input_streams[ost->source_index];
1982 codec = ost->st->codec;
1983 icodec = ist->st->codec;
1985 ost->st->disposition = ist->st->disposition;
1986 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1987 codec->chroma_sample_location = icodec->chroma_sample_location;
1989 if (ost->st->stream_copy) {
1990 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1992 if (extra_size > INT_MAX) {
1993 return AVERROR(EINVAL);
1996 /* if stream_copy is selected, no need to decode or encode */
1997 codec->codec_id = icodec->codec_id;
1998 codec->codec_type = icodec->codec_type;
2000 if(!codec->codec_tag){
2001 if( !os->oformat->codec_tag
2002 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2003 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2004 codec->codec_tag = icodec->codec_tag;
2007 codec->bit_rate = icodec->bit_rate;
2008 codec->rc_max_rate = icodec->rc_max_rate;
2009 codec->rc_buffer_size = icodec->rc_buffer_size;
2010 codec->extradata= av_mallocz(extra_size);
2011 if (!codec->extradata) {
2012 return AVERROR(ENOMEM);
2014 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2015 codec->extradata_size= icodec->extradata_size;
2016 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){
2017 codec->time_base = icodec->time_base;
2018 codec->time_base.num *= icodec->ticks_per_frame;
2019 av_reduce(&codec->time_base.num, &codec->time_base.den,
2020 codec->time_base.num, codec->time_base.den, INT_MAX);
2022 codec->time_base = ist->st->time_base;
2023 switch(codec->codec_type) {
2024 case AVMEDIA_TYPE_AUDIO:
2025 if(audio_volume != 256) {
2026 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2029 codec->channel_layout = icodec->channel_layout;
2030 codec->sample_rate = icodec->sample_rate;
2031 codec->channels = icodec->channels;
2032 codec->frame_size = icodec->frame_size;
2033 codec->audio_service_type = icodec->audio_service_type;
2034 codec->block_align= icodec->block_align;
2035 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2036 codec->block_align= 0;
2037 if(codec->codec_id == CODEC_ID_AC3)
2038 codec->block_align= 0;
2040 case AVMEDIA_TYPE_VIDEO:
2041 codec->pix_fmt = icodec->pix_fmt;
2042 codec->width = icodec->width;
2043 codec->height = icodec->height;
2044 codec->has_b_frames = icodec->has_b_frames;
2045 if (!codec->sample_aspect_ratio.num) {
2046 codec->sample_aspect_ratio =
2047 ost->st->sample_aspect_ratio =
2048 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2049 ist->st->codec->sample_aspect_ratio.num ?
2050 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2053 case AVMEDIA_TYPE_SUBTITLE:
2054 codec->width = icodec->width;
2055 codec->height = icodec->height;
2057 case AVMEDIA_TYPE_DATA:
2058 case AVMEDIA_TYPE_ATTACHMENT:
2065 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2066 ist->decoding_needed = 1;
2067 ost->encoding_needed = 1;
2068 switch(codec->codec_type) {
2069 case AVMEDIA_TYPE_AUDIO:
2070 ost->fifo= av_fifo_alloc(1024);
2072 return AVERROR(ENOMEM);
2074 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2075 if (!codec->sample_rate) {
2076 codec->sample_rate = icodec->sample_rate;
2078 codec->sample_rate >>= icodec->lowres;
2080 choose_sample_rate(ost->st, ost->enc);
2081 codec->time_base = (AVRational){1, codec->sample_rate};
2082 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2083 codec->sample_fmt = icodec->sample_fmt;
2084 choose_sample_fmt(ost->st, ost->enc);
2085 if (!codec->channels)
2086 codec->channels = icodec->channels;
2087 codec->channel_layout = icodec->channel_layout;
2088 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2089 codec->channel_layout = 0;
2090 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2091 icodec->request_channels = codec->channels;
2092 ost->resample_sample_fmt = icodec->sample_fmt;
2093 ost->resample_sample_rate = icodec->sample_rate;
2094 ost->resample_channels = icodec->channels;
2096 case AVMEDIA_TYPE_VIDEO:
2097 if (codec->pix_fmt == PIX_FMT_NONE)
2098 codec->pix_fmt = icodec->pix_fmt;
2099 choose_pixel_fmt(ost->st, ost->enc);
2101 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2102 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2106 if (!codec->width || !codec->height) {
2107 codec->width = icodec->width;
2108 codec->height = icodec->height;
2111 ost->video_resample = codec->width != icodec->width ||
2112 codec->height != icodec->height ||
2113 codec->pix_fmt != icodec->pix_fmt;
2114 if (ost->video_resample) {
2115 #if !CONFIG_AVFILTER
2116 avcodec_get_frame_defaults(&ost->pict_tmp);
2117 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2118 codec->width, codec->height)) {
2119 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2122 ost->img_resample_ctx = sws_getContext(
2129 ost->sws_flags, NULL, NULL, NULL);
2130 if (ost->img_resample_ctx == NULL) {
2131 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2135 codec->bits_per_raw_sample= 0;
2138 ost->resample_height = icodec->height;
2139 ost->resample_width = icodec->width;
2140 ost->resample_pix_fmt= icodec->pix_fmt;
2142 if (!ost->frame_rate.num)
2143 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2144 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2145 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2146 ost->frame_rate = ost->enc->supported_framerates[idx];
2148 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2151 if (configure_video_filters(ist, ost)) {
2152 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2157 case AVMEDIA_TYPE_SUBTITLE:
2164 if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2165 char logfilename[1024];
2168 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2169 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2171 if (codec->flags & CODEC_FLAG_PASS1) {
2172 f = fopen(logfilename, "wb");
2174 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2175 logfilename, strerror(errno));
2181 size_t logbuffer_size;
2182 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2183 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2187 codec->stats_in = logbuffer;
2191 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2192 int size= codec->width * codec->height;
2193 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2198 bit_buffer = av_malloc(bit_buffer_size);
2200 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2202 return AVERROR(ENOMEM);
2205 /* open each encoder */
2206 for (i = 0; i < nb_output_streams; i++) {
2207 ost = &output_streams[i];
2208 if (ost->encoding_needed) {
2209 AVCodec *codec = ost->enc;
2210 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2212 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2213 ost->st->codec->codec_id, ost->file_index, ost->index);
2214 ret = AVERROR(EINVAL);
2217 if (dec->subtitle_header) {
2218 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2219 if (!ost->st->codec->subtitle_header) {
2220 ret = AVERROR(ENOMEM);
2223 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2224 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2226 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2227 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2228 ost->file_index, ost->index);
2229 ret = AVERROR(EINVAL);
2232 assert_codec_experimental(ost->st->codec, 1);
2233 assert_avoptions(ost->opts);
2234 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2235 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2236 "It takes bits/s as argument, not kbits/s\n");
2237 extra_size += ost->st->codec->extradata_size;
2239 if (ost->st->codec->me_threshold)
2240 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2244 /* init input streams */
2245 for (i = 0; i < nb_input_streams; i++)
2246 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2249 /* discard unused programs */
2250 for (i = 0; i < nb_input_files; i++) {
2251 InputFile *ifile = &input_files[i];
2252 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2253 AVProgram *p = ifile->ctx->programs[j];
2254 int discard = AVDISCARD_ALL;
2256 for (k = 0; k < p->nb_stream_indexes; k++)
2257 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2258 discard = AVDISCARD_DEFAULT;
2261 p->discard = discard;
2265 /* open files and write file headers */
2266 for (i = 0; i < nb_output_files; i++) {
2267 os = output_files[i].ctx;
2268 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2269 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2270 ret = AVERROR(EINVAL);
2273 assert_avoptions(output_files[i].opts);
2274 if (strcmp(os->oformat->name, "rtp")) {
2280 /* dump the file output parameters - cannot be done before in case
2282 for(i=0;i<nb_output_files;i++) {
2283 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2286 /* dump the stream mapping */
2287 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2288 for (i = 0; i < nb_output_streams; i++) {
2289 ost = &output_streams[i];
2290 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d -> #%d.%d",
2291 input_streams[ost->source_index].file_index,
2292 input_streams[ost->source_index].st->index,
2295 if (ost->sync_ist != &input_streams[ost->source_index])
2296 av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
2297 ost->sync_ist->file_index,
2298 ost->sync_ist->st->index);
2299 if (ost->st->stream_copy)
2300 av_log(NULL, AV_LOG_INFO, " (copy)");
2302 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2303 input_streams[ost->source_index].dec->name : "?",
2304 ost->enc ? ost->enc->name : "?");
2305 av_log(NULL, AV_LOG_INFO, "\n");
2309 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2314 print_sdp(output_files, nb_output_files);
2321 * The following code is the main loop of the file converter
2323 static int transcode(OutputFile *output_files,
2324 int nb_output_files,
2325 InputFile *input_files,
2329 AVFormatContext *is, *os;
2333 int no_packet_count=0;
2334 int64_t timer_start;
2336 if (!(no_packet = av_mallocz(nb_input_files)))
2339 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2343 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2346 timer_start = av_gettime();
2348 for(; received_sigterm == 0;) {
2349 int file_index, ist_index;
2354 ipts_min = INT64_MAX;
2357 /* select the stream that we must read now by looking at the
2358 smallest output pts */
2360 for (i = 0; i < nb_output_streams; i++) {
2364 ost = &output_streams[i];
2365 of = &output_files[ost->file_index];
2366 os = output_files[ost->file_index].ctx;
2367 ist = &input_streams[ost->source_index];
2368 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2369 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2371 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2373 if (!input_files[ist->file_index].eof_reached){
2374 if(ipts < ipts_min) {
2376 if(input_sync ) file_index = ist->file_index;
2378 if(opts < opts_min) {
2380 if(!input_sync) file_index = ist->file_index;
2383 if (ost->frame_number >= ost->max_frames) {
2385 for (j = 0; j < of->ctx->nb_streams; j++)
2386 output_streams[of->ost_index + j].is_past_recording_time = 1;
2390 /* if none, if is finished */
2391 if (file_index < 0) {
2392 if(no_packet_count){
2394 memset(no_packet, 0, nb_input_files);
2401 /* read a frame from it and output it in the fifo */
2402 is = input_files[file_index].ctx;
2403 ret= av_read_frame(is, &pkt);
2404 if(ret == AVERROR(EAGAIN)){
2405 no_packet[file_index]=1;
2410 input_files[file_index].eof_reached = 1;
2418 memset(no_packet, 0, nb_input_files);
2421 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2422 is->streams[pkt.stream_index]);
2424 /* the following test is needed in case new streams appear
2425 dynamically in stream : we ignore them */
2426 if (pkt.stream_index >= input_files[file_index].nb_streams)
2427 goto discard_packet;
2428 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2429 ist = &input_streams[ist_index];
2431 goto discard_packet;
2433 if (pkt.dts != AV_NOPTS_VALUE)
2434 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2435 if (pkt.pts != AV_NOPTS_VALUE)
2436 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2438 if(pkt.pts != AV_NOPTS_VALUE)
2439 pkt.pts *= ist->ts_scale;
2440 if(pkt.dts != AV_NOPTS_VALUE)
2441 pkt.dts *= ist->ts_scale;
2443 // 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);
2444 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2445 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2446 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2447 int64_t delta= pkt_dts - ist->next_pts;
2448 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2449 input_files[ist->file_index].ts_offset -= delta;
2450 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2451 delta, input_files[ist->file_index].ts_offset);
2452 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2453 if(pkt.pts != AV_NOPTS_VALUE)
2454 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2458 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2459 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2461 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d.%d\n",
2462 ist->file_index, ist->st->index);
2465 av_free_packet(&pkt);
2470 av_free_packet(&pkt);
2472 /* dump report by using the output first video and audio streams */
2473 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2476 /* at the end of stream, we must flush the decoder buffers */
2477 for (i = 0; i < nb_input_streams; i++) {
2478 ist = &input_streams[i];
2479 if (ist->decoding_needed) {
2480 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2483 flush_encoders(output_streams, nb_output_streams);
2487 /* write the trailer if needed and close file */
2488 for(i=0;i<nb_output_files;i++) {
2489 os = output_files[i].ctx;
2490 av_write_trailer(os);
2493 /* dump report by using the first video and audio streams */
2494 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2496 /* close each encoder */
2497 for (i = 0; i < nb_output_streams; i++) {
2498 ost = &output_streams[i];
2499 if (ost->encoding_needed) {
2500 av_freep(&ost->st->codec->stats_in);
2501 avcodec_close(ost->st->codec);
2504 avfilter_graph_free(&ost->graph);
2508 /* close each decoder */
2509 for (i = 0; i < nb_input_streams; i++) {
2510 ist = &input_streams[i];
2511 if (ist->decoding_needed) {
2512 avcodec_close(ist->st->codec);
2520 av_freep(&bit_buffer);
2521 av_freep(&no_packet);
2523 if (output_streams) {
2524 for (i = 0; i < nb_output_streams; i++) {
2525 ost = &output_streams[i];
2527 if (ost->st->stream_copy)
2528 av_freep(&ost->st->codec->extradata);
2530 fclose(ost->logfile);
2531 ost->logfile = NULL;
2533 av_fifo_free(ost->fifo); /* works even if fifo is not
2534 initialized but set to zero */
2535 av_freep(&ost->st->codec->subtitle_header);
2536 av_free(ost->pict_tmp.data[0]);
2537 av_free(ost->forced_kf_pts);
2538 if (ost->video_resample)
2539 sws_freeContext(ost->img_resample_ctx);
2541 audio_resample_close(ost->resample);
2542 if (ost->reformat_ctx)
2543 av_audio_convert_free(ost->reformat_ctx);
2544 av_dict_free(&ost->opts);
2551 static int opt_verbose(const char *opt, const char *arg)
2553 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -loglevel\n", opt);
2557 static double parse_frame_aspect_ratio(const char *arg)
2564 p = strchr(arg, ':');
2566 x = strtol(arg, &end, 10);
2568 y = strtol(end+1, &end, 10);
2570 ar = (double)x / (double)y;
2572 ar = strtod(arg, NULL);
2575 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2581 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2583 return parse_option(o, "codec:a", arg, options);
2586 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2588 return parse_option(o, "codec:v", arg, options);
2591 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2593 return parse_option(o, "codec:s", arg, options);
2596 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2598 return parse_option(o, "codec:d", arg, options);
2601 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2603 StreamMap *m = NULL;
2604 int i, negative = 0, file_idx;
2605 int sync_file_idx = -1, sync_stream_idx;
2613 map = av_strdup(arg);
2615 /* parse sync stream first, just pick first matching stream */
2616 if (sync = strchr(map, ',')) {
2618 sync_file_idx = strtol(sync + 1, &sync, 0);
2619 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2620 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2625 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2626 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2627 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2628 sync_stream_idx = i;
2631 if (i == input_files[sync_file_idx].nb_streams) {
2632 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2633 "match any streams.\n", arg);
2639 file_idx = strtol(map, &p, 0);
2640 if (file_idx >= nb_input_files || file_idx < 0) {
2641 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2645 /* disable some already defined maps */
2646 for (i = 0; i < o->nb_stream_maps; i++) {
2647 m = &o->stream_maps[i];
2648 if (check_stream_specifier(input_files[m->file_index].ctx,
2649 input_files[m->file_index].ctx->streams[m->stream_index],
2650 *p == ':' ? p + 1 : p) > 0)
2654 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2655 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2656 *p == ':' ? p + 1 : p) <= 0)
2658 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2659 &o->nb_stream_maps, o->nb_stream_maps + 1);
2660 m = &o->stream_maps[o->nb_stream_maps - 1];
2662 m->file_index = file_idx;
2663 m->stream_index = i;
2665 if (sync_file_idx >= 0) {
2666 m->sync_file_index = sync_file_idx;
2667 m->sync_stream_index = sync_stream_idx;
2669 m->sync_file_index = file_idx;
2670 m->sync_stream_index = i;
2675 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2683 static void parse_meta_type(char *arg, char *type, int *index)
2693 if (*(++arg) == ':')
2694 *index = strtol(++arg, NULL, 0);
2697 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2704 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2706 MetadataMap *m, *m1;
2709 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2710 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2712 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2713 m->file = strtol(arg, &p, 0);
2714 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2716 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2717 if (p = strchr(opt, ':'))
2718 parse_meta_type(p + 1, &m1->type, &m1->index);
2722 if (m->type == 'g' || m1->type == 'g')
2723 o->metadata_global_manual = 1;
2724 if (m->type == 's' || m1->type == 's')
2725 o->metadata_streams_manual = 1;
2726 if (m->type == 'c' || m1->type == 'c')
2727 o->metadata_chapters_manual = 1;
2732 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2734 const char *codec_string = encoder ? "encoder" : "decoder";
2738 return CODEC_ID_NONE;
2740 avcodec_find_encoder_by_name(name) :
2741 avcodec_find_decoder_by_name(name);
2743 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2746 if(codec->type != type) {
2747 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2753 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2755 char *codec_name = NULL;
2757 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2761 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2762 return avcodec_find_encoder(st->codec->codec_id);
2764 } else if (!strcmp(codec_name, "copy"))
2765 st->stream_copy = 1;
2767 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2768 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2769 avcodec_find_decoder_by_name(codec_name);
2776 * Add all the streams from the given input file to the global
2777 * list of input streams.
2779 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2781 int i, rfps, rfps_base;
2783 for (i = 0; i < ic->nb_streams; i++) {
2784 AVStream *st = ic->streams[i];
2785 AVCodecContext *dec = st->codec;
2789 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2790 ist = &input_streams[nb_input_streams - 1];
2792 ist->file_index = nb_input_files;
2794 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2796 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2797 ist->ts_scale = scale;
2799 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2801 ist->dec = avcodec_find_decoder(dec->codec_id);
2803 switch (dec->codec_type) {
2804 case AVMEDIA_TYPE_AUDIO:
2805 if (o->audio_disable)
2806 st->discard= AVDISCARD_ALL;
2808 case AVMEDIA_TYPE_VIDEO:
2809 rfps = ic->streams[i]->r_frame_rate.num;
2810 rfps_base = ic->streams[i]->r_frame_rate.den;
2812 dec->flags |= CODEC_FLAG_EMU_EDGE;
2813 dec->height >>= dec->lowres;
2814 dec->width >>= dec->lowres;
2817 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2819 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",
2820 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2821 (float)rfps / rfps_base, rfps, rfps_base);
2824 if (o->video_disable)
2825 st->discard= AVDISCARD_ALL;
2826 else if(video_discard)
2827 st->discard= video_discard;
2829 case AVMEDIA_TYPE_DATA:
2831 case AVMEDIA_TYPE_SUBTITLE:
2832 if (o->subtitle_disable)
2833 st->discard = AVDISCARD_ALL;
2835 case AVMEDIA_TYPE_ATTACHMENT:
2836 case AVMEDIA_TYPE_UNKNOWN:
2844 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2846 AVFormatContext *ic;
2847 AVInputFormat *file_iformat = NULL;
2851 AVDictionary **opts;
2852 int orig_nb_streams; // number of streams before avformat_find_stream_info
2855 if (!(file_iformat = av_find_input_format(o->format))) {
2856 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
2861 if (!strcmp(filename, "-"))
2864 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2865 !strcmp(filename, "/dev/stdin");
2867 /* get default parameters from command line */
2868 ic = avformat_alloc_context();
2870 print_error(filename, AVERROR(ENOMEM));
2873 if (o->nb_audio_sample_rate) {
2874 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2875 av_dict_set(&format_opts, "sample_rate", buf, 0);
2877 if (o->nb_audio_channels) {
2878 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2879 av_dict_set(&format_opts, "channels", buf, 0);
2881 if (o->nb_frame_rates) {
2882 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2884 if (o->nb_frame_sizes) {
2885 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2887 if (o->nb_frame_pix_fmts)
2888 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
2890 ic->flags |= AVFMT_FLAG_NONBLOCK;
2892 /* open the input file with generic libav function */
2893 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2895 print_error(filename, err);
2898 assert_avoptions(format_opts);
2900 /* apply forced codec ids */
2901 for (i = 0; i < ic->nb_streams; i++)
2902 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
2904 /* Set AVCodecContext options for avformat_find_stream_info */
2905 opts = setup_find_stream_info_opts(ic, codec_opts);
2906 orig_nb_streams = ic->nb_streams;
2908 /* If not enough info to get the stream parameters, we decode the
2909 first frames to get it. (used in mpeg case for example) */
2910 ret = avformat_find_stream_info(ic, opts);
2912 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
2913 av_close_input_file(ic);
2917 timestamp = o->start_time;
2918 /* add the stream start time */
2919 if (ic->start_time != AV_NOPTS_VALUE)
2920 timestamp += ic->start_time;
2922 /* if seeking requested, we execute it */
2923 if (o->start_time != 0) {
2924 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2926 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2927 filename, (double)timestamp / AV_TIME_BASE);
2931 /* update the current parameters so that they match the one of the input stream */
2932 add_input_streams(o, ic);
2934 /* dump the file content */
2935 av_dump_format(ic, nb_input_files, filename, 0);
2937 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
2938 input_files[nb_input_files - 1].ctx = ic;
2939 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
2940 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
2941 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
2942 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
2944 for (i = 0; i < orig_nb_streams; i++)
2945 av_dict_free(&opts[i]);
2952 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2953 AVCodecContext *avctx)
2959 for (p = kf; *p; p++)
2962 ost->forced_kf_count = n;
2963 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2964 if (!ost->forced_kf_pts) {
2965 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2968 for (i = 0; i < n; i++) {
2969 p = i ? strchr(p, ',') + 1 : kf;
2970 t = parse_time_or_die("force_key_frames", p, 1);
2971 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2975 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
2978 AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
2979 int idx = oc->nb_streams - 1;
2980 int64_t max_frames = INT64_MAX;
2981 char *bsf = NULL, *next, *codec_tag = NULL;
2982 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
2986 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
2990 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
2991 nb_output_streams + 1);
2992 ost = &output_streams[nb_output_streams - 1];
2993 ost->file_index = nb_output_files;
2996 st->codec->codec_type = type;
2997 ost->enc = choose_codec(o, oc, st, type);
2999 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3002 avcodec_get_context_defaults3(st->codec, ost->enc);
3003 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3005 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3006 ost->max_frames = max_frames;
3008 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3010 if (next = strchr(bsf, ','))
3012 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3013 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3017 bsfc_prev->next = bsfc;
3019 ost->bitstream_filters = bsfc;
3025 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3027 uint32_t tag = strtol(codec_tag, &next, 0);
3029 tag = AV_RL32(codec_tag);
3030 st->codec->codec_tag = tag;
3033 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3034 if (qscale >= 0 || same_quant) {
3035 st->codec->flags |= CODEC_FLAG_QSCALE;
3036 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3039 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3040 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3042 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3046 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3049 const char *p = str;
3056 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3063 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3067 AVCodecContext *video_enc;
3069 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3071 video_enc = st->codec;
3073 if (!st->stream_copy) {
3074 const char *p = NULL;
3075 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3076 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3077 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3078 int i, force_fps = 0, top_field_first = -1;
3080 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3081 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3082 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3086 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3087 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3088 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3092 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3093 if (frame_aspect_ratio)
3094 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3096 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3097 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3098 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3101 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3103 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3105 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3106 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3109 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3111 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3113 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3114 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3117 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3120 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3123 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3125 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3128 video_enc->rc_override=
3129 av_realloc(video_enc->rc_override,
3130 sizeof(RcOverride)*(i+1));
3131 video_enc->rc_override[i].start_frame= start;
3132 video_enc->rc_override[i].end_frame = end;
3134 video_enc->rc_override[i].qscale= q;
3135 video_enc->rc_override[i].quality_factor= 1.0;
3138 video_enc->rc_override[i].qscale= 0;
3139 video_enc->rc_override[i].quality_factor= -q/100.0;
3144 video_enc->rc_override_count=i;
3145 if (!video_enc->rc_initial_buffer_occupancy)
3146 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3147 video_enc->intra_dc_precision= intra_dc_precision - 8;
3152 video_enc->flags |= CODEC_FLAG_PASS1;
3154 video_enc->flags |= CODEC_FLAG_PASS2;
3158 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3159 if (forced_key_frames)
3160 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3162 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3163 ost->force_fps = force_fps;
3165 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3166 ost->top_field_first = top_field_first;
3169 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3171 ost->avfilter = av_strdup(filters);
3178 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3182 AVCodecContext *audio_enc;
3184 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3187 audio_enc = st->codec;
3188 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3190 if (!st->stream_copy) {
3191 char *sample_fmt = NULL;
3193 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3195 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3197 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3198 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3202 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3208 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3213 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3215 if (!st->stream_copy) {
3216 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3223 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3225 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3226 ost->st->stream_copy = 1;
3230 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3234 AVCodecContext *subtitle_enc;
3236 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3238 subtitle_enc = st->codec;
3240 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3245 /* arg format is "output-stream-index:streamid-value". */
3246 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3252 av_strlcpy(idx_str, arg, sizeof(idx_str));
3253 p = strchr(idx_str, ':');
3255 av_log(NULL, AV_LOG_FATAL,
3256 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3261 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3262 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3263 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3267 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3269 AVFormatContext *is = ifile->ctx;
3270 AVFormatContext *os = ofile->ctx;
3273 for (i = 0; i < is->nb_chapters; i++) {
3274 AVChapter *in_ch = is->chapters[i], *out_ch;
3275 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3276 AV_TIME_BASE_Q, in_ch->time_base);
3277 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3278 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3281 if (in_ch->end < ts_off)
3283 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3286 out_ch = av_mallocz(sizeof(AVChapter));
3288 return AVERROR(ENOMEM);
3290 out_ch->id = in_ch->id;
3291 out_ch->time_base = in_ch->time_base;
3292 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3293 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3296 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3299 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3301 return AVERROR(ENOMEM);
3302 os->chapters[os->nb_chapters - 1] = out_ch;
3307 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3310 AVFormatContext *ic = NULL;
3312 err = avformat_open_input(&ic, filename, NULL, NULL);
3315 /* copy stream format */
3316 for(i=0;i<ic->nb_streams;i++) {
3321 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3322 ost = new_output_stream(o, s, codec->type);
3325 // FIXME: a more elegant solution is needed
3326 memcpy(st, ic->streams[i], sizeof(AVStream));
3328 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3330 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3331 choose_sample_fmt(st, codec);
3332 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3333 choose_pixel_fmt(st, codec);
3336 av_close_input_file(ic);
3340 static void opt_output_file(void *optctx, const char *filename)
3342 OptionsContext *o = optctx;
3343 AVFormatContext *oc;
3345 AVOutputFormat *file_oformat;
3349 if (!strcmp(filename, "-"))
3352 oc = avformat_alloc_context();
3354 print_error(filename, AVERROR(ENOMEM));
3359 file_oformat = av_guess_format(o->format, NULL, NULL);
3360 if (!file_oformat) {
3361 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3365 file_oformat = av_guess_format(NULL, filename, NULL);
3366 if (!file_oformat) {
3367 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3373 oc->oformat = file_oformat;
3374 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3376 if (!strcmp(file_oformat->name, "ffm") &&
3377 av_strstart(filename, "http:", NULL)) {
3378 /* special case for files sent to avserver: we get the stream
3379 parameters from avserver */
3380 int err = read_avserver_streams(o, oc, filename);
3382 print_error(filename, err);
3385 } else if (!o->nb_stream_maps) {
3386 /* pick the "best" stream of each type */
3387 #define NEW_STREAM(type, index)\
3389 ost = new_ ## type ## _stream(o, oc);\
3390 ost->source_index = index;\
3391 ost->sync_ist = &input_streams[index];\
3392 input_streams[index].discard = 0;\
3395 /* video: highest resolution */
3396 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3397 int area = 0, idx = -1;
3398 for (i = 0; i < nb_input_streams; i++) {
3399 ist = &input_streams[i];
3400 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3401 ist->st->codec->width * ist->st->codec->height > area) {
3402 area = ist->st->codec->width * ist->st->codec->height;
3406 NEW_STREAM(video, idx);
3409 /* audio: most channels */
3410 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3411 int channels = 0, idx = -1;
3412 for (i = 0; i < nb_input_streams; i++) {
3413 ist = &input_streams[i];
3414 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3415 ist->st->codec->channels > channels) {
3416 channels = ist->st->codec->channels;
3420 NEW_STREAM(audio, idx);
3423 /* subtitles: pick first */
3424 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3425 for (i = 0; i < nb_input_streams; i++)
3426 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3427 NEW_STREAM(subtitle, i);
3431 /* do something with data? */
3433 for (i = 0; i < o->nb_stream_maps; i++) {
3434 StreamMap *map = &o->stream_maps[i];
3439 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3440 switch (ist->st->codec->codec_type) {
3441 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3442 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3443 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3444 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3445 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3447 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3448 map->file_index, map->stream_index);
3452 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3453 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3454 map->sync_stream_index];
3459 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3460 output_files[nb_output_files - 1].ctx = oc;
3461 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3462 output_files[nb_output_files - 1].recording_time = o->recording_time;
3463 output_files[nb_output_files - 1].start_time = o->start_time;
3464 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3465 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3467 /* check filename in case of an image number is expected */
3468 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3469 if (!av_filename_number_test(oc->filename)) {
3470 print_error(oc->filename, AVERROR(EINVAL));
3475 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3476 /* test if it already exists to avoid loosing precious files */
3477 if (!file_overwrite &&
3478 (strchr(filename, ':') == NULL ||
3479 filename[1] == ':' ||
3480 av_strstart(filename, "file:", NULL))) {
3481 if (avio_check(filename, 0) == 0) {
3483 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3485 if (!read_yesno()) {
3486 fprintf(stderr, "Not overwriting - exiting\n");
3491 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3498 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3499 print_error(filename, err);
3504 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3505 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3506 oc->flags |= AVFMT_FLAG_NONBLOCK;
3509 if (o->chapters_input_file >= nb_input_files) {
3510 if (o->chapters_input_file == INT_MAX) {
3511 /* copy chapters from the first input file that has them*/
3512 o->chapters_input_file = -1;
3513 for (i = 0; i < nb_input_files; i++)
3514 if (input_files[i].ctx->nb_chapters) {
3515 o->chapters_input_file = i;
3519 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3520 o->chapters_input_file);
3524 if (o->chapters_input_file >= 0)
3525 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3526 !o->metadata_chapters_manual);
3529 for (i = 0; i < o->nb_meta_data_maps; i++) {
3530 AVFormatContext *files[2];
3531 AVDictionary **meta[2];
3534 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3535 if ((index) < 0 || (index) >= (nb_elems)) {\
3536 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3541 int in_file_index = o->meta_data_maps[i][1].file;
3542 if (in_file_index < 0)
3544 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3547 files[1] = input_files[in_file_index].ctx;
3549 for (j = 0; j < 2; j++) {
3550 MetadataMap *map = &o->meta_data_maps[i][j];
3552 switch (map->type) {
3554 meta[j] = &files[j]->metadata;
3557 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3558 meta[j] = &files[j]->streams[map->index]->metadata;
3561 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3562 meta[j] = &files[j]->chapters[map->index]->metadata;
3565 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3566 meta[j] = &files[j]->programs[map->index]->metadata;
3571 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3574 /* copy global metadata by default */
3575 if (!o->metadata_global_manual && nb_input_files)
3576 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3577 AV_DICT_DONT_OVERWRITE);
3578 if (!o->metadata_streams_manual)
3579 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3580 InputStream *ist = &input_streams[output_streams[i].source_index];
3581 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3584 /* process manually set metadata */
3585 for (i = 0; i < o->nb_metadata; i++) {
3590 val = strchr(o->metadata[i].u.str, '=');
3592 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3593 o->metadata[i].u.str);
3598 parse_meta_type(o->metadata[i].specifier, &type, &index);
3604 if (index < 0 || index >= oc->nb_streams) {
3605 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3608 m = &oc->streams[index]->metadata;
3611 if (index < 0 || index >= oc->nb_chapters) {
3612 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3615 m = &oc->chapters[index]->metadata;
3618 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3622 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3628 /* same option as mencoder */
3629 static int opt_pass(const char *opt, const char *arg)
3631 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3635 static int64_t getutime(void)
3638 struct rusage rusage;
3640 getrusage(RUSAGE_SELF, &rusage);
3641 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3642 #elif HAVE_GETPROCESSTIMES
3644 FILETIME c, e, k, u;
3645 proc = GetCurrentProcess();
3646 GetProcessTimes(proc, &c, &e, &k, &u);
3647 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3649 return av_gettime();
3653 static int64_t getmaxrss(void)
3655 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3656 struct rusage rusage;
3657 getrusage(RUSAGE_SELF, &rusage);
3658 return (int64_t)rusage.ru_maxrss * 1024;
3659 #elif HAVE_GETPROCESSMEMORYINFO
3661 PROCESS_MEMORY_COUNTERS memcounters;
3662 proc = GetCurrentProcess();
3663 memcounters.cb = sizeof(memcounters);
3664 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3665 return memcounters.PeakPagefileUsage;
3671 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3673 return parse_option(o, "q:a", arg, options);
3676 static void show_usage(void)
3678 printf("Hyper fast Audio and Video encoder\n");
3679 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3683 static void show_help(void)
3686 AVOutputFormat *oformat = NULL;
3687 AVInputFormat *iformat = NULL;
3688 const AVClass *class;
3690 av_log_set_callback(log_callback_help);
3692 show_help_options(options, "Main options:\n",
3693 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3694 show_help_options(options, "\nAdvanced options:\n",
3695 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3697 show_help_options(options, "\nVideo options:\n",
3698 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3700 show_help_options(options, "\nAdvanced Video options:\n",
3701 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3702 OPT_VIDEO | OPT_EXPERT);
3703 show_help_options(options, "\nAudio options:\n",
3704 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3706 show_help_options(options, "\nAdvanced Audio options:\n",
3707 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3708 OPT_AUDIO | OPT_EXPERT);
3709 show_help_options(options, "\nSubtitle options:\n",
3710 OPT_SUBTITLE | OPT_GRAB,
3712 show_help_options(options, "\nAudio/Video grab options:\n",
3716 class = avcodec_get_class();
3717 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3720 /* individual codec options */
3722 while ((c = av_codec_next(c))) {
3723 if (c->priv_class) {
3724 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3729 class = avformat_get_class();
3730 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3733 /* individual muxer options */
3734 while ((oformat = av_oformat_next(oformat))) {
3735 if (oformat->priv_class) {
3736 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3741 /* individual demuxer options */
3742 while ((iformat = av_iformat_next(iformat))) {
3743 if (iformat->priv_class) {
3744 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3749 class = sws_get_class();
3750 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3753 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3755 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3756 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3758 if(!strncmp(arg, "pal-", 4)) {
3761 } else if(!strncmp(arg, "ntsc-", 5)) {
3764 } else if(!strncmp(arg, "film-", 5)) {
3768 /* Try to determine PAL/NTSC by peeking in the input files */
3769 if(nb_input_files) {
3771 for (j = 0; j < nb_input_files; j++) {
3772 for (i = 0; i < input_files[j].nb_streams; i++) {
3773 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3774 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3776 fr = c->time_base.den * 1000 / c->time_base.num;
3780 } else if((fr == 29970) || (fr == 23976)) {
3789 if (norm != UNKNOWN)
3790 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3793 if(norm == UNKNOWN) {
3794 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3795 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3796 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3800 if(!strcmp(arg, "vcd")) {
3801 opt_video_codec(o, "c:v", "mpeg1video");
3802 opt_audio_codec(o, "c:a", "mp2");
3803 parse_option(o, "f", "vcd", options);
3805 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3806 parse_option(o, "r", frame_rates[norm], options);
3807 opt_default("g", norm == PAL ? "15" : "18");
3809 opt_default("b", "1150000");
3810 opt_default("maxrate", "1150000");
3811 opt_default("minrate", "1150000");
3812 opt_default("bufsize", "327680"); // 40*1024*8;
3814 opt_default("b:a", "224000");
3815 parse_option(o, "ar", "44100", options);
3816 parse_option(o, "ac", "2", options);
3818 opt_default("packetsize", "2324");
3819 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3821 /* We have to offset the PTS, so that it is consistent with the SCR.
3822 SCR starts at 36000, but the first two packs contain only padding
3823 and the first pack from the other stream, respectively, may also have
3824 been written before.
3825 So the real data starts at SCR 36000+3*1200. */
3826 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3827 } else if(!strcmp(arg, "svcd")) {
3829 opt_video_codec(o, "c:v", "mpeg2video");
3830 opt_audio_codec(o, "c:a", "mp2");
3831 parse_option(o, "f", "svcd", options);
3833 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3834 parse_option(o, "r", frame_rates[norm], options);
3835 opt_default("g", norm == PAL ? "15" : "18");
3837 opt_default("b", "2040000");
3838 opt_default("maxrate", "2516000");
3839 opt_default("minrate", "0"); //1145000;
3840 opt_default("bufsize", "1835008"); //224*1024*8;
3841 opt_default("flags", "+scan_offset");
3844 opt_default("b:a", "224000");
3845 parse_option(o, "ar", "44100", options);
3847 opt_default("packetsize", "2324");
3849 } else if(!strcmp(arg, "dvd")) {
3851 opt_video_codec(o, "c:v", "mpeg2video");
3852 opt_audio_codec(o, "c:a", "ac3");
3853 parse_option(o, "f", "dvd", options);
3855 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3856 parse_option(o, "r", frame_rates[norm], options);
3857 opt_default("g", norm == PAL ? "15" : "18");
3859 opt_default("b", "6000000");
3860 opt_default("maxrate", "9000000");
3861 opt_default("minrate", "0"); //1500000;
3862 opt_default("bufsize", "1835008"); //224*1024*8;
3864 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3865 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3867 opt_default("b:a", "448000");
3868 parse_option(o, "ar", "48000", options);
3870 } else if(!strncmp(arg, "dv", 2)) {
3872 parse_option(o, "f", "dv", options);
3874 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3875 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3876 norm == PAL ? "yuv420p" : "yuv411p", options);
3877 parse_option(o, "r", frame_rates[norm], options);
3879 parse_option(o, "ar", "48000", options);
3880 parse_option(o, "ac", "2", options);
3883 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
3884 return AVERROR(EINVAL);
3889 static int opt_vstats_file(const char *opt, const char *arg)
3891 av_free (vstats_filename);
3892 vstats_filename=av_strdup (arg);
3896 static int opt_vstats(const char *opt, const char *arg)
3899 time_t today2 = time(NULL);
3900 struct tm *today = localtime(&today2);
3902 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3904 return opt_vstats_file(opt, filename);
3907 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
3909 return parse_option(o, "frames:v", arg, options);
3912 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
3914 return parse_option(o, "frames:a", arg, options);
3917 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
3919 return parse_option(o, "frames:d", arg, options);
3922 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
3924 return parse_option(o, "tag:v", arg, options);
3927 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
3929 return parse_option(o, "tag:a", arg, options);
3932 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
3934 return parse_option(o, "tag:s", arg, options);
3937 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
3939 return parse_option(o, "filter:v", arg, options);
3942 #define OFFSET(x) offsetof(OptionsContext, x)
3943 static const OptionDef options[] = {
3945 #include "cmdutils_common_opts.h"
3946 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
3947 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
3948 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3949 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3950 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3951 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
3952 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
3953 "outfile[,metadata]:infile[,metadata]" },
3954 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
3955 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3956 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
3957 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
3958 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
3959 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
3960 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
3961 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
3962 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3963 "add timings for benchmarking" },
3964 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3965 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3966 "dump each input packet" },
3967 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3968 "when dumping packets, also dump the payload" },
3969 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
3970 { "v", HAS_ARG, {(void*)opt_verbose}, "deprecated, use -loglevel instead", "number" },
3971 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3972 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3973 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3974 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3975 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3976 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
3977 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3978 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3979 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3980 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3981 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
3982 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
3983 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
3984 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
3986 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
3988 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
3991 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
3992 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3993 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
3994 { "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" },
3995 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
3996 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
3997 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3998 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
3999 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4000 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4001 "use same quantizer as source (implies VBR)" },
4002 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4003 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4004 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4005 "deinterlace pictures" },
4006 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4007 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4009 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4011 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4012 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4013 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4014 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4015 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4016 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4017 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4018 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4019 { "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" },
4022 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4023 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4024 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4025 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4026 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4027 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4028 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4029 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4030 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4032 /* subtitle options */
4033 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4034 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4035 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4038 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4041 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4042 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4044 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4046 /* data codec support */
4047 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4049 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4053 int main(int argc, char **argv)
4055 OptionsContext o = { 0 };
4060 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4061 parse_loglevel(argc, argv, options);
4063 avcodec_register_all();
4065 avdevice_register_all();
4068 avfilter_register_all();
4072 avio_set_interrupt_cb(decode_interrupt_cb);
4077 parse_options(&o, argc, argv, options, opt_output_file);
4079 if(nb_output_files <= 0 && nb_input_files == 0) {
4081 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4085 /* file converter / grab */
4086 if (nb_output_files <= 0) {
4087 fprintf(stderr, "At least one output file must be specified\n");
4091 if (nb_input_files == 0) {
4092 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4097 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4099 ti = getutime() - ti;
4101 int maxrss = getmaxrss() / 1024;
4102 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);