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 uint8_t *audio_buf;
136 static uint8_t *audio_out;
137 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
139 static void *samples;
141 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
143 typedef struct InputStream {
146 int discard; /* true if stream data should be discarded */
147 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
150 int64_t start; /* time when read started */
151 int64_t next_pts; /* synthetic pts for cases where pkt.pts
153 int64_t pts; /* current pts */
154 PtsCorrectionContext pts_ctx;
156 int is_start; /* is 1 at the start and after a discontinuity */
157 int showed_multi_packet_warning;
161 typedef struct InputFile {
162 AVFormatContext *ctx;
163 int eof_reached; /* true if eof reached */
164 int ist_index; /* index of first stream in ist_table */
165 int buffer_size; /* current total buffer size */
167 int nb_streams; /* number of stream that avconv is aware of; may be different
168 from ctx.nb_streams if new streams appear during av_read_frame() */
172 typedef struct OutputStream {
173 int file_index; /* file index */
174 int index; /* stream index in the output file */
175 int source_index; /* InputStream index */
176 AVStream *st; /* stream in the output file */
177 int encoding_needed; /* true if encoding needed for this stream */
179 /* input pts and corresponding output pts
181 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
182 struct InputStream *sync_ist; /* input stream to sync against */
183 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
184 AVBitStreamFilterContext *bitstream_filters;
190 AVFrame pict_tmp; /* temporary image for resampling */
191 struct SwsContext *img_resample_ctx; /* for image resampling */
194 int resample_pix_fmt;
195 AVRational frame_rate;
199 float frame_aspect_ratio;
201 /* forced key frames */
202 int64_t *forced_kf_pts;
208 ReSampleContext *resample; /* for audio resampling */
209 int resample_sample_fmt;
210 int resample_channels;
211 int resample_sample_rate;
213 AVAudioConvert *reformat_ctx;
214 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
218 AVFilterContext *output_video_filter;
219 AVFilterContext *input_video_filter;
220 AVFilterBufferRef *picref;
222 AVFilterGraph *graph;
227 int is_past_recording_time;
231 typedef struct OutputFile {
232 AVFormatContext *ctx;
234 int ost_index; /* index of the first stream in output_streams */
235 int64_t recording_time; /* desired length of the resulting file in microseconds */
236 int64_t start_time; /* start time in microseconds */
237 uint64_t limit_filesize;
240 static InputStream *input_streams = NULL;
241 static int nb_input_streams = 0;
242 static InputFile *input_files = NULL;
243 static int nb_input_files = 0;
245 static OutputStream *output_streams = NULL;
246 static int nb_output_streams = 0;
247 static OutputFile *output_files = NULL;
248 static int nb_output_files = 0;
250 typedef struct OptionsContext {
251 /* input/output options */
255 SpecifierOpt *codec_names;
257 SpecifierOpt *audio_channels;
258 int nb_audio_channels;
259 SpecifierOpt *audio_sample_rate;
260 int nb_audio_sample_rate;
261 SpecifierOpt *frame_rates;
263 SpecifierOpt *frame_sizes;
265 SpecifierOpt *frame_pix_fmts;
266 int nb_frame_pix_fmts;
269 int64_t input_ts_offset;
272 SpecifierOpt *ts_scale;
276 StreamMap *stream_maps;
278 /* first item specifies output metadata, second is input */
279 MetadataMap (*meta_data_maps)[2];
280 int nb_meta_data_maps;
281 int metadata_global_manual;
282 int metadata_streams_manual;
283 int metadata_chapters_manual;
285 int chapters_input_file;
287 int64_t recording_time;
288 uint64_t limit_filesize;
294 int subtitle_disable;
297 /* indexed by output file stream index */
301 SpecifierOpt *metadata;
303 SpecifierOpt *max_frames;
305 SpecifierOpt *bitstream_filters;
306 int nb_bitstream_filters;
307 SpecifierOpt *codec_tags;
309 SpecifierOpt *sample_fmts;
311 SpecifierOpt *qscale;
313 SpecifierOpt *forced_key_frames;
314 int nb_forced_key_frames;
315 SpecifierOpt *force_fps;
317 SpecifierOpt *frame_aspect_ratios;
318 int nb_frame_aspect_ratios;
319 SpecifierOpt *rc_overrides;
321 SpecifierOpt *intra_matrices;
322 int nb_intra_matrices;
323 SpecifierOpt *inter_matrices;
324 int nb_inter_matrices;
325 SpecifierOpt *top_field_first;
326 int nb_top_field_first;
328 SpecifierOpt *filters;
333 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
336 for (i = 0; i < o->nb_ ## name; i++) {\
337 char *spec = o->name[i].specifier;\
338 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
339 outvar = o->name[i].u.type;\
345 static void reset_options(OptionsContext *o)
347 const OptionDef *po = options;
349 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
351 void *dst = (uint8_t*)o + po->u.off;
353 if (po->flags & OPT_SPEC) {
354 SpecifierOpt **so = dst;
355 int i, *count = (int*)(so + 1);
356 for (i = 0; i < *count; i++) {
357 av_freep(&(*so)[i].specifier);
358 if (po->flags & OPT_STRING)
359 av_freep(&(*so)[i].u.str);
363 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
368 av_freep(&o->stream_maps);
369 av_freep(&o->meta_data_maps);
370 av_freep(&o->streamid_map);
372 memset(o, 0, sizeof(*o));
374 o->mux_preload = 0.5;
375 o->mux_max_delay = 0.7;
376 o->recording_time = INT64_MAX;
377 o->limit_filesize = UINT64_MAX;
378 o->chapters_input_file = INT_MAX;
386 static int configure_video_filters(InputStream *ist, OutputStream *ost)
388 AVFilterContext *last_filter, *filter;
389 /** filter graph containing all filters including input & output */
390 AVCodecContext *codec = ost->st->codec;
391 AVCodecContext *icodec = ist->st->codec;
392 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
393 AVRational sample_aspect_ratio;
397 ost->graph = avfilter_graph_alloc();
399 if (ist->st->sample_aspect_ratio.num){
400 sample_aspect_ratio = ist->st->sample_aspect_ratio;
402 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
404 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
405 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
406 sample_aspect_ratio.num, sample_aspect_ratio.den);
408 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
409 "src", args, NULL, ost->graph);
412 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
413 "out", NULL, &ffsink_ctx, ost->graph);
416 last_filter = ost->input_video_filter;
418 if (codec->width != icodec->width || codec->height != icodec->height) {
419 snprintf(args, 255, "%d:%d:flags=0x%X",
423 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
424 NULL, args, NULL, ost->graph)) < 0)
426 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
428 last_filter = filter;
431 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
432 ost->graph->scale_sws_opts = av_strdup(args);
435 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
436 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
438 outputs->name = av_strdup("in");
439 outputs->filter_ctx = last_filter;
440 outputs->pad_idx = 0;
441 outputs->next = NULL;
443 inputs->name = av_strdup("out");
444 inputs->filter_ctx = ost->output_video_filter;
448 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
450 av_freep(&ost->avfilter);
452 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
456 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
459 codec->width = ost->output_video_filter->inputs[0]->w;
460 codec->height = ost->output_video_filter->inputs[0]->h;
461 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
462 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
463 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
464 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
468 #endif /* CONFIG_AVFILTER */
470 static void term_exit(void)
472 av_log(NULL, AV_LOG_QUIET, "");
475 static volatile int received_sigterm = 0;
476 static volatile int received_nb_signals = 0;
479 sigterm_handler(int sig)
481 received_sigterm = sig;
482 received_nb_signals++;
486 static void term_init(void)
488 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
489 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
491 signal(SIGXCPU, sigterm_handler);
495 static int decode_interrupt_cb(void)
497 return received_nb_signals > 1;
500 void exit_program(int ret)
505 for(i=0;i<nb_output_files;i++) {
506 AVFormatContext *s = output_files[i].ctx;
507 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
509 avformat_free_context(s);
510 av_dict_free(&output_files[i].opts);
512 for(i=0;i<nb_input_files;i++) {
513 av_close_input_file(input_files[i].ctx);
515 for (i = 0; i < nb_input_streams; i++)
516 av_dict_free(&input_streams[i].opts);
520 av_free(vstats_filename);
522 av_freep(&input_streams);
523 av_freep(&input_files);
524 av_freep(&output_streams);
525 av_freep(&output_files);
530 allocated_audio_buf_size= allocated_audio_out_size= 0;
537 if (received_sigterm) {
538 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
539 (int) received_sigterm);
543 exit(ret); /* not all OS-es handle main() return value */
546 static void assert_avoptions(AVDictionary *m)
548 AVDictionaryEntry *t;
549 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
550 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
555 static void assert_codec_experimental(AVCodecContext *c, int encoder)
557 const char *codec_string = encoder ? "encoder" : "decoder";
559 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
560 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
561 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
562 "results.\nAdd '-strict experimental' if you want to use it.\n",
563 codec_string, c->codec->name);
564 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
565 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
566 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
567 codec_string, codec->name);
572 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
574 if(codec && codec->sample_fmts){
575 const enum AVSampleFormat *p= codec->sample_fmts;
577 if(*p == st->codec->sample_fmt)
581 av_log(NULL, AV_LOG_WARNING,
582 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
583 av_get_sample_fmt_name(st->codec->sample_fmt),
585 av_get_sample_fmt_name(codec->sample_fmts[0]));
586 st->codec->sample_fmt = codec->sample_fmts[0];
592 * Update the requested input sample format based on the output sample format.
593 * This is currently only used to request float output from decoders which
594 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
595 * Ideally this will be removed in the future when decoders do not do format
596 * conversion and only output in their native format.
598 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
601 /* if sample formats match or a decoder sample format has already been
602 requested, just return */
603 if (enc->sample_fmt == dec->sample_fmt ||
604 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
607 /* if decoder supports more than one output format */
608 if (dec_codec && dec_codec->sample_fmts &&
609 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
610 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
611 const enum AVSampleFormat *p;
612 int min_dec = -1, min_inc = -1;
614 /* find a matching sample format in the encoder */
615 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
616 if (*p == enc->sample_fmt) {
617 dec->request_sample_fmt = *p;
619 } else if (*p > enc->sample_fmt) {
620 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
622 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
625 /* if none match, provide the one that matches quality closest */
626 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
627 enc->sample_fmt - min_dec;
631 static void choose_sample_rate(AVStream *st, AVCodec *codec)
633 if(codec && codec->supported_samplerates){
634 const int *p= codec->supported_samplerates;
636 int best_dist=INT_MAX;
638 int dist= abs(st->codec->sample_rate - *p);
639 if(dist < best_dist){
645 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
647 st->codec->sample_rate= best;
651 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
653 if(codec && codec->pix_fmts){
654 const enum PixelFormat *p= codec->pix_fmts;
655 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
656 if(st->codec->codec_id==CODEC_ID_MJPEG){
657 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
658 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
659 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};
663 if(*p == st->codec->pix_fmt)
667 if(st->codec->pix_fmt != PIX_FMT_NONE)
668 av_log(NULL, AV_LOG_WARNING,
669 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
670 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
672 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
673 st->codec->pix_fmt = codec->pix_fmts[0];
679 get_sync_ipts(const OutputStream *ost)
681 const InputStream *ist = ost->sync_ist;
682 OutputFile *of = &output_files[ost->file_index];
683 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
686 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
690 AVPacket new_pkt= *pkt;
691 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
692 &new_pkt.data, &new_pkt.size,
693 pkt->data, pkt->size,
694 pkt->flags & AV_PKT_FLAG_KEY);
697 new_pkt.destruct= av_destruct_packet;
699 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
700 bsfc->filter->name, pkt->stream_index,
701 avctx->codec ? avctx->codec->name : "copy");
711 ret= av_interleaved_write_frame(s, pkt);
713 print_error("av_interleaved_write_frame()", ret);
718 static void do_audio_out(AVFormatContext *s,
721 unsigned char *buf, int size)
724 int64_t audio_out_size, audio_buf_size;
725 int64_t allocated_for_size= size;
727 int size_out, frame_bytes, ret, resample_changed;
728 AVCodecContext *enc= ost->st->codec;
729 AVCodecContext *dec= ist->st->codec;
730 int osize = av_get_bytes_per_sample(enc->sample_fmt);
731 int isize = av_get_bytes_per_sample(dec->sample_fmt);
732 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
735 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
736 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
737 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
738 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
739 audio_buf_size*= osize*enc->channels;
741 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
742 if(coded_bps > 8*osize)
743 audio_out_size= audio_out_size * coded_bps / (8*osize);
744 audio_out_size += FF_MIN_BUFFER_SIZE;
746 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
747 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
751 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
752 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
753 if (!audio_buf || !audio_out){
754 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
758 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
759 ost->audio_resample = 1;
761 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
762 ost->resample_channels != dec->channels ||
763 ost->resample_sample_rate != dec->sample_rate;
765 if ((ost->audio_resample && !ost->resample) || resample_changed) {
766 if (resample_changed) {
767 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",
768 ist->file_index, ist->st->index,
769 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
770 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
771 ost->resample_sample_fmt = dec->sample_fmt;
772 ost->resample_channels = dec->channels;
773 ost->resample_sample_rate = dec->sample_rate;
775 audio_resample_close(ost->resample);
777 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
778 if (audio_sync_method <= 1 &&
779 ost->resample_sample_fmt == enc->sample_fmt &&
780 ost->resample_channels == enc->channels &&
781 ost->resample_sample_rate == enc->sample_rate) {
782 ost->resample = NULL;
783 ost->audio_resample = 0;
784 } else if (ost->audio_resample) {
785 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
786 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
787 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
788 enc->sample_rate, dec->sample_rate,
789 enc->sample_fmt, dec->sample_fmt,
791 if (!ost->resample) {
792 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
793 dec->channels, dec->sample_rate,
794 enc->channels, enc->sample_rate);
800 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
801 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
802 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
803 if (ost->reformat_ctx)
804 av_audio_convert_free(ost->reformat_ctx);
805 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
806 dec->sample_fmt, 1, NULL, 0);
807 if (!ost->reformat_ctx) {
808 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
809 av_get_sample_fmt_name(dec->sample_fmt),
810 av_get_sample_fmt_name(enc->sample_fmt));
813 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
816 if(audio_sync_method){
817 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
818 - av_fifo_size(ost->fifo)/(enc->channels * 2);
819 double idelta= delta*dec->sample_rate / enc->sample_rate;
820 int byte_delta= ((int)idelta)*2*dec->channels;
822 //FIXME resample delay
823 if(fabs(delta) > 50){
824 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
826 byte_delta= FFMAX(byte_delta, -size);
829 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
834 static uint8_t *input_tmp= NULL;
835 input_tmp= av_realloc(input_tmp, byte_delta + size);
837 if(byte_delta > allocated_for_size - size){
838 allocated_for_size= byte_delta + (int64_t)size;
843 memset(input_tmp, 0, byte_delta);
844 memcpy(input_tmp + byte_delta, buf, size);
847 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
849 }else if(audio_sync_method>1){
850 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
851 av_assert0(ost->audio_resample);
852 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
853 delta, comp, enc->sample_rate);
854 // 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));
855 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
859 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
860 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
862 if (ost->audio_resample) {
864 size_out = audio_resample(ost->resample,
865 (short *)buftmp, (short *)buf,
866 size / (dec->channels * isize));
867 size_out = size_out * enc->channels * osize;
873 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
874 const void *ibuf[6]= {buftmp};
875 void *obuf[6]= {audio_buf};
876 int istride[6]= {isize};
877 int ostride[6]= {osize};
878 int len= size_out/istride[0];
879 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
880 printf("av_audio_convert() failed\n");
886 size_out = len*osize;
889 /* now encode as many frames as possible */
890 if (enc->frame_size > 1) {
891 /* output resampled raw samples */
892 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
893 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
896 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
898 frame_bytes = enc->frame_size * osize * enc->channels;
900 while (av_fifo_size(ost->fifo) >= frame_bytes) {
902 av_init_packet(&pkt);
904 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
906 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
908 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
911 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
915 pkt.stream_index= ost->index;
918 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
919 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
920 pkt.flags |= AV_PKT_FLAG_KEY;
921 write_frame(s, &pkt, enc, ost->bitstream_filters);
923 ost->sync_opts += enc->frame_size;
927 av_init_packet(&pkt);
929 ost->sync_opts += size_out / (osize * enc->channels);
931 /* output a pcm frame */
932 /* determine the size of the coded buffer */
935 size_out = size_out*coded_bps/8;
937 if(size_out > audio_out_size){
938 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
942 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
943 ret = avcodec_encode_audio(enc, audio_out, size_out,
946 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
950 pkt.stream_index= ost->index;
953 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
954 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
955 pkt.flags |= AV_PKT_FLAG_KEY;
956 write_frame(s, &pkt, enc, ost->bitstream_filters);
960 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
964 AVPicture picture_tmp;
967 dec = ist->st->codec;
969 /* deinterlace : must be done before any resize */
970 if (do_deinterlace) {
973 /* create temporary picture */
974 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
975 buf = av_malloc(size);
979 picture2 = &picture_tmp;
980 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
982 if(avpicture_deinterlace(picture2, picture,
983 dec->pix_fmt, dec->width, dec->height) < 0) {
984 /* if error, do not deinterlace */
985 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
994 if (picture != picture2)
995 *picture = *picture2;
999 static void do_subtitle_out(AVFormatContext *s,
1005 static uint8_t *subtitle_out = NULL;
1006 int subtitle_out_max_size = 1024 * 1024;
1007 int subtitle_out_size, nb, i;
1008 AVCodecContext *enc;
1011 if (pts == AV_NOPTS_VALUE) {
1012 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1018 enc = ost->st->codec;
1020 if (!subtitle_out) {
1021 subtitle_out = av_malloc(subtitle_out_max_size);
1024 /* Note: DVB subtitle need one packet to draw them and one other
1025 packet to clear them */
1026 /* XXX: signal it in the codec context ? */
1027 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1032 for(i = 0; i < nb; i++) {
1033 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1034 // start_display_time is required to be 0
1035 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1036 sub->end_display_time -= sub->start_display_time;
1037 sub->start_display_time = 0;
1038 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1039 subtitle_out_max_size, sub);
1040 if (subtitle_out_size < 0) {
1041 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1045 av_init_packet(&pkt);
1046 pkt.stream_index = ost->index;
1047 pkt.data = subtitle_out;
1048 pkt.size = subtitle_out_size;
1049 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1050 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1051 /* XXX: the pts correction is handled here. Maybe handling
1052 it in the codec would be better */
1054 pkt.pts += 90 * sub->start_display_time;
1056 pkt.pts += 90 * sub->end_display_time;
1058 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1062 static int bit_buffer_size= 1024*256;
1063 static uint8_t *bit_buffer= NULL;
1065 static void do_video_resample(OutputStream *ost,
1067 AVFrame *in_picture,
1068 AVFrame **out_picture)
1070 int resample_changed = 0;
1071 AVCodecContext *dec = ist->st->codec;
1072 *out_picture = in_picture;
1074 resample_changed = ost->resample_width != dec->width ||
1075 ost->resample_height != dec->height ||
1076 ost->resample_pix_fmt != dec->pix_fmt;
1078 if (resample_changed) {
1079 av_log(NULL, AV_LOG_INFO,
1080 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1081 ist->file_index, ist->st->index,
1082 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1083 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1084 if(!ost->video_resample)
1085 ost->video_resample = 1;
1088 #if !CONFIG_AVFILTER
1089 if (ost->video_resample) {
1090 *out_picture = &ost->pict_tmp;
1091 if (resample_changed) {
1092 /* initialize a new scaler context */
1093 sws_freeContext(ost->img_resample_ctx);
1094 ost->img_resample_ctx = sws_getContext(
1095 ist->st->codec->width,
1096 ist->st->codec->height,
1097 ist->st->codec->pix_fmt,
1098 ost->st->codec->width,
1099 ost->st->codec->height,
1100 ost->st->codec->pix_fmt,
1101 ost->sws_flags, NULL, NULL, NULL);
1102 if (ost->img_resample_ctx == NULL) {
1103 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1107 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1108 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1111 if (resample_changed) {
1112 avfilter_graph_free(&ost->graph);
1113 if (configure_video_filters(ist, ost)) {
1114 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1119 if (resample_changed) {
1120 ost->resample_width = dec->width;
1121 ost->resample_height = dec->height;
1122 ost->resample_pix_fmt = dec->pix_fmt;
1127 static void do_video_out(AVFormatContext *s,
1130 AVFrame *in_picture,
1131 int *frame_size, float quality)
1133 int nb_frames, i, ret, format_video_sync;
1134 AVFrame *final_picture;
1135 AVCodecContext *enc;
1138 enc = ost->st->codec;
1140 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1142 /* by default, we output a single frame */
1147 format_video_sync = video_sync_method;
1148 if (format_video_sync < 0)
1149 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1151 if (format_video_sync) {
1152 double vdelta = sync_ipts - ost->sync_opts;
1153 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1156 else if (format_video_sync == 2) {
1159 }else if(vdelta>0.6)
1160 ost->sync_opts= lrintf(sync_ipts);
1161 }else if (vdelta > 1.1)
1162 nb_frames = lrintf(vdelta);
1163 //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);
1164 if (nb_frames == 0){
1166 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1167 }else if (nb_frames > 1) {
1168 nb_frames_dup += nb_frames - 1;
1169 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1172 ost->sync_opts= lrintf(sync_ipts);
1174 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1178 do_video_resample(ost, ist, in_picture, &final_picture);
1180 /* duplicates frame if needed */
1181 for(i=0;i<nb_frames;i++) {
1183 av_init_packet(&pkt);
1184 pkt.stream_index= ost->index;
1186 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1187 /* raw pictures are written as AVPicture structure to
1188 avoid any copies. We support temporarily the older
1190 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1191 enc->coded_frame->top_field_first = in_picture->top_field_first;
1192 pkt.data= (uint8_t *)final_picture;
1193 pkt.size= sizeof(AVPicture);
1194 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1195 pkt.flags |= AV_PKT_FLAG_KEY;
1197 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1199 AVFrame big_picture;
1201 big_picture= *final_picture;
1202 /* better than nothing: use input picture interlaced
1204 big_picture.interlaced_frame = in_picture->interlaced_frame;
1205 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1206 if (ost->top_field_first == -1)
1207 big_picture.top_field_first = in_picture->top_field_first;
1209 big_picture.top_field_first = !!ost->top_field_first;
1212 /* handles same_quant here. This is not correct because it may
1213 not be a global option */
1214 big_picture.quality = quality;
1215 if (!enc->me_threshold)
1216 big_picture.pict_type = 0;
1217 // big_picture.pts = AV_NOPTS_VALUE;
1218 big_picture.pts= ost->sync_opts;
1219 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1220 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1221 if (ost->forced_kf_index < ost->forced_kf_count &&
1222 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1223 big_picture.pict_type = AV_PICTURE_TYPE_I;
1224 ost->forced_kf_index++;
1226 ret = avcodec_encode_video(enc,
1227 bit_buffer, bit_buffer_size,
1230 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1235 pkt.data= bit_buffer;
1237 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1238 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1239 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1240 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1241 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1243 if(enc->coded_frame->key_frame)
1244 pkt.flags |= AV_PKT_FLAG_KEY;
1245 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1248 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1249 // enc->frame_number-1, ret, enc->pict_type);
1250 /* if two pass, output log */
1251 if (ost->logfile && enc->stats_out) {
1252 fprintf(ost->logfile, "%s", enc->stats_out);
1257 ost->frame_number++;
1261 static double psnr(double d){
1262 return -10.0*log(d)/log(10.0);
1265 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1268 AVCodecContext *enc;
1270 double ti1, bitrate, avg_bitrate;
1272 /* this is executed just the first time do_video_stats is called */
1274 vstats_file = fopen(vstats_filename, "w");
1281 enc = ost->st->codec;
1282 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1283 frame_number = ost->frame_number;
1284 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1285 if (enc->flags&CODEC_FLAG_PSNR)
1286 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1288 fprintf(vstats_file,"f_size= %6d ", frame_size);
1289 /* compute pts value */
1290 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1294 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1295 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1296 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1297 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1298 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1302 static void print_report(OutputFile *output_files,
1303 OutputStream *ost_table, int nb_ostreams,
1304 int is_last_report, int64_t timer_start)
1308 AVFormatContext *oc;
1310 AVCodecContext *enc;
1311 int frame_number, vid, i;
1312 double bitrate, ti1, pts;
1313 static int64_t last_time = -1;
1314 static int qp_histogram[52];
1316 if (!is_last_report) {
1318 /* display the report every 0.5 seconds */
1319 cur_time = av_gettime();
1320 if (last_time == -1) {
1321 last_time = cur_time;
1324 if ((cur_time - last_time) < 500000)
1326 last_time = cur_time;
1330 oc = output_files[0].ctx;
1332 total_size = avio_size(oc->pb);
1333 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1334 total_size= avio_tell(oc->pb);
1339 for(i=0;i<nb_ostreams;i++) {
1341 ost = &ost_table[i];
1342 enc = ost->st->codec;
1343 if (!ost->st->stream_copy && enc->coded_frame)
1344 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1345 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1346 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1348 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1349 float t = (av_gettime()-timer_start) / 1000000.0;
1351 frame_number = ost->frame_number;
1352 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1353 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1355 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1359 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1362 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1364 if (enc->flags&CODEC_FLAG_PSNR){
1366 double error, error_sum=0;
1367 double scale, scale_sum=0;
1368 char type[3]= {'Y','U','V'};
1369 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1372 error= enc->error[j];
1373 scale= enc->width*enc->height*255.0*255.0*frame_number;
1375 error= enc->coded_frame->error[j];
1376 scale= enc->width*enc->height*255.0*255.0;
1381 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1383 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1387 /* compute min output value */
1388 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1389 if ((pts < ti1) && (pts > 0))
1395 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1397 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1398 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1399 (double)total_size / 1024, ti1, bitrate);
1401 if (nb_frames_dup || nb_frames_drop)
1402 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1403 nb_frames_dup, nb_frames_drop);
1405 av_log(NULL, is_last_report ? AV_LOG_WARNING : AV_LOG_INFO, "%s \r", buf);
1409 if (is_last_report) {
1410 int64_t raw= audio_size + video_size + extra_size;
1411 av_log(NULL, AV_LOG_INFO, "\n");
1412 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1416 100.0*(total_size - raw)/raw
1421 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1423 int fill_char = 0x00;
1424 if (sample_fmt == AV_SAMPLE_FMT_U8)
1426 memset(buf, fill_char, size);
1429 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1433 for (i = 0; i < nb_ostreams; i++) {
1434 OutputStream *ost = &ost_table[i];
1435 AVCodecContext *enc = ost->st->codec;
1436 AVFormatContext *os = output_files[ost->file_index].ctx;
1438 if (!ost->encoding_needed)
1441 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1443 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1449 av_init_packet(&pkt);
1450 pkt.stream_index= ost->index;
1452 switch (ost->st->codec->codec_type) {
1453 case AVMEDIA_TYPE_AUDIO:
1454 fifo_bytes = av_fifo_size(ost->fifo);
1456 /* encode any samples remaining in fifo */
1457 if (fifo_bytes > 0) {
1458 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1459 int fs_tmp = enc->frame_size;
1461 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1462 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1463 enc->frame_size = fifo_bytes / (osize * enc->channels);
1465 int frame_bytes = enc->frame_size*osize*enc->channels;
1466 if (allocated_audio_buf_size < frame_bytes)
1468 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1471 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1472 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1473 ost->st->time_base.num, enc->sample_rate);
1474 enc->frame_size = fs_tmp;
1477 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1480 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1484 pkt.flags |= AV_PKT_FLAG_KEY;
1486 case AVMEDIA_TYPE_VIDEO:
1487 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1489 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1493 if(enc->coded_frame && enc->coded_frame->key_frame)
1494 pkt.flags |= AV_PKT_FLAG_KEY;
1495 if (ost->logfile && enc->stats_out) {
1496 fprintf(ost->logfile, "%s", enc->stats_out);
1505 pkt.data = bit_buffer;
1507 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1508 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1509 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1514 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1515 static int output_packet(InputStream *ist, int ist_index,
1516 OutputStream *ost_table, int nb_ostreams,
1517 const AVPacket *pkt)
1519 AVFormatContext *os;
1523 void *buffer_to_free = NULL;
1524 static unsigned int samples_size= 0;
1525 AVSubtitle subtitle, *subtitle_to_free;
1526 int64_t pkt_pts = AV_NOPTS_VALUE;
1528 int frame_available;
1533 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1535 if(ist->next_pts == AV_NOPTS_VALUE)
1536 ist->next_pts= ist->pts;
1540 av_init_packet(&avpkt);
1548 if(pkt->dts != AV_NOPTS_VALUE)
1549 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1550 if(pkt->pts != AV_NOPTS_VALUE)
1551 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1553 //while we have more to decode or while the decoder did output something on EOF
1554 while (avpkt.size > 0 || (!pkt && got_output)) {
1555 uint8_t *data_buf, *decoded_data_buf;
1556 int data_size, decoded_data_size;
1557 AVFrame *decoded_frame, *filtered_frame;
1559 ist->pts= ist->next_pts;
1561 if(avpkt.size && avpkt.size != pkt->size)
1562 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1563 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1564 ist->showed_multi_packet_warning=1;
1566 /* decode the packet if needed */
1567 decoded_frame = filtered_frame = NULL;
1568 decoded_data_buf = NULL; /* fail safe */
1569 decoded_data_size= 0;
1570 data_buf = avpkt.data;
1571 data_size = avpkt.size;
1572 subtitle_to_free = NULL;
1573 if (ist->decoding_needed) {
1574 switch(ist->st->codec->codec_type) {
1575 case AVMEDIA_TYPE_AUDIO:{
1576 if(pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1577 samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1579 samples= av_malloc(samples_size);
1581 decoded_data_size= samples_size;
1582 /* XXX: could avoid copy if PCM 16 bits with same
1583 endianness as CPU */
1584 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1591 got_output = decoded_data_size > 0;
1592 /* Some bug in mpeg audio decoder gives */
1593 /* decoded_data_size < 0, it seems they are overflows */
1595 /* no audio frame */
1598 decoded_data_buf = (uint8_t *)samples;
1599 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1600 (ist->st->codec->sample_rate * ist->st->codec->channels);
1602 case AVMEDIA_TYPE_VIDEO:
1603 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1604 if (!(decoded_frame = avcodec_alloc_frame()))
1605 return AVERROR(ENOMEM);
1606 avpkt.pts = pkt_pts;
1607 avpkt.dts = ist->pts;
1608 pkt_pts = AV_NOPTS_VALUE;
1610 ret = avcodec_decode_video2(ist->st->codec,
1611 decoded_frame, &got_output, &avpkt);
1612 quality = same_quant ? decoded_frame->quality : 0;
1616 /* no picture yet */
1617 av_freep(&decoded_frame);
1618 goto discard_packet;
1620 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1621 decoded_frame->pkt_dts);
1622 if (ist->st->codec->time_base.num != 0) {
1623 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1624 ist->next_pts += ((int64_t)AV_TIME_BASE *
1625 ist->st->codec->time_base.num * ticks) /
1626 ist->st->codec->time_base.den;
1629 buffer_to_free = NULL;
1630 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1632 case AVMEDIA_TYPE_SUBTITLE:
1633 ret = avcodec_decode_subtitle2(ist->st->codec,
1634 &subtitle, &got_output, &avpkt);
1638 goto discard_packet;
1640 subtitle_to_free = &subtitle;
1647 switch(ist->st->codec->codec_type) {
1648 case AVMEDIA_TYPE_AUDIO:
1649 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1650 ist->st->codec->sample_rate;
1652 case AVMEDIA_TYPE_VIDEO:
1653 if (ist->st->codec->time_base.num != 0) {
1654 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1655 ist->next_pts += ((int64_t)AV_TIME_BASE *
1656 ist->st->codec->time_base.num * ticks) /
1657 ist->st->codec->time_base.den;
1664 // preprocess audio (volume)
1665 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1666 if (audio_volume != 256) {
1667 switch (ist->st->codec->sample_fmt) {
1668 case AV_SAMPLE_FMT_U8:
1670 uint8_t *volp = samples;
1671 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1672 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1673 *volp++ = av_clip_uint8(v);
1677 case AV_SAMPLE_FMT_S16:
1679 int16_t *volp = samples;
1680 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1681 int v = ((*volp) * audio_volume + 128) >> 8;
1682 *volp++ = av_clip_int16(v);
1686 case AV_SAMPLE_FMT_S32:
1688 int32_t *volp = samples;
1689 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1690 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1691 *volp++ = av_clipl_int32(v);
1695 case AV_SAMPLE_FMT_FLT:
1697 float *volp = samples;
1698 float scale = audio_volume / 256.f;
1699 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1704 case AV_SAMPLE_FMT_DBL:
1706 double *volp = samples;
1707 double scale = audio_volume / 256.;
1708 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1714 av_log(NULL, AV_LOG_FATAL,
1715 "Audio volume adjustment on sample format %s is not supported.\n",
1716 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1722 /* frame rate emulation */
1723 if (input_files[ist->file_index].rate_emu) {
1724 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1725 int64_t now = av_gettime() - ist->start;
1729 /* if output time reached then transcode raw format,
1730 encode packets and output them */
1731 for (i = 0; i < nb_ostreams; i++) {
1732 OutputFile *of = &output_files[ost_table[i].file_index];
1735 ost = &ost_table[i];
1736 if (ost->source_index != ist_index)
1739 if (of->start_time && ist->pts < of->start_time)
1742 if (of->recording_time != INT64_MAX &&
1743 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1744 (AVRational){1, 1000000}) >= 0) {
1745 ost->is_past_recording_time = 1;
1750 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1751 ost->input_video_filter) {
1753 if (ist->st->sample_aspect_ratio.num)
1754 sar = ist->st->sample_aspect_ratio;
1756 sar = ist->st->codec->sample_aspect_ratio;
1757 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, ist->pts, sar);
1758 if (!(filtered_frame = avcodec_alloc_frame())) {
1759 ret = AVERROR(ENOMEM);
1763 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1764 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1765 while (frame_available) {
1766 AVRational ist_pts_tb;
1767 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1768 get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
1770 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1772 filtered_frame = decoded_frame;
1774 os = output_files[ost->file_index].ctx;
1776 /* set the input output pts pairs */
1777 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1779 if (ost->encoding_needed) {
1780 av_assert0(ist->decoding_needed);
1781 switch(ost->st->codec->codec_type) {
1782 case AVMEDIA_TYPE_AUDIO:
1783 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1785 case AVMEDIA_TYPE_VIDEO:
1787 if (ost->picref->video && !ost->frame_aspect_ratio)
1788 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1790 do_video_out(os, ost, ist, filtered_frame, &frame_size,
1791 same_quant ? quality : ost->st->codec->global_quality);
1792 if (vstats_filename && frame_size)
1793 do_video_stats(os, ost, frame_size);
1795 case AVMEDIA_TYPE_SUBTITLE:
1796 do_subtitle_out(os, ost, ist, &subtitle,
1804 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1806 av_init_packet(&opkt);
1808 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1809 #if !CONFIG_AVFILTER
1815 /* no reencoding needed : output the packet directly */
1816 /* force the input stream PTS */
1818 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1819 audio_size += data_size;
1820 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1821 video_size += data_size;
1825 opkt.stream_index= ost->index;
1826 if(pkt->pts != AV_NOPTS_VALUE)
1827 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1829 opkt.pts= AV_NOPTS_VALUE;
1831 if (pkt->dts == AV_NOPTS_VALUE)
1832 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1834 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1835 opkt.dts -= ost_tb_start_time;
1837 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1838 opkt.flags= pkt->flags;
1840 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1841 if( ost->st->codec->codec_id != CODEC_ID_H264
1842 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1843 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1845 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1846 opkt.destruct= av_destruct_packet;
1848 opkt.data = data_buf;
1849 opkt.size = data_size;
1852 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1853 ost->st->codec->frame_number++;
1854 ost->frame_number++;
1855 av_free_packet(&opkt);
1859 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1860 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1862 avfilter_unref_buffer(ost->picref);
1864 av_freep(&filtered_frame);
1869 av_free(buffer_to_free);
1870 /* XXX: allocate the subtitles in the codec ? */
1871 if (subtitle_to_free) {
1872 avsubtitle_free(subtitle_to_free);
1873 subtitle_to_free = NULL;
1875 av_freep(&decoded_frame);
1884 static void print_sdp(OutputFile *output_files, int n)
1888 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1892 for (i = 0; i < n; i++)
1893 avc[i] = output_files[i].ctx;
1895 av_sdp_create(avc, n, sdp, sizeof(sdp));
1896 printf("SDP:\n%s\n", sdp);
1901 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1902 char *error, int error_len)
1905 InputStream *ist = &input_streams[ist_index];
1906 if (ist->decoding_needed) {
1907 AVCodec *codec = ist->dec;
1909 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1910 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1911 return AVERROR(EINVAL);
1914 /* update requested sample format for the decoder based on the
1915 corresponding encoder sample format */
1916 for (i = 0; i < nb_output_streams; i++) {
1917 OutputStream *ost = &output_streams[i];
1918 if (ost->source_index == ist_index) {
1919 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1924 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1925 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1926 ist->file_index, ist->st->index);
1927 return AVERROR(EINVAL);
1929 assert_codec_experimental(ist->st->codec, 0);
1930 assert_avoptions(ist->opts);
1933 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;
1934 ist->next_pts = AV_NOPTS_VALUE;
1935 init_pts_correction(&ist->pts_ctx);
1941 static int transcode_init(OutputFile *output_files,
1942 int nb_output_files,
1943 InputFile *input_files,
1946 int ret = 0, i, j, k;
1947 AVFormatContext *os;
1948 AVCodecContext *codec, *icodec;
1954 /* init framerate emulation */
1955 for (i = 0; i < nb_input_files; i++) {
1956 InputFile *ifile = &input_files[i];
1957 if (ifile->rate_emu)
1958 for (j = 0; j < ifile->nb_streams; j++)
1959 input_streams[j + ifile->ist_index].start = av_gettime();
1962 /* output stream init */
1963 for(i=0;i<nb_output_files;i++) {
1964 os = output_files[i].ctx;
1965 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1966 av_dump_format(os, i, os->filename, 1);
1967 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
1968 return AVERROR(EINVAL);
1972 /* for each output stream, we compute the right encoding parameters */
1973 for (i = 0; i < nb_output_streams; i++) {
1974 ost = &output_streams[i];
1975 os = output_files[ost->file_index].ctx;
1976 ist = &input_streams[ost->source_index];
1978 codec = ost->st->codec;
1979 icodec = ist->st->codec;
1981 ost->st->disposition = ist->st->disposition;
1982 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1983 codec->chroma_sample_location = icodec->chroma_sample_location;
1985 if (ost->st->stream_copy) {
1986 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1988 if (extra_size > INT_MAX) {
1989 return AVERROR(EINVAL);
1992 /* if stream_copy is selected, no need to decode or encode */
1993 codec->codec_id = icodec->codec_id;
1994 codec->codec_type = icodec->codec_type;
1996 if(!codec->codec_tag){
1997 if( !os->oformat->codec_tag
1998 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1999 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2000 codec->codec_tag = icodec->codec_tag;
2003 codec->bit_rate = icodec->bit_rate;
2004 codec->rc_max_rate = icodec->rc_max_rate;
2005 codec->rc_buffer_size = icodec->rc_buffer_size;
2006 codec->extradata= av_mallocz(extra_size);
2007 if (!codec->extradata) {
2008 return AVERROR(ENOMEM);
2010 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2011 codec->extradata_size= icodec->extradata_size;
2012 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){
2013 codec->time_base = icodec->time_base;
2014 codec->time_base.num *= icodec->ticks_per_frame;
2015 av_reduce(&codec->time_base.num, &codec->time_base.den,
2016 codec->time_base.num, codec->time_base.den, INT_MAX);
2018 codec->time_base = ist->st->time_base;
2019 switch(codec->codec_type) {
2020 case AVMEDIA_TYPE_AUDIO:
2021 if(audio_volume != 256) {
2022 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2025 codec->channel_layout = icodec->channel_layout;
2026 codec->sample_rate = icodec->sample_rate;
2027 codec->channels = icodec->channels;
2028 codec->frame_size = icodec->frame_size;
2029 codec->audio_service_type = icodec->audio_service_type;
2030 codec->block_align= icodec->block_align;
2031 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2032 codec->block_align= 0;
2033 if(codec->codec_id == CODEC_ID_AC3)
2034 codec->block_align= 0;
2036 case AVMEDIA_TYPE_VIDEO:
2037 codec->pix_fmt = icodec->pix_fmt;
2038 codec->width = icodec->width;
2039 codec->height = icodec->height;
2040 codec->has_b_frames = icodec->has_b_frames;
2041 if (!codec->sample_aspect_ratio.num) {
2042 codec->sample_aspect_ratio =
2043 ost->st->sample_aspect_ratio =
2044 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2045 ist->st->codec->sample_aspect_ratio.num ?
2046 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2049 case AVMEDIA_TYPE_SUBTITLE:
2050 codec->width = icodec->width;
2051 codec->height = icodec->height;
2053 case AVMEDIA_TYPE_DATA:
2054 case AVMEDIA_TYPE_ATTACHMENT:
2061 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2062 switch(codec->codec_type) {
2063 case AVMEDIA_TYPE_AUDIO:
2064 ost->fifo= av_fifo_alloc(1024);
2066 return AVERROR(ENOMEM);
2068 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2069 if (!codec->sample_rate) {
2070 codec->sample_rate = icodec->sample_rate;
2072 codec->sample_rate >>= icodec->lowres;
2074 choose_sample_rate(ost->st, ost->enc);
2075 codec->time_base = (AVRational){1, codec->sample_rate};
2076 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2077 codec->sample_fmt = icodec->sample_fmt;
2078 choose_sample_fmt(ost->st, ost->enc);
2079 if (!codec->channels)
2080 codec->channels = icodec->channels;
2081 codec->channel_layout = icodec->channel_layout;
2082 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2083 codec->channel_layout = 0;
2084 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2085 icodec->request_channels = codec->channels;
2086 ist->decoding_needed = 1;
2087 ost->encoding_needed = 1;
2088 ost->resample_sample_fmt = icodec->sample_fmt;
2089 ost->resample_sample_rate = icodec->sample_rate;
2090 ost->resample_channels = icodec->channels;
2092 case AVMEDIA_TYPE_VIDEO:
2093 if (codec->pix_fmt == PIX_FMT_NONE)
2094 codec->pix_fmt = icodec->pix_fmt;
2095 choose_pixel_fmt(ost->st, ost->enc);
2097 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2098 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2102 if (!codec->width || !codec->height) {
2103 codec->width = icodec->width;
2104 codec->height = icodec->height;
2107 ost->video_resample = codec->width != icodec->width ||
2108 codec->height != icodec->height ||
2109 codec->pix_fmt != icodec->pix_fmt;
2110 if (ost->video_resample) {
2111 #if !CONFIG_AVFILTER
2112 avcodec_get_frame_defaults(&ost->pict_tmp);
2113 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2114 codec->width, codec->height)) {
2115 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2118 ost->img_resample_ctx = sws_getContext(
2125 ost->sws_flags, NULL, NULL, NULL);
2126 if (ost->img_resample_ctx == NULL) {
2127 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2131 codec->bits_per_raw_sample= 0;
2134 ost->resample_height = icodec->height;
2135 ost->resample_width = icodec->width;
2136 ost->resample_pix_fmt= icodec->pix_fmt;
2137 ost->encoding_needed = 1;
2138 ist->decoding_needed = 1;
2140 if (!ost->frame_rate.num)
2141 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2142 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2143 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2144 ost->frame_rate = ost->enc->supported_framerates[idx];
2146 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2149 if (configure_video_filters(ist, ost)) {
2150 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2155 case AVMEDIA_TYPE_SUBTITLE:
2156 ost->encoding_needed = 1;
2157 ist->decoding_needed = 1;
2164 if (ost->encoding_needed &&
2165 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2166 char logfilename[1024];
2169 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2170 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2172 if (codec->flags & CODEC_FLAG_PASS1) {
2173 f = fopen(logfilename, "wb");
2175 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2176 logfilename, strerror(errno));
2182 size_t logbuffer_size;
2183 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2184 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2188 codec->stats_in = logbuffer;
2192 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2193 int size= codec->width * codec->height;
2194 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2199 bit_buffer = av_malloc(bit_buffer_size);
2201 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2203 return AVERROR(ENOMEM);
2206 /* open each encoder */
2207 for (i = 0; i < nb_output_streams; i++) {
2208 ost = &output_streams[i];
2209 if (ost->encoding_needed) {
2210 AVCodec *codec = ost->enc;
2211 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2213 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2214 ost->st->codec->codec_id, ost->file_index, ost->index);
2215 ret = AVERROR(EINVAL);
2218 if (dec->subtitle_header) {
2219 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2220 if (!ost->st->codec->subtitle_header) {
2221 ret = AVERROR(ENOMEM);
2224 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2225 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2227 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2228 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2229 ost->file_index, ost->index);
2230 ret = AVERROR(EINVAL);
2233 assert_codec_experimental(ost->st->codec, 1);
2234 assert_avoptions(ost->opts);
2235 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2236 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2237 "It takes bits/s as argument, not kbits/s\n");
2238 extra_size += ost->st->codec->extradata_size;
2240 if (ost->st->codec->me_threshold)
2241 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2245 /* init input streams */
2246 for (i = 0; i < nb_input_streams; i++)
2247 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2250 /* discard unused programs */
2251 for (i = 0; i < nb_input_files; i++) {
2252 InputFile *ifile = &input_files[i];
2253 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2254 AVProgram *p = ifile->ctx->programs[j];
2255 int discard = AVDISCARD_ALL;
2257 for (k = 0; k < p->nb_stream_indexes; k++)
2258 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2259 discard = AVDISCARD_DEFAULT;
2262 p->discard = discard;
2266 /* open files and write file headers */
2267 for (i = 0; i < nb_output_files; i++) {
2268 os = output_files[i].ctx;
2269 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2270 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2271 ret = AVERROR(EINVAL);
2274 assert_avoptions(output_files[i].opts);
2275 if (strcmp(os->oformat->name, "rtp")) {
2281 /* dump the file output parameters - cannot be done before in case
2283 for(i=0;i<nb_output_files;i++) {
2284 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2287 /* dump the stream mapping */
2288 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2289 for (i = 0; i < nb_output_streams; i++) {
2290 ost = &output_streams[i];
2291 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d -> #%d.%d",
2292 input_streams[ost->source_index].file_index,
2293 input_streams[ost->source_index].st->index,
2296 if (ost->sync_ist != &input_streams[ost->source_index])
2297 av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
2298 ost->sync_ist->file_index,
2299 ost->sync_ist->st->index);
2300 if (ost->st->stream_copy)
2301 av_log(NULL, AV_LOG_INFO, " (copy)");
2303 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2304 input_streams[ost->source_index].dec->name : "?",
2305 ost->enc ? ost->enc->name : "?");
2306 av_log(NULL, AV_LOG_INFO, "\n");
2310 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2315 print_sdp(output_files, nb_output_files);
2322 * The following code is the main loop of the file converter
2324 static int transcode(OutputFile *output_files,
2325 int nb_output_files,
2326 InputFile *input_files,
2330 AVFormatContext *is, *os;
2334 int no_packet_count=0;
2335 int64_t timer_start;
2337 if (!(no_packet = av_mallocz(nb_input_files)))
2340 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2344 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2347 timer_start = av_gettime();
2349 for(; received_sigterm == 0;) {
2350 int file_index, ist_index;
2355 ipts_min = INT64_MAX;
2358 /* select the stream that we must read now by looking at the
2359 smallest output pts */
2361 for (i = 0; i < nb_output_streams; i++) {
2365 ost = &output_streams[i];
2366 of = &output_files[ost->file_index];
2367 os = output_files[ost->file_index].ctx;
2368 ist = &input_streams[ost->source_index];
2369 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2370 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2372 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2374 if (!input_files[ist->file_index].eof_reached){
2375 if(ipts < ipts_min) {
2377 if(input_sync ) file_index = ist->file_index;
2379 if(opts < opts_min) {
2381 if(!input_sync) file_index = ist->file_index;
2384 if (ost->frame_number >= ost->max_frames) {
2386 for (j = 0; j < of->ctx->nb_streams; j++)
2387 output_streams[of->ost_index + j].is_past_recording_time = 1;
2391 /* if none, if is finished */
2392 if (file_index < 0) {
2393 if(no_packet_count){
2395 memset(no_packet, 0, nb_input_files);
2402 /* read a frame from it and output it in the fifo */
2403 is = input_files[file_index].ctx;
2404 ret= av_read_frame(is, &pkt);
2405 if(ret == AVERROR(EAGAIN)){
2406 no_packet[file_index]=1;
2411 input_files[file_index].eof_reached = 1;
2419 memset(no_packet, 0, nb_input_files);
2422 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2423 is->streams[pkt.stream_index]);
2425 /* the following test is needed in case new streams appear
2426 dynamically in stream : we ignore them */
2427 if (pkt.stream_index >= input_files[file_index].nb_streams)
2428 goto discard_packet;
2429 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2430 ist = &input_streams[ist_index];
2432 goto discard_packet;
2434 if (pkt.dts != AV_NOPTS_VALUE)
2435 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2436 if (pkt.pts != AV_NOPTS_VALUE)
2437 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2439 if(pkt.pts != AV_NOPTS_VALUE)
2440 pkt.pts *= ist->ts_scale;
2441 if(pkt.dts != AV_NOPTS_VALUE)
2442 pkt.dts *= ist->ts_scale;
2444 // 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);
2445 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2446 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2447 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2448 int64_t delta= pkt_dts - ist->next_pts;
2449 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2450 input_files[ist->file_index].ts_offset -= delta;
2451 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2452 delta, input_files[ist->file_index].ts_offset);
2453 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2454 if(pkt.pts != AV_NOPTS_VALUE)
2455 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2459 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2460 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2462 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d.%d\n",
2463 ist->file_index, ist->st->index);
2466 av_free_packet(&pkt);
2471 av_free_packet(&pkt);
2473 /* dump report by using the output first video and audio streams */
2474 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2477 /* at the end of stream, we must flush the decoder buffers */
2478 for (i = 0; i < nb_input_streams; i++) {
2479 ist = &input_streams[i];
2480 if (ist->decoding_needed) {
2481 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2484 flush_encoders(output_streams, nb_output_streams);
2488 /* write the trailer if needed and close file */
2489 for(i=0;i<nb_output_files;i++) {
2490 os = output_files[i].ctx;
2491 av_write_trailer(os);
2494 /* dump report by using the first video and audio streams */
2495 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2497 /* close each encoder */
2498 for (i = 0; i < nb_output_streams; i++) {
2499 ost = &output_streams[i];
2500 if (ost->encoding_needed) {
2501 av_freep(&ost->st->codec->stats_in);
2502 avcodec_close(ost->st->codec);
2505 avfilter_graph_free(&ost->graph);
2509 /* close each decoder */
2510 for (i = 0; i < nb_input_streams; i++) {
2511 ist = &input_streams[i];
2512 if (ist->decoding_needed) {
2513 avcodec_close(ist->st->codec);
2521 av_freep(&bit_buffer);
2522 av_freep(&no_packet);
2524 if (output_streams) {
2525 for (i = 0; i < nb_output_streams; i++) {
2526 ost = &output_streams[i];
2528 if (ost->st->stream_copy)
2529 av_freep(&ost->st->codec->extradata);
2531 fclose(ost->logfile);
2532 ost->logfile = NULL;
2534 av_fifo_free(ost->fifo); /* works even if fifo is not
2535 initialized but set to zero */
2536 av_freep(&ost->st->codec->subtitle_header);
2537 av_free(ost->pict_tmp.data[0]);
2538 av_free(ost->forced_kf_pts);
2539 if (ost->video_resample)
2540 sws_freeContext(ost->img_resample_ctx);
2542 audio_resample_close(ost->resample);
2543 if (ost->reformat_ctx)
2544 av_audio_convert_free(ost->reformat_ctx);
2545 av_dict_free(&ost->opts);
2552 static int opt_verbose(const char *opt, const char *arg)
2554 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -loglevel\n", opt);
2558 static double parse_frame_aspect_ratio(const char *arg)
2565 p = strchr(arg, ':');
2567 x = strtol(arg, &end, 10);
2569 y = strtol(end+1, &end, 10);
2571 ar = (double)x / (double)y;
2573 ar = strtod(arg, NULL);
2576 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2582 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2584 return parse_option(o, "codec:a", arg, options);
2587 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2589 return parse_option(o, "codec:v", arg, options);
2592 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2594 return parse_option(o, "codec:s", arg, options);
2597 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2599 return parse_option(o, "codec:d", arg, options);
2602 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2604 StreamMap *m = NULL;
2605 int i, negative = 0, file_idx;
2606 int sync_file_idx = -1, sync_stream_idx;
2614 map = av_strdup(arg);
2616 /* parse sync stream first, just pick first matching stream */
2617 if (sync = strchr(map, ',')) {
2619 sync_file_idx = strtol(sync + 1, &sync, 0);
2620 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2621 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2626 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2627 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2628 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2629 sync_stream_idx = i;
2632 if (i == input_files[sync_file_idx].nb_streams) {
2633 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2634 "match any streams.\n", arg);
2640 file_idx = strtol(map, &p, 0);
2641 if (file_idx >= nb_input_files || file_idx < 0) {
2642 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2646 /* disable some already defined maps */
2647 for (i = 0; i < o->nb_stream_maps; i++) {
2648 m = &o->stream_maps[i];
2649 if (check_stream_specifier(input_files[m->file_index].ctx,
2650 input_files[m->file_index].ctx->streams[m->stream_index],
2651 *p == ':' ? p + 1 : p) > 0)
2655 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2656 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2657 *p == ':' ? p + 1 : p) <= 0)
2659 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2660 &o->nb_stream_maps, o->nb_stream_maps + 1);
2661 m = &o->stream_maps[o->nb_stream_maps - 1];
2663 m->file_index = file_idx;
2664 m->stream_index = i;
2666 if (sync_file_idx >= 0) {
2667 m->sync_file_index = sync_file_idx;
2668 m->sync_stream_index = sync_stream_idx;
2670 m->sync_file_index = file_idx;
2671 m->sync_stream_index = i;
2676 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2684 static void parse_meta_type(char *arg, char *type, int *index)
2694 if (*(++arg) == ':')
2695 *index = strtol(++arg, NULL, 0);
2698 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2705 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2707 MetadataMap *m, *m1;
2710 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2711 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2713 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2714 m->file = strtol(arg, &p, 0);
2715 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2717 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2718 if (p = strchr(opt, ':'))
2719 parse_meta_type(p + 1, &m1->type, &m1->index);
2723 if (m->type == 'g' || m1->type == 'g')
2724 o->metadata_global_manual = 1;
2725 if (m->type == 's' || m1->type == 's')
2726 o->metadata_streams_manual = 1;
2727 if (m->type == 'c' || m1->type == 'c')
2728 o->metadata_chapters_manual = 1;
2733 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2735 const char *codec_string = encoder ? "encoder" : "decoder";
2739 return CODEC_ID_NONE;
2741 avcodec_find_encoder_by_name(name) :
2742 avcodec_find_decoder_by_name(name);
2744 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2747 if(codec->type != type) {
2748 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2754 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2756 char *codec_name = NULL;
2758 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2762 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2763 return avcodec_find_encoder(st->codec->codec_id);
2765 } else if (!strcmp(codec_name, "copy"))
2766 st->stream_copy = 1;
2768 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2769 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2770 avcodec_find_decoder_by_name(codec_name);
2777 * Add all the streams from the given input file to the global
2778 * list of input streams.
2780 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2782 int i, rfps, rfps_base;
2784 for (i = 0; i < ic->nb_streams; i++) {
2785 AVStream *st = ic->streams[i];
2786 AVCodecContext *dec = st->codec;
2790 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2791 ist = &input_streams[nb_input_streams - 1];
2793 ist->file_index = nb_input_files;
2795 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2797 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2798 ist->ts_scale = scale;
2800 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2802 ist->dec = avcodec_find_decoder(dec->codec_id);
2804 switch (dec->codec_type) {
2805 case AVMEDIA_TYPE_AUDIO:
2806 if (o->audio_disable)
2807 st->discard= AVDISCARD_ALL;
2809 case AVMEDIA_TYPE_VIDEO:
2810 rfps = ic->streams[i]->r_frame_rate.num;
2811 rfps_base = ic->streams[i]->r_frame_rate.den;
2813 dec->flags |= CODEC_FLAG_EMU_EDGE;
2814 dec->height >>= dec->lowres;
2815 dec->width >>= dec->lowres;
2818 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2820 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",
2821 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2822 (float)rfps / rfps_base, rfps, rfps_base);
2825 if (o->video_disable)
2826 st->discard= AVDISCARD_ALL;
2827 else if(video_discard)
2828 st->discard= video_discard;
2830 case AVMEDIA_TYPE_DATA:
2832 case AVMEDIA_TYPE_SUBTITLE:
2833 if (o->subtitle_disable)
2834 st->discard = AVDISCARD_ALL;
2836 case AVMEDIA_TYPE_ATTACHMENT:
2837 case AVMEDIA_TYPE_UNKNOWN:
2845 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2847 AVFormatContext *ic;
2848 AVInputFormat *file_iformat = NULL;
2852 AVDictionary **opts;
2853 int orig_nb_streams; // number of streams before avformat_find_stream_info
2856 if (!(file_iformat = av_find_input_format(o->format))) {
2857 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
2862 if (!strcmp(filename, "-"))
2865 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2866 !strcmp(filename, "/dev/stdin");
2868 /* get default parameters from command line */
2869 ic = avformat_alloc_context();
2871 print_error(filename, AVERROR(ENOMEM));
2874 if (o->nb_audio_sample_rate) {
2875 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2876 av_dict_set(&format_opts, "sample_rate", buf, 0);
2878 if (o->nb_audio_channels) {
2879 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2880 av_dict_set(&format_opts, "channels", buf, 0);
2882 if (o->nb_frame_rates) {
2883 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2885 if (o->nb_frame_sizes) {
2886 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2888 if (o->nb_frame_pix_fmts)
2889 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
2891 ic->flags |= AVFMT_FLAG_NONBLOCK;
2893 /* open the input file with generic libav function */
2894 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2896 print_error(filename, err);
2899 assert_avoptions(format_opts);
2901 /* apply forced codec ids */
2902 for (i = 0; i < ic->nb_streams; i++)
2903 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
2905 /* Set AVCodecContext options for avformat_find_stream_info */
2906 opts = setup_find_stream_info_opts(ic, codec_opts);
2907 orig_nb_streams = ic->nb_streams;
2909 /* If not enough info to get the stream parameters, we decode the
2910 first frames to get it. (used in mpeg case for example) */
2911 ret = avformat_find_stream_info(ic, opts);
2913 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
2914 av_close_input_file(ic);
2918 timestamp = o->start_time;
2919 /* add the stream start time */
2920 if (ic->start_time != AV_NOPTS_VALUE)
2921 timestamp += ic->start_time;
2923 /* if seeking requested, we execute it */
2924 if (o->start_time != 0) {
2925 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2927 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2928 filename, (double)timestamp / AV_TIME_BASE);
2932 /* update the current parameters so that they match the one of the input stream */
2933 add_input_streams(o, ic);
2935 /* dump the file content */
2936 av_dump_format(ic, nb_input_files, filename, 0);
2938 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
2939 input_files[nb_input_files - 1].ctx = ic;
2940 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
2941 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
2942 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
2943 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
2945 for (i = 0; i < orig_nb_streams; i++)
2946 av_dict_free(&opts[i]);
2953 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2954 AVCodecContext *avctx)
2960 for (p = kf; *p; p++)
2963 ost->forced_kf_count = n;
2964 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2965 if (!ost->forced_kf_pts) {
2966 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2969 for (i = 0; i < n; i++) {
2970 p = i ? strchr(p, ',') + 1 : kf;
2971 t = parse_time_or_die("force_key_frames", p, 1);
2972 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2976 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
2979 AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
2980 int idx = oc->nb_streams - 1;
2981 int64_t max_frames = INT64_MAX;
2982 char *bsf = NULL, *next, *codec_tag = NULL;
2983 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
2987 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
2991 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
2992 nb_output_streams + 1);
2993 ost = &output_streams[nb_output_streams - 1];
2994 ost->file_index = nb_output_files;
2997 st->codec->codec_type = type;
2998 ost->enc = choose_codec(o, oc, st, type);
3000 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3003 avcodec_get_context_defaults3(st->codec, ost->enc);
3004 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3006 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3007 ost->max_frames = max_frames;
3009 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3011 if (next = strchr(bsf, ','))
3013 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3014 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3018 bsfc_prev->next = bsfc;
3020 ost->bitstream_filters = bsfc;
3026 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3028 uint32_t tag = strtol(codec_tag, &next, 0);
3030 tag = AV_RL32(codec_tag);
3031 st->codec->codec_tag = tag;
3034 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3035 if (qscale >= 0 || same_quant) {
3036 st->codec->flags |= CODEC_FLAG_QSCALE;
3037 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3040 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3041 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3043 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3047 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3050 const char *p = str;
3057 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3064 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3068 AVCodecContext *video_enc;
3070 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3072 video_enc = st->codec;
3074 if (!st->stream_copy) {
3075 const char *p = NULL;
3076 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3077 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3078 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3079 int i, force_fps = 0, top_field_first = -1;
3081 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3082 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3083 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3087 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3088 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3089 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3093 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3094 if (frame_aspect_ratio)
3095 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3097 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3098 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3099 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3102 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3104 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3106 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3107 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3110 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3112 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3114 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3115 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3118 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3121 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3124 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3126 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3129 video_enc->rc_override=
3130 av_realloc(video_enc->rc_override,
3131 sizeof(RcOverride)*(i+1));
3132 video_enc->rc_override[i].start_frame= start;
3133 video_enc->rc_override[i].end_frame = end;
3135 video_enc->rc_override[i].qscale= q;
3136 video_enc->rc_override[i].quality_factor= 1.0;
3139 video_enc->rc_override[i].qscale= 0;
3140 video_enc->rc_override[i].quality_factor= -q/100.0;
3145 video_enc->rc_override_count=i;
3146 if (!video_enc->rc_initial_buffer_occupancy)
3147 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3148 video_enc->intra_dc_precision= intra_dc_precision - 8;
3153 video_enc->flags |= CODEC_FLAG_PASS1;
3155 video_enc->flags |= CODEC_FLAG_PASS2;
3159 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3160 if (forced_key_frames)
3161 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3163 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3164 ost->force_fps = force_fps;
3166 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3167 ost->top_field_first = top_field_first;
3170 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3172 ost->avfilter = av_strdup(filters);
3179 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3183 AVCodecContext *audio_enc;
3185 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3188 audio_enc = st->codec;
3189 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3191 if (!st->stream_copy) {
3192 char *sample_fmt = NULL;
3194 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3196 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3198 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3199 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3203 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3209 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3214 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3216 if (!st->stream_copy) {
3217 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3224 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3226 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3227 ost->st->stream_copy = 1;
3231 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3235 AVCodecContext *subtitle_enc;
3237 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3239 subtitle_enc = st->codec;
3241 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3246 /* arg format is "output-stream-index:streamid-value". */
3247 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3253 av_strlcpy(idx_str, arg, sizeof(idx_str));
3254 p = strchr(idx_str, ':');
3256 av_log(NULL, AV_LOG_FATAL,
3257 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3262 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3263 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3264 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3268 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3270 AVFormatContext *is = ifile->ctx;
3271 AVFormatContext *os = ofile->ctx;
3274 for (i = 0; i < is->nb_chapters; i++) {
3275 AVChapter *in_ch = is->chapters[i], *out_ch;
3276 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3277 AV_TIME_BASE_Q, in_ch->time_base);
3278 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3279 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3282 if (in_ch->end < ts_off)
3284 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3287 out_ch = av_mallocz(sizeof(AVChapter));
3289 return AVERROR(ENOMEM);
3291 out_ch->id = in_ch->id;
3292 out_ch->time_base = in_ch->time_base;
3293 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3294 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3297 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3300 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3302 return AVERROR(ENOMEM);
3303 os->chapters[os->nb_chapters - 1] = out_ch;
3308 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3311 AVFormatContext *ic = NULL;
3313 err = avformat_open_input(&ic, filename, NULL, NULL);
3316 /* copy stream format */
3317 for(i=0;i<ic->nb_streams;i++) {
3322 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3323 ost = new_output_stream(o, s, codec->type);
3326 // FIXME: a more elegant solution is needed
3327 memcpy(st, ic->streams[i], sizeof(AVStream));
3329 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3331 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3332 choose_sample_fmt(st, codec);
3333 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3334 choose_pixel_fmt(st, codec);
3337 av_close_input_file(ic);
3341 static void opt_output_file(void *optctx, const char *filename)
3343 OptionsContext *o = optctx;
3344 AVFormatContext *oc;
3346 AVOutputFormat *file_oformat;
3350 if (!strcmp(filename, "-"))
3353 oc = avformat_alloc_context();
3355 print_error(filename, AVERROR(ENOMEM));
3360 file_oformat = av_guess_format(o->format, NULL, NULL);
3361 if (!file_oformat) {
3362 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3366 file_oformat = av_guess_format(NULL, filename, NULL);
3367 if (!file_oformat) {
3368 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3374 oc->oformat = file_oformat;
3375 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3377 if (!strcmp(file_oformat->name, "ffm") &&
3378 av_strstart(filename, "http:", NULL)) {
3379 /* special case for files sent to avserver: we get the stream
3380 parameters from avserver */
3381 int err = read_avserver_streams(o, oc, filename);
3383 print_error(filename, err);
3386 } else if (!o->nb_stream_maps) {
3387 /* pick the "best" stream of each type */
3388 #define NEW_STREAM(type, index)\
3390 ost = new_ ## type ## _stream(o, oc);\
3391 ost->source_index = index;\
3392 ost->sync_ist = &input_streams[index];\
3393 input_streams[index].discard = 0;\
3396 /* video: highest resolution */
3397 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3398 int area = 0, idx = -1;
3399 for (i = 0; i < nb_input_streams; i++) {
3400 ist = &input_streams[i];
3401 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3402 ist->st->codec->width * ist->st->codec->height > area) {
3403 area = ist->st->codec->width * ist->st->codec->height;
3407 NEW_STREAM(video, idx);
3410 /* audio: most channels */
3411 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3412 int channels = 0, idx = -1;
3413 for (i = 0; i < nb_input_streams; i++) {
3414 ist = &input_streams[i];
3415 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3416 ist->st->codec->channels > channels) {
3417 channels = ist->st->codec->channels;
3421 NEW_STREAM(audio, idx);
3424 /* subtitles: pick first */
3425 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3426 for (i = 0; i < nb_input_streams; i++)
3427 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3428 NEW_STREAM(subtitle, i);
3432 /* do something with data? */
3434 for (i = 0; i < o->nb_stream_maps; i++) {
3435 StreamMap *map = &o->stream_maps[i];
3440 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3441 switch (ist->st->codec->codec_type) {
3442 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3443 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3444 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3445 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3446 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3448 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3449 map->file_index, map->stream_index);
3453 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3454 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3455 map->sync_stream_index];
3460 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3461 output_files[nb_output_files - 1].ctx = oc;
3462 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3463 output_files[nb_output_files - 1].recording_time = o->recording_time;
3464 output_files[nb_output_files - 1].start_time = o->start_time;
3465 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3466 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3468 /* check filename in case of an image number is expected */
3469 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3470 if (!av_filename_number_test(oc->filename)) {
3471 print_error(oc->filename, AVERROR(EINVAL));
3476 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3477 /* test if it already exists to avoid loosing precious files */
3478 if (!file_overwrite &&
3479 (strchr(filename, ':') == NULL ||
3480 filename[1] == ':' ||
3481 av_strstart(filename, "file:", NULL))) {
3482 if (avio_check(filename, 0) == 0) {
3484 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3486 if (!read_yesno()) {
3487 fprintf(stderr, "Not overwriting - exiting\n");
3492 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3499 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3500 print_error(filename, err);
3505 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3506 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3507 oc->flags |= AVFMT_FLAG_NONBLOCK;
3510 if (o->chapters_input_file >= nb_input_files) {
3511 if (o->chapters_input_file == INT_MAX) {
3512 /* copy chapters from the first input file that has them*/
3513 o->chapters_input_file = -1;
3514 for (i = 0; i < nb_input_files; i++)
3515 if (input_files[i].ctx->nb_chapters) {
3516 o->chapters_input_file = i;
3520 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3521 o->chapters_input_file);
3525 if (o->chapters_input_file >= 0)
3526 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3527 !o->metadata_chapters_manual);
3530 for (i = 0; i < o->nb_meta_data_maps; i++) {
3531 AVFormatContext *files[2];
3532 AVDictionary **meta[2];
3535 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3536 if ((index) < 0 || (index) >= (nb_elems)) {\
3537 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3542 int in_file_index = o->meta_data_maps[i][1].file;
3543 if (in_file_index < 0)
3545 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3548 files[1] = input_files[in_file_index].ctx;
3550 for (j = 0; j < 2; j++) {
3551 MetadataMap *map = &o->meta_data_maps[i][j];
3553 switch (map->type) {
3555 meta[j] = &files[j]->metadata;
3558 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3559 meta[j] = &files[j]->streams[map->index]->metadata;
3562 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3563 meta[j] = &files[j]->chapters[map->index]->metadata;
3566 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3567 meta[j] = &files[j]->programs[map->index]->metadata;
3572 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3575 /* copy global metadata by default */
3576 if (!o->metadata_global_manual && nb_input_files)
3577 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3578 AV_DICT_DONT_OVERWRITE);
3579 if (!o->metadata_streams_manual)
3580 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3581 InputStream *ist = &input_streams[output_streams[i].source_index];
3582 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3585 /* process manually set metadata */
3586 for (i = 0; i < o->nb_metadata; i++) {
3591 val = strchr(o->metadata[i].u.str, '=');
3593 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3594 o->metadata[i].u.str);
3599 parse_meta_type(o->metadata[i].specifier, &type, &index);
3605 if (index < 0 || index >= oc->nb_streams) {
3606 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3609 m = &oc->streams[index]->metadata;
3612 if (index < 0 || index >= oc->nb_chapters) {
3613 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3616 m = &oc->chapters[index]->metadata;
3619 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3623 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3629 /* same option as mencoder */
3630 static int opt_pass(const char *opt, const char *arg)
3632 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3636 static int64_t getutime(void)
3639 struct rusage rusage;
3641 getrusage(RUSAGE_SELF, &rusage);
3642 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3643 #elif HAVE_GETPROCESSTIMES
3645 FILETIME c, e, k, u;
3646 proc = GetCurrentProcess();
3647 GetProcessTimes(proc, &c, &e, &k, &u);
3648 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3650 return av_gettime();
3654 static int64_t getmaxrss(void)
3656 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3657 struct rusage rusage;
3658 getrusage(RUSAGE_SELF, &rusage);
3659 return (int64_t)rusage.ru_maxrss * 1024;
3660 #elif HAVE_GETPROCESSMEMORYINFO
3662 PROCESS_MEMORY_COUNTERS memcounters;
3663 proc = GetCurrentProcess();
3664 memcounters.cb = sizeof(memcounters);
3665 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3666 return memcounters.PeakPagefileUsage;
3672 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3674 return parse_option(o, "q:a", arg, options);
3677 static void show_usage(void)
3679 printf("Hyper fast Audio and Video encoder\n");
3680 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3684 static void show_help(void)
3687 AVOutputFormat *oformat = NULL;
3688 AVInputFormat *iformat = NULL;
3689 const AVClass *class;
3691 av_log_set_callback(log_callback_help);
3693 show_help_options(options, "Main options:\n",
3694 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3695 show_help_options(options, "\nAdvanced options:\n",
3696 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3698 show_help_options(options, "\nVideo options:\n",
3699 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3701 show_help_options(options, "\nAdvanced Video options:\n",
3702 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3703 OPT_VIDEO | OPT_EXPERT);
3704 show_help_options(options, "\nAudio options:\n",
3705 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3707 show_help_options(options, "\nAdvanced Audio options:\n",
3708 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3709 OPT_AUDIO | OPT_EXPERT);
3710 show_help_options(options, "\nSubtitle options:\n",
3711 OPT_SUBTITLE | OPT_GRAB,
3713 show_help_options(options, "\nAudio/Video grab options:\n",
3717 class = avcodec_get_class();
3718 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3721 /* individual codec options */
3723 while ((c = av_codec_next(c))) {
3724 if (c->priv_class) {
3725 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3730 class = avformat_get_class();
3731 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3734 /* individual muxer options */
3735 while ((oformat = av_oformat_next(oformat))) {
3736 if (oformat->priv_class) {
3737 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3742 /* individual demuxer options */
3743 while ((iformat = av_iformat_next(iformat))) {
3744 if (iformat->priv_class) {
3745 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3750 class = sws_get_class();
3751 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3754 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3756 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3757 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3759 if(!strncmp(arg, "pal-", 4)) {
3762 } else if(!strncmp(arg, "ntsc-", 5)) {
3765 } else if(!strncmp(arg, "film-", 5)) {
3769 /* Try to determine PAL/NTSC by peeking in the input files */
3770 if(nb_input_files) {
3772 for (j = 0; j < nb_input_files; j++) {
3773 for (i = 0; i < input_files[j].nb_streams; i++) {
3774 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3775 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3777 fr = c->time_base.den * 1000 / c->time_base.num;
3781 } else if((fr == 29970) || (fr == 23976)) {
3790 if (norm != UNKNOWN)
3791 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3794 if(norm == UNKNOWN) {
3795 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3796 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3797 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3801 if(!strcmp(arg, "vcd")) {
3802 opt_video_codec(o, "c:v", "mpeg1video");
3803 opt_audio_codec(o, "c:a", "mp2");
3804 parse_option(o, "f", "vcd", options);
3806 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3807 parse_option(o, "r", frame_rates[norm], options);
3808 opt_default("g", norm == PAL ? "15" : "18");
3810 opt_default("b", "1150000");
3811 opt_default("maxrate", "1150000");
3812 opt_default("minrate", "1150000");
3813 opt_default("bufsize", "327680"); // 40*1024*8;
3815 opt_default("b:a", "224000");
3816 parse_option(o, "ar", "44100", options);
3817 parse_option(o, "ac", "2", options);
3819 opt_default("packetsize", "2324");
3820 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3822 /* We have to offset the PTS, so that it is consistent with the SCR.
3823 SCR starts at 36000, but the first two packs contain only padding
3824 and the first pack from the other stream, respectively, may also have
3825 been written before.
3826 So the real data starts at SCR 36000+3*1200. */
3827 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3828 } else if(!strcmp(arg, "svcd")) {
3830 opt_video_codec(o, "c:v", "mpeg2video");
3831 opt_audio_codec(o, "c:a", "mp2");
3832 parse_option(o, "f", "svcd", options);
3834 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3835 parse_option(o, "r", frame_rates[norm], options);
3836 opt_default("g", norm == PAL ? "15" : "18");
3838 opt_default("b", "2040000");
3839 opt_default("maxrate", "2516000");
3840 opt_default("minrate", "0"); //1145000;
3841 opt_default("bufsize", "1835008"); //224*1024*8;
3842 opt_default("flags", "+scan_offset");
3845 opt_default("b:a", "224000");
3846 parse_option(o, "ar", "44100", options);
3848 opt_default("packetsize", "2324");
3850 } else if(!strcmp(arg, "dvd")) {
3852 opt_video_codec(o, "c:v", "mpeg2video");
3853 opt_audio_codec(o, "c:a", "ac3");
3854 parse_option(o, "f", "dvd", options);
3856 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3857 parse_option(o, "r", frame_rates[norm], options);
3858 opt_default("g", norm == PAL ? "15" : "18");
3860 opt_default("b", "6000000");
3861 opt_default("maxrate", "9000000");
3862 opt_default("minrate", "0"); //1500000;
3863 opt_default("bufsize", "1835008"); //224*1024*8;
3865 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3866 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3868 opt_default("b:a", "448000");
3869 parse_option(o, "ar", "48000", options);
3871 } else if(!strncmp(arg, "dv", 2)) {
3873 parse_option(o, "f", "dv", options);
3875 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3876 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3877 norm == PAL ? "yuv420p" : "yuv411p", options);
3878 parse_option(o, "r", frame_rates[norm], options);
3880 parse_option(o, "ar", "48000", options);
3881 parse_option(o, "ac", "2", options);
3884 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
3885 return AVERROR(EINVAL);
3890 static int opt_vstats_file(const char *opt, const char *arg)
3892 av_free (vstats_filename);
3893 vstats_filename=av_strdup (arg);
3897 static int opt_vstats(const char *opt, const char *arg)
3900 time_t today2 = time(NULL);
3901 struct tm *today = localtime(&today2);
3903 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3905 return opt_vstats_file(opt, filename);
3908 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
3910 return parse_option(o, "frames:v", arg, options);
3913 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
3915 return parse_option(o, "frames:a", arg, options);
3918 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
3920 return parse_option(o, "frames:d", arg, options);
3923 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
3925 return parse_option(o, "tag:v", arg, options);
3928 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
3930 return parse_option(o, "tag:a", arg, options);
3933 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
3935 return parse_option(o, "tag:s", arg, options);
3938 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
3940 return parse_option(o, "filter:v", arg, options);
3943 #define OFFSET(x) offsetof(OptionsContext, x)
3944 static const OptionDef options[] = {
3946 #include "cmdutils_common_opts.h"
3947 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
3948 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
3949 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3950 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3951 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3952 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
3953 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
3954 "outfile[,metadata]:infile[,metadata]" },
3955 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
3956 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3957 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
3958 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
3959 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
3960 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
3961 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
3962 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
3963 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3964 "add timings for benchmarking" },
3965 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3966 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3967 "dump each input packet" },
3968 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3969 "when dumping packets, also dump the payload" },
3970 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
3971 { "v", HAS_ARG, {(void*)opt_verbose}, "deprecated, use -loglevel instead", "number" },
3972 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3973 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3974 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3975 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3976 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3977 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
3978 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3979 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3980 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3981 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3982 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
3983 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
3984 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
3985 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
3987 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
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);