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;
116 static int copy_tb = 1;
117 static int opt_shortest = 0;
118 static char *vstats_filename;
119 static FILE *vstats_file;
121 static int audio_volume = 256;
123 static int exit_on_error = 0;
124 static int using_stdin = 0;
125 static int64_t video_size = 0;
126 static int64_t audio_size = 0;
127 static int64_t extra_size = 0;
128 static int nb_frames_dup = 0;
129 static int nb_frames_drop = 0;
130 static int input_sync;
132 static float dts_delta_threshold = 10;
134 static int print_stats = 1;
136 static uint8_t *audio_buf;
137 static uint8_t *audio_out;
138 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
140 static void *samples;
142 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
144 typedef struct InputStream {
147 int discard; /* true if stream data should be discarded */
148 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
151 int64_t start; /* time when read started */
152 int64_t next_pts; /* synthetic pts for cases where pkt.pts
154 int64_t pts; /* current pts */
155 PtsCorrectionContext pts_ctx;
157 int is_start; /* is 1 at the start and after a discontinuity */
158 int showed_multi_packet_warning;
162 typedef struct InputFile {
163 AVFormatContext *ctx;
164 int eof_reached; /* true if eof reached */
165 int ist_index; /* index of first stream in ist_table */
166 int buffer_size; /* current total buffer size */
168 int nb_streams; /* number of stream that avconv is aware of; may be different
169 from ctx.nb_streams if new streams appear during av_read_frame() */
173 typedef struct OutputStream {
174 int file_index; /* file index */
175 int index; /* stream index in the output file */
176 int source_index; /* InputStream index */
177 AVStream *st; /* stream in the output file */
178 int encoding_needed; /* true if encoding needed for this stream */
180 /* input pts and corresponding output pts
182 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
183 struct InputStream *sync_ist; /* input stream to sync against */
184 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
185 AVBitStreamFilterContext *bitstream_filters;
191 AVFrame pict_tmp; /* temporary image for resampling */
192 struct SwsContext *img_resample_ctx; /* for image resampling */
195 int resample_pix_fmt;
196 AVRational frame_rate;
200 float frame_aspect_ratio;
202 /* forced key frames */
203 int64_t *forced_kf_pts;
209 ReSampleContext *resample; /* for audio resampling */
210 int resample_sample_fmt;
211 int resample_channels;
212 int resample_sample_rate;
214 AVAudioConvert *reformat_ctx;
215 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
219 AVFilterContext *output_video_filter;
220 AVFilterContext *input_video_filter;
221 AVFilterBufferRef *picref;
223 AVFilterGraph *graph;
228 int is_past_recording_time;
230 const char *attachment_filename;
231 int copy_initial_nonkeyframes;
235 typedef struct OutputFile {
236 AVFormatContext *ctx;
238 int ost_index; /* index of the first stream in output_streams */
239 int64_t recording_time; /* desired length of the resulting file in microseconds */
240 int64_t start_time; /* start time in microseconds */
241 uint64_t limit_filesize;
244 static InputStream *input_streams = NULL;
245 static int nb_input_streams = 0;
246 static InputFile *input_files = NULL;
247 static int nb_input_files = 0;
249 static OutputStream *output_streams = NULL;
250 static int nb_output_streams = 0;
251 static OutputFile *output_files = NULL;
252 static int nb_output_files = 0;
254 typedef struct OptionsContext {
255 /* input/output options */
259 SpecifierOpt *codec_names;
261 SpecifierOpt *audio_channels;
262 int nb_audio_channels;
263 SpecifierOpt *audio_sample_rate;
264 int nb_audio_sample_rate;
265 SpecifierOpt *frame_rates;
267 SpecifierOpt *frame_sizes;
269 SpecifierOpt *frame_pix_fmts;
270 int nb_frame_pix_fmts;
273 int64_t input_ts_offset;
276 SpecifierOpt *ts_scale;
278 SpecifierOpt *dump_attachment;
279 int nb_dump_attachment;
282 StreamMap *stream_maps;
284 /* first item specifies output metadata, second is input */
285 MetadataMap (*meta_data_maps)[2];
286 int nb_meta_data_maps;
287 int metadata_global_manual;
288 int metadata_streams_manual;
289 int metadata_chapters_manual;
290 const char **attachments;
293 int chapters_input_file;
295 int64_t recording_time;
296 uint64_t limit_filesize;
302 int subtitle_disable;
305 /* indexed by output file stream index */
309 SpecifierOpt *metadata;
311 SpecifierOpt *max_frames;
313 SpecifierOpt *bitstream_filters;
314 int nb_bitstream_filters;
315 SpecifierOpt *codec_tags;
317 SpecifierOpt *sample_fmts;
319 SpecifierOpt *qscale;
321 SpecifierOpt *forced_key_frames;
322 int nb_forced_key_frames;
323 SpecifierOpt *force_fps;
325 SpecifierOpt *frame_aspect_ratios;
326 int nb_frame_aspect_ratios;
327 SpecifierOpt *rc_overrides;
329 SpecifierOpt *intra_matrices;
330 int nb_intra_matrices;
331 SpecifierOpt *inter_matrices;
332 int nb_inter_matrices;
333 SpecifierOpt *top_field_first;
334 int nb_top_field_first;
335 SpecifierOpt *presets;
337 SpecifierOpt *copy_initial_nonkeyframes;
338 int nb_copy_initial_nonkeyframes;
340 SpecifierOpt *filters;
345 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
348 for (i = 0; i < o->nb_ ## name; i++) {\
349 char *spec = o->name[i].specifier;\
350 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
351 outvar = o->name[i].u.type;\
357 static void reset_options(OptionsContext *o)
359 const OptionDef *po = options;
361 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
363 void *dst = (uint8_t*)o + po->u.off;
365 if (po->flags & OPT_SPEC) {
366 SpecifierOpt **so = dst;
367 int i, *count = (int*)(so + 1);
368 for (i = 0; i < *count; i++) {
369 av_freep(&(*so)[i].specifier);
370 if (po->flags & OPT_STRING)
371 av_freep(&(*so)[i].u.str);
375 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
380 av_freep(&o->stream_maps);
381 av_freep(&o->meta_data_maps);
382 av_freep(&o->streamid_map);
384 memset(o, 0, sizeof(*o));
386 o->mux_max_delay = 0.7;
387 o->recording_time = INT64_MAX;
388 o->limit_filesize = UINT64_MAX;
389 o->chapters_input_file = INT_MAX;
397 static int configure_video_filters(InputStream *ist, OutputStream *ost)
399 AVFilterContext *last_filter, *filter;
400 /** filter graph containing all filters including input & output */
401 AVCodecContext *codec = ost->st->codec;
402 AVCodecContext *icodec = ist->st->codec;
403 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
404 AVRational sample_aspect_ratio;
408 ost->graph = avfilter_graph_alloc();
410 if (ist->st->sample_aspect_ratio.num){
411 sample_aspect_ratio = ist->st->sample_aspect_ratio;
413 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
415 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
416 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
417 sample_aspect_ratio.num, sample_aspect_ratio.den);
419 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
420 "src", args, NULL, ost->graph);
423 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
424 "out", NULL, &ffsink_ctx, ost->graph);
427 last_filter = ost->input_video_filter;
429 if (codec->width != icodec->width || codec->height != icodec->height) {
430 snprintf(args, 255, "%d:%d:flags=0x%X",
433 (unsigned)ost->sws_flags);
434 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
435 NULL, args, NULL, ost->graph)) < 0)
437 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
439 last_filter = filter;
442 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
443 ost->graph->scale_sws_opts = av_strdup(args);
446 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
447 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
449 outputs->name = av_strdup("in");
450 outputs->filter_ctx = last_filter;
451 outputs->pad_idx = 0;
452 outputs->next = NULL;
454 inputs->name = av_strdup("out");
455 inputs->filter_ctx = ost->output_video_filter;
459 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
461 av_freep(&ost->avfilter);
463 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
467 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
470 codec->width = ost->output_video_filter->inputs[0]->w;
471 codec->height = ost->output_video_filter->inputs[0]->h;
472 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
473 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
474 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
475 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
479 #endif /* CONFIG_AVFILTER */
481 static void term_exit(void)
483 av_log(NULL, AV_LOG_QUIET, "");
486 static volatile int received_sigterm = 0;
487 static volatile int received_nb_signals = 0;
490 sigterm_handler(int sig)
492 received_sigterm = sig;
493 received_nb_signals++;
497 static void term_init(void)
499 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
500 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
502 signal(SIGXCPU, sigterm_handler);
506 static int decode_interrupt_cb(void *ctx)
508 return received_nb_signals > 1;
511 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
513 void exit_program(int ret)
518 for(i=0;i<nb_output_files;i++) {
519 AVFormatContext *s = output_files[i].ctx;
520 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
522 avformat_free_context(s);
523 av_dict_free(&output_files[i].opts);
525 for(i=0;i<nb_input_files;i++) {
526 av_close_input_file(input_files[i].ctx);
528 for (i = 0; i < nb_input_streams; i++)
529 av_dict_free(&input_streams[i].opts);
533 av_free(vstats_filename);
535 av_freep(&input_streams);
536 av_freep(&input_files);
537 av_freep(&output_streams);
538 av_freep(&output_files);
543 allocated_audio_buf_size= allocated_audio_out_size= 0;
549 avformat_network_deinit();
551 if (received_sigterm) {
552 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
553 (int) received_sigterm);
557 exit(ret); /* not all OS-es handle main() return value */
560 static void assert_avoptions(AVDictionary *m)
562 AVDictionaryEntry *t;
563 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
564 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
569 static void assert_codec_experimental(AVCodecContext *c, int encoder)
571 const char *codec_string = encoder ? "encoder" : "decoder";
573 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
574 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
575 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
576 "results.\nAdd '-strict experimental' if you want to use it.\n",
577 codec_string, c->codec->name);
578 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
579 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
580 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
581 codec_string, codec->name);
586 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
588 if(codec && codec->sample_fmts){
589 const enum AVSampleFormat *p= codec->sample_fmts;
591 if(*p == st->codec->sample_fmt)
595 av_log(NULL, AV_LOG_WARNING,
596 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
597 av_get_sample_fmt_name(st->codec->sample_fmt),
599 av_get_sample_fmt_name(codec->sample_fmts[0]));
600 st->codec->sample_fmt = codec->sample_fmts[0];
606 * Update the requested input sample format based on the output sample format.
607 * This is currently only used to request float output from decoders which
608 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
609 * Ideally this will be removed in the future when decoders do not do format
610 * conversion and only output in their native format.
612 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
615 /* if sample formats match or a decoder sample format has already been
616 requested, just return */
617 if (enc->sample_fmt == dec->sample_fmt ||
618 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
621 /* if decoder supports more than one output format */
622 if (dec_codec && dec_codec->sample_fmts &&
623 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
624 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
625 const enum AVSampleFormat *p;
626 int min_dec = -1, min_inc = -1;
628 /* find a matching sample format in the encoder */
629 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
630 if (*p == enc->sample_fmt) {
631 dec->request_sample_fmt = *p;
633 } else if (*p > enc->sample_fmt) {
634 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
636 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
639 /* if none match, provide the one that matches quality closest */
640 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
641 enc->sample_fmt - min_dec;
645 static void choose_sample_rate(AVStream *st, AVCodec *codec)
647 if(codec && codec->supported_samplerates){
648 const int *p= codec->supported_samplerates;
650 int best_dist=INT_MAX;
652 int dist= abs(st->codec->sample_rate - *p);
653 if(dist < best_dist){
659 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
661 st->codec->sample_rate= best;
665 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
667 if(codec && codec->pix_fmts){
668 const enum PixelFormat *p= codec->pix_fmts;
669 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
670 if(st->codec->codec_id==CODEC_ID_MJPEG){
671 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
672 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
673 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};
676 for (; *p != PIX_FMT_NONE; p++) {
677 if(*p == st->codec->pix_fmt)
680 if (*p == PIX_FMT_NONE) {
681 if(st->codec->pix_fmt != PIX_FMT_NONE)
682 av_log(NULL, AV_LOG_WARNING,
683 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
684 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
686 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
687 st->codec->pix_fmt = codec->pix_fmts[0];
693 get_sync_ipts(const OutputStream *ost)
695 const InputStream *ist = ost->sync_ist;
696 OutputFile *of = &output_files[ost->file_index];
697 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
700 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
704 AVPacket new_pkt= *pkt;
705 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
706 &new_pkt.data, &new_pkt.size,
707 pkt->data, pkt->size,
708 pkt->flags & AV_PKT_FLAG_KEY);
711 new_pkt.destruct= av_destruct_packet;
713 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
714 bsfc->filter->name, pkt->stream_index,
715 avctx->codec ? avctx->codec->name : "copy");
725 ret= av_interleaved_write_frame(s, pkt);
727 print_error("av_interleaved_write_frame()", ret);
732 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
734 int fill_char = 0x00;
735 if (sample_fmt == AV_SAMPLE_FMT_U8)
737 memset(buf, fill_char, size);
740 static void do_audio_out(AVFormatContext *s,
743 unsigned char *buf, int size)
746 int64_t audio_out_size, audio_buf_size;
747 int64_t allocated_for_size= size;
749 int size_out, frame_bytes, ret, resample_changed;
750 AVCodecContext *enc= ost->st->codec;
751 AVCodecContext *dec= ist->st->codec;
752 int osize = av_get_bytes_per_sample(enc->sample_fmt);
753 int isize = av_get_bytes_per_sample(dec->sample_fmt);
754 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
757 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
758 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
759 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
760 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
761 audio_buf_size*= osize*enc->channels;
763 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
764 if(coded_bps > 8*osize)
765 audio_out_size= audio_out_size * coded_bps / (8*osize);
766 audio_out_size += FF_MIN_BUFFER_SIZE;
768 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
769 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
773 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
774 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
775 if (!audio_buf || !audio_out){
776 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
780 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
781 ost->audio_resample = 1;
783 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
784 ost->resample_channels != dec->channels ||
785 ost->resample_sample_rate != dec->sample_rate;
787 if ((ost->audio_resample && !ost->resample) || resample_changed) {
788 if (resample_changed) {
789 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",
790 ist->file_index, ist->st->index,
791 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
792 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
793 ost->resample_sample_fmt = dec->sample_fmt;
794 ost->resample_channels = dec->channels;
795 ost->resample_sample_rate = dec->sample_rate;
797 audio_resample_close(ost->resample);
799 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
800 if (audio_sync_method <= 1 &&
801 ost->resample_sample_fmt == enc->sample_fmt &&
802 ost->resample_channels == enc->channels &&
803 ost->resample_sample_rate == enc->sample_rate) {
804 ost->resample = NULL;
805 ost->audio_resample = 0;
806 } else if (ost->audio_resample) {
807 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
808 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
809 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
810 enc->sample_rate, dec->sample_rate,
811 enc->sample_fmt, dec->sample_fmt,
813 if (!ost->resample) {
814 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
815 dec->channels, dec->sample_rate,
816 enc->channels, enc->sample_rate);
822 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
823 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
824 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
825 if (ost->reformat_ctx)
826 av_audio_convert_free(ost->reformat_ctx);
827 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
828 dec->sample_fmt, 1, NULL, 0);
829 if (!ost->reformat_ctx) {
830 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
831 av_get_sample_fmt_name(dec->sample_fmt),
832 av_get_sample_fmt_name(enc->sample_fmt));
835 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
838 if(audio_sync_method){
839 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
840 - av_fifo_size(ost->fifo)/(enc->channels * osize);
841 int idelta = delta * dec->sample_rate / enc->sample_rate;
842 int byte_delta = idelta * isize * dec->channels;
844 //FIXME resample delay
845 if(fabs(delta) > 50){
846 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
848 byte_delta= FFMAX(byte_delta, -size);
851 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
852 -byte_delta / (isize * dec->channels));
857 static uint8_t *input_tmp= NULL;
858 input_tmp= av_realloc(input_tmp, byte_delta + size);
860 if(byte_delta > allocated_for_size - size){
861 allocated_for_size= byte_delta + (int64_t)size;
866 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
867 memcpy(input_tmp + byte_delta, buf, size);
870 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
872 }else if(audio_sync_method>1){
873 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
874 av_assert0(ost->audio_resample);
875 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
876 delta, comp, enc->sample_rate);
877 // 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));
878 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
882 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
883 - av_fifo_size(ost->fifo)/(enc->channels * osize); //FIXME wrong
885 if (ost->audio_resample) {
887 size_out = audio_resample(ost->resample,
888 (short *)buftmp, (short *)buf,
889 size / (dec->channels * isize));
890 size_out = size_out * enc->channels * osize;
896 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
897 const void *ibuf[6]= {buftmp};
898 void *obuf[6]= {audio_buf};
899 int istride[6]= {isize};
900 int ostride[6]= {osize};
901 int len= size_out/istride[0];
902 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
903 printf("av_audio_convert() failed\n");
909 size_out = len*osize;
912 /* now encode as many frames as possible */
913 if (enc->frame_size > 1) {
914 /* output resampled raw samples */
915 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
916 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
919 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
921 frame_bytes = enc->frame_size * osize * enc->channels;
923 while (av_fifo_size(ost->fifo) >= frame_bytes) {
925 av_init_packet(&pkt);
927 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
929 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
931 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
934 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
938 pkt.stream_index= ost->index;
941 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
942 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
943 pkt.flags |= AV_PKT_FLAG_KEY;
944 write_frame(s, &pkt, enc, ost->bitstream_filters);
946 ost->sync_opts += enc->frame_size;
950 av_init_packet(&pkt);
952 ost->sync_opts += size_out / (osize * enc->channels);
954 /* output a pcm frame */
955 /* determine the size of the coded buffer */
958 size_out = size_out*coded_bps/8;
960 if(size_out > audio_out_size){
961 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
965 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
966 ret = avcodec_encode_audio(enc, audio_out, size_out,
969 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
973 pkt.stream_index= ost->index;
976 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
977 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
978 pkt.flags |= AV_PKT_FLAG_KEY;
979 write_frame(s, &pkt, enc, ost->bitstream_filters);
983 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
987 AVPicture picture_tmp;
990 dec = ist->st->codec;
992 /* deinterlace : must be done before any resize */
993 if (do_deinterlace) {
996 /* create temporary picture */
997 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
998 buf = av_malloc(size);
1002 picture2 = &picture_tmp;
1003 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1005 if(avpicture_deinterlace(picture2, picture,
1006 dec->pix_fmt, dec->width, dec->height) < 0) {
1007 /* if error, do not deinterlace */
1008 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1017 if (picture != picture2)
1018 *picture = *picture2;
1022 static void do_subtitle_out(AVFormatContext *s,
1028 static uint8_t *subtitle_out = NULL;
1029 int subtitle_out_max_size = 1024 * 1024;
1030 int subtitle_out_size, nb, i;
1031 AVCodecContext *enc;
1034 if (pts == AV_NOPTS_VALUE) {
1035 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1041 enc = ost->st->codec;
1043 if (!subtitle_out) {
1044 subtitle_out = av_malloc(subtitle_out_max_size);
1047 /* Note: DVB subtitle need one packet to draw them and one other
1048 packet to clear them */
1049 /* XXX: signal it in the codec context ? */
1050 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1055 for(i = 0; i < nb; i++) {
1056 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1057 // start_display_time is required to be 0
1058 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1059 sub->end_display_time -= sub->start_display_time;
1060 sub->start_display_time = 0;
1061 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1062 subtitle_out_max_size, sub);
1063 if (subtitle_out_size < 0) {
1064 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1068 av_init_packet(&pkt);
1069 pkt.stream_index = ost->index;
1070 pkt.data = subtitle_out;
1071 pkt.size = subtitle_out_size;
1072 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1073 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1074 /* XXX: the pts correction is handled here. Maybe handling
1075 it in the codec would be better */
1077 pkt.pts += 90 * sub->start_display_time;
1079 pkt.pts += 90 * sub->end_display_time;
1081 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1085 static int bit_buffer_size= 1024*256;
1086 static uint8_t *bit_buffer= NULL;
1088 static void do_video_resample(OutputStream *ost,
1090 AVFrame *in_picture,
1091 AVFrame **out_picture)
1093 int resample_changed = 0;
1094 AVCodecContext *dec = ist->st->codec;
1095 *out_picture = in_picture;
1097 resample_changed = ost->resample_width != dec->width ||
1098 ost->resample_height != dec->height ||
1099 ost->resample_pix_fmt != dec->pix_fmt;
1101 if (resample_changed) {
1102 av_log(NULL, AV_LOG_INFO,
1103 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1104 ist->file_index, ist->st->index,
1105 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1106 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1107 if(!ost->video_resample)
1108 ost->video_resample = 1;
1111 #if !CONFIG_AVFILTER
1112 if (ost->video_resample) {
1113 *out_picture = &ost->pict_tmp;
1114 if (resample_changed) {
1115 /* initialize a new scaler context */
1116 sws_freeContext(ost->img_resample_ctx);
1117 ost->img_resample_ctx = sws_getContext(
1118 ist->st->codec->width,
1119 ist->st->codec->height,
1120 ist->st->codec->pix_fmt,
1121 ost->st->codec->width,
1122 ost->st->codec->height,
1123 ost->st->codec->pix_fmt,
1124 ost->sws_flags, NULL, NULL, NULL);
1125 if (ost->img_resample_ctx == NULL) {
1126 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1130 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1131 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1134 if (resample_changed) {
1135 avfilter_graph_free(&ost->graph);
1136 if (configure_video_filters(ist, ost)) {
1137 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1142 if (resample_changed) {
1143 ost->resample_width = dec->width;
1144 ost->resample_height = dec->height;
1145 ost->resample_pix_fmt = dec->pix_fmt;
1150 static void do_video_out(AVFormatContext *s,
1153 AVFrame *in_picture,
1154 int *frame_size, float quality)
1156 int nb_frames, i, ret, format_video_sync;
1157 AVFrame *final_picture;
1158 AVCodecContext *enc;
1161 enc = ost->st->codec;
1163 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1165 /* by default, we output a single frame */
1170 format_video_sync = video_sync_method;
1171 if (format_video_sync < 0)
1172 format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? 0 :
1173 (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1175 if (format_video_sync) {
1176 double vdelta = sync_ipts - ost->sync_opts;
1177 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1180 else if (format_video_sync == 2) {
1183 }else if(vdelta>0.6)
1184 ost->sync_opts= lrintf(sync_ipts);
1185 }else if (vdelta > 1.1)
1186 nb_frames = lrintf(vdelta);
1187 //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);
1188 if (nb_frames == 0){
1190 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1191 }else if (nb_frames > 1) {
1192 nb_frames_dup += nb_frames - 1;
1193 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1196 ost->sync_opts= lrintf(sync_ipts);
1198 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1202 do_video_resample(ost, ist, in_picture, &final_picture);
1204 /* duplicates frame if needed */
1205 for(i=0;i<nb_frames;i++) {
1207 av_init_packet(&pkt);
1208 pkt.stream_index= ost->index;
1210 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1211 /* raw pictures are written as AVPicture structure to
1212 avoid any copies. We support temporarily the older
1214 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1215 enc->coded_frame->top_field_first = in_picture->top_field_first;
1216 pkt.data= (uint8_t *)final_picture;
1217 pkt.size= sizeof(AVPicture);
1218 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1219 pkt.flags |= AV_PKT_FLAG_KEY;
1221 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1223 AVFrame big_picture;
1225 big_picture= *final_picture;
1226 /* better than nothing: use input picture interlaced
1228 big_picture.interlaced_frame = in_picture->interlaced_frame;
1229 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1230 if (ost->top_field_first == -1)
1231 big_picture.top_field_first = in_picture->top_field_first;
1233 big_picture.top_field_first = !!ost->top_field_first;
1236 /* handles same_quant here. This is not correct because it may
1237 not be a global option */
1238 big_picture.quality = quality;
1239 if (!enc->me_threshold)
1240 big_picture.pict_type = 0;
1241 // big_picture.pts = AV_NOPTS_VALUE;
1242 big_picture.pts= ost->sync_opts;
1243 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1244 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1245 if (ost->forced_kf_index < ost->forced_kf_count &&
1246 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1247 big_picture.pict_type = AV_PICTURE_TYPE_I;
1248 ost->forced_kf_index++;
1250 ret = avcodec_encode_video(enc,
1251 bit_buffer, bit_buffer_size,
1254 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1259 pkt.data= bit_buffer;
1261 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1262 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1263 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1264 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1265 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1267 if(enc->coded_frame->key_frame)
1268 pkt.flags |= AV_PKT_FLAG_KEY;
1269 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1272 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1273 // enc->frame_number-1, ret, enc->pict_type);
1274 /* if two pass, output log */
1275 if (ost->logfile && enc->stats_out) {
1276 fprintf(ost->logfile, "%s", enc->stats_out);
1281 ost->frame_number++;
1285 static double psnr(double d){
1286 return -10.0*log(d)/log(10.0);
1289 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1292 AVCodecContext *enc;
1294 double ti1, bitrate, avg_bitrate;
1296 /* this is executed just the first time do_video_stats is called */
1298 vstats_file = fopen(vstats_filename, "w");
1305 enc = ost->st->codec;
1306 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1307 frame_number = ost->frame_number;
1308 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1309 if (enc->flags&CODEC_FLAG_PSNR)
1310 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1312 fprintf(vstats_file,"f_size= %6d ", frame_size);
1313 /* compute pts value */
1314 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1318 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1319 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1320 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1321 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1322 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1326 static void print_report(OutputFile *output_files,
1327 OutputStream *ost_table, int nb_ostreams,
1328 int is_last_report, int64_t timer_start)
1332 AVFormatContext *oc;
1334 AVCodecContext *enc;
1335 int frame_number, vid, i;
1336 double bitrate, ti1, pts;
1337 static int64_t last_time = -1;
1338 static int qp_histogram[52];
1340 if (!print_stats && !is_last_report)
1343 if (!is_last_report) {
1345 /* display the report every 0.5 seconds */
1346 cur_time = av_gettime();
1347 if (last_time == -1) {
1348 last_time = cur_time;
1351 if ((cur_time - last_time) < 500000)
1353 last_time = cur_time;
1357 oc = output_files[0].ctx;
1359 total_size = avio_size(oc->pb);
1360 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1361 total_size= avio_tell(oc->pb);
1366 for(i=0;i<nb_ostreams;i++) {
1368 ost = &ost_table[i];
1369 enc = ost->st->codec;
1370 if (!ost->stream_copy && enc->coded_frame)
1371 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1372 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1373 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1375 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1376 float t = (av_gettime()-timer_start) / 1000000.0;
1378 frame_number = ost->frame_number;
1379 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1380 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1382 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1386 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1389 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1391 if (enc->flags&CODEC_FLAG_PSNR){
1393 double error, error_sum=0;
1394 double scale, scale_sum=0;
1395 char type[3]= {'Y','U','V'};
1396 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1399 error= enc->error[j];
1400 scale= enc->width*enc->height*255.0*255.0*frame_number;
1402 error= enc->coded_frame->error[j];
1403 scale= enc->width*enc->height*255.0*255.0;
1408 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1410 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1414 /* compute min output value */
1415 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1416 if ((pts < ti1) && (pts > 0))
1422 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1424 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1425 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1426 (double)total_size / 1024, ti1, bitrate);
1428 if (nb_frames_dup || nb_frames_drop)
1429 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1430 nb_frames_dup, nb_frames_drop);
1432 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1436 if (is_last_report) {
1437 int64_t raw= audio_size + video_size + extra_size;
1438 av_log(NULL, AV_LOG_INFO, "\n");
1439 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1443 100.0*(total_size - raw)/raw
1448 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1452 for (i = 0; i < nb_ostreams; i++) {
1453 OutputStream *ost = &ost_table[i];
1454 AVCodecContext *enc = ost->st->codec;
1455 AVFormatContext *os = output_files[ost->file_index].ctx;
1457 if (!ost->encoding_needed)
1460 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1462 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1468 av_init_packet(&pkt);
1469 pkt.stream_index= ost->index;
1471 switch (ost->st->codec->codec_type) {
1472 case AVMEDIA_TYPE_AUDIO:
1473 fifo_bytes = av_fifo_size(ost->fifo);
1475 /* encode any samples remaining in fifo */
1476 if (fifo_bytes > 0) {
1477 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1478 int fs_tmp = enc->frame_size;
1480 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1481 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1482 enc->frame_size = fifo_bytes / (osize * enc->channels);
1484 int frame_bytes = enc->frame_size*osize*enc->channels;
1485 if (allocated_audio_buf_size < frame_bytes)
1487 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1490 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1491 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1492 ost->st->time_base.num, enc->sample_rate);
1493 enc->frame_size = fs_tmp;
1496 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1499 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1503 pkt.flags |= AV_PKT_FLAG_KEY;
1505 case AVMEDIA_TYPE_VIDEO:
1506 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1508 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1512 if(enc->coded_frame && enc->coded_frame->key_frame)
1513 pkt.flags |= AV_PKT_FLAG_KEY;
1514 if (ost->logfile && enc->stats_out) {
1515 fprintf(ost->logfile, "%s", enc->stats_out);
1524 pkt.data = bit_buffer;
1526 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1527 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1528 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1534 * Check whether a packet from ist should be written into ost at this time
1536 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1538 OutputFile *of = &output_files[ost->file_index];
1539 int ist_index = ist - input_streams;
1541 if (ost->source_index != ist_index)
1544 if (of->start_time && ist->pts < of->start_time)
1547 if (of->recording_time != INT64_MAX &&
1548 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1549 (AVRational){1, 1000000}) >= 0) {
1550 ost->is_past_recording_time = 1;
1557 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1559 OutputFile *of = &output_files[ost->file_index];
1560 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1563 av_init_packet(&opkt);
1565 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1566 !ost->copy_initial_nonkeyframes)
1569 /* force the input stream PTS */
1570 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1571 audio_size += pkt->size;
1572 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1573 video_size += pkt->size;
1577 opkt.stream_index = ost->index;
1578 if (pkt->pts != AV_NOPTS_VALUE)
1579 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1581 opkt.pts = AV_NOPTS_VALUE;
1583 if (pkt->dts == AV_NOPTS_VALUE)
1584 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1586 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1587 opkt.dts -= ost_tb_start_time;
1589 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1590 opkt.flags = pkt->flags;
1592 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1593 if( ost->st->codec->codec_id != CODEC_ID_H264
1594 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1595 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1597 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1598 opkt.destruct = av_destruct_packet;
1600 opkt.data = pkt->data;
1601 opkt.size = pkt->size;
1604 write_frame(of->ctx, &opkt, ost->st->codec, ost->bitstream_filters);
1605 ost->st->codec->frame_number++;
1606 ost->frame_number++;
1607 av_free_packet(&opkt);
1610 static void rate_emu_sleep(InputStream *ist)
1612 if (input_files[ist->file_index].rate_emu) {
1613 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1614 int64_t now = av_gettime() - ist->start;
1620 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1622 static unsigned int samples_size = 0;
1623 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1624 uint8_t *decoded_data_buf = NULL;
1625 int decoded_data_size = 0;
1628 if (pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1630 samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1631 samples = av_malloc(samples_size);
1633 decoded_data_size = samples_size;
1635 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1639 *got_output = decoded_data_size > 0;
1641 /* Some bug in mpeg audio decoder gives */
1642 /* decoded_data_size < 0, it seems they are overflows */
1644 /* no audio frame */
1648 decoded_data_buf = (uint8_t *)samples;
1649 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1650 (ist->st->codec->sample_rate * ist->st->codec->channels);
1652 // preprocess audio (volume)
1653 if (audio_volume != 256) {
1654 switch (ist->st->codec->sample_fmt) {
1655 case AV_SAMPLE_FMT_U8:
1657 uint8_t *volp = samples;
1658 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1659 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1660 *volp++ = av_clip_uint8(v);
1664 case AV_SAMPLE_FMT_S16:
1666 int16_t *volp = samples;
1667 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1668 int v = ((*volp) * audio_volume + 128) >> 8;
1669 *volp++ = av_clip_int16(v);
1673 case AV_SAMPLE_FMT_S32:
1675 int32_t *volp = samples;
1676 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1677 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1678 *volp++ = av_clipl_int32(v);
1682 case AV_SAMPLE_FMT_FLT:
1684 float *volp = samples;
1685 float scale = audio_volume / 256.f;
1686 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1691 case AV_SAMPLE_FMT_DBL:
1693 double *volp = samples;
1694 double scale = audio_volume / 256.;
1695 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1701 av_log(NULL, AV_LOG_FATAL,
1702 "Audio volume adjustment on sample format %s is not supported.\n",
1703 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1708 rate_emu_sleep(ist);
1710 for (i = 0; i < nb_output_streams; i++) {
1711 OutputStream *ost = &output_streams[i];
1713 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1715 do_audio_out(output_files[ost->file_index].ctx, ost, ist,
1716 decoded_data_buf, decoded_data_size);
1721 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
1723 AVFrame *decoded_frame, *filtered_frame = NULL;
1724 void *buffer_to_free = NULL;
1728 int frame_available = 1;
1731 if (!(decoded_frame = avcodec_alloc_frame()))
1732 return AVERROR(ENOMEM);
1733 pkt->pts = *pkt_pts;
1734 pkt->dts = ist->pts;
1735 *pkt_pts = AV_NOPTS_VALUE;
1737 ret = avcodec_decode_video2(ist->st->codec,
1738 decoded_frame, got_output, pkt);
1742 quality = same_quant ? decoded_frame->quality : 0;
1744 /* no picture yet */
1745 av_freep(&decoded_frame);
1748 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1749 decoded_frame->pkt_dts);
1751 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
1752 else if (ist->st->codec->time_base.num != 0) {
1753 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1754 ist->st->codec->ticks_per_frame;
1755 ist->next_pts += ((int64_t)AV_TIME_BASE *
1756 ist->st->codec->time_base.num * ticks) /
1757 ist->st->codec->time_base.den;
1760 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1762 rate_emu_sleep(ist);
1764 for (i = 0; i < nb_output_streams; i++) {
1765 OutputStream *ost = &output_streams[i];
1768 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1772 if (ost->input_video_filter) {
1774 if (ist->st->sample_aspect_ratio.num)
1775 sar = ist->st->sample_aspect_ratio;
1777 sar = ist->st->codec->sample_aspect_ratio;
1778 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, ist->pts, sar);
1779 if (!(filtered_frame = avcodec_alloc_frame())) {
1780 ret = AVERROR(ENOMEM);
1783 frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1785 while (frame_available) {
1786 AVRational ist_pts_tb;
1787 if (ost->output_video_filter)
1788 get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
1790 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1791 if (ost->picref->video && !ost->frame_aspect_ratio)
1792 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1794 filtered_frame = decoded_frame;
1797 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
1798 same_quant ? quality : ost->st->codec->global_quality);
1799 if (vstats_filename && frame_size)
1800 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
1802 frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1804 avfilter_unref_buffer(ost->picref);
1806 av_freep(&filtered_frame);
1811 av_free(buffer_to_free);
1812 av_freep(&decoded_frame);
1816 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1818 AVSubtitle subtitle;
1819 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1820 &subtitle, got_output, pkt);
1826 rate_emu_sleep(ist);
1828 for (i = 0; i < nb_output_streams; i++) {
1829 OutputStream *ost = &output_streams[i];
1831 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1834 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
1837 avsubtitle_free(&subtitle);
1841 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1842 static int output_packet(InputStream *ist,
1843 OutputStream *ost_table, int nb_ostreams,
1844 const AVPacket *pkt)
1848 int64_t pkt_pts = AV_NOPTS_VALUE;
1851 if (ist->next_pts == AV_NOPTS_VALUE)
1852 ist->next_pts = ist->pts;
1856 av_init_packet(&avpkt);
1864 if(pkt->dts != AV_NOPTS_VALUE)
1865 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1866 if(pkt->pts != AV_NOPTS_VALUE)
1867 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1869 //while we have more to decode or while the decoder did output something on EOF
1870 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
1874 ist->pts = ist->next_pts;
1876 if (avpkt.size && avpkt.size != pkt->size) {
1877 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1878 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1879 ist->showed_multi_packet_warning = 1;
1882 switch(ist->st->codec->codec_type) {
1883 case AVMEDIA_TYPE_AUDIO:
1884 ret = transcode_audio (ist, &avpkt, &got_output);
1886 case AVMEDIA_TYPE_VIDEO:
1887 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
1889 case AVMEDIA_TYPE_SUBTITLE:
1890 ret = transcode_subtitles(ist, &avpkt, &got_output);
1898 // touch data and size only if not EOF
1908 /* handle stream copy */
1909 if (!ist->decoding_needed) {
1910 rate_emu_sleep(ist);
1911 ist->pts = ist->next_pts;
1912 switch (ist->st->codec->codec_type) {
1913 case AVMEDIA_TYPE_AUDIO:
1914 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1915 ist->st->codec->sample_rate;
1917 case AVMEDIA_TYPE_VIDEO:
1918 if (ist->st->codec->time_base.num != 0) {
1919 int ticks = ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1920 ist->next_pts += ((int64_t)AV_TIME_BASE *
1921 ist->st->codec->time_base.num * ticks) /
1922 ist->st->codec->time_base.den;
1927 for (i = 0; pkt && i < nb_ostreams; i++) {
1928 OutputStream *ost = &ost_table[i];
1930 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
1933 do_streamcopy(ist, ost, pkt);
1939 static void print_sdp(OutputFile *output_files, int n)
1943 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1947 for (i = 0; i < n; i++)
1948 avc[i] = output_files[i].ctx;
1950 av_sdp_create(avc, n, sdp, sizeof(sdp));
1951 printf("SDP:\n%s\n", sdp);
1956 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1957 char *error, int error_len)
1960 InputStream *ist = &input_streams[ist_index];
1961 if (ist->decoding_needed) {
1962 AVCodec *codec = ist->dec;
1964 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
1965 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1966 return AVERROR(EINVAL);
1969 /* update requested sample format for the decoder based on the
1970 corresponding encoder sample format */
1971 for (i = 0; i < nb_output_streams; i++) {
1972 OutputStream *ost = &output_streams[i];
1973 if (ost->source_index == ist_index) {
1974 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1979 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1980 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
1981 ist->file_index, ist->st->index);
1982 return AVERROR(EINVAL);
1984 assert_codec_experimental(ist->st->codec, 0);
1985 assert_avoptions(ist->opts);
1988 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;
1989 ist->next_pts = AV_NOPTS_VALUE;
1990 init_pts_correction(&ist->pts_ctx);
1996 static int transcode_init(OutputFile *output_files,
1997 int nb_output_files,
1998 InputFile *input_files,
2001 int ret = 0, i, j, k;
2002 AVFormatContext *oc;
2003 AVCodecContext *codec, *icodec;
2009 /* init framerate emulation */
2010 for (i = 0; i < nb_input_files; i++) {
2011 InputFile *ifile = &input_files[i];
2012 if (ifile->rate_emu)
2013 for (j = 0; j < ifile->nb_streams; j++)
2014 input_streams[j + ifile->ist_index].start = av_gettime();
2017 /* output stream init */
2018 for (i = 0; i < nb_output_files; i++) {
2019 oc = output_files[i].ctx;
2020 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2021 av_dump_format(oc, i, oc->filename, 1);
2022 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2023 return AVERROR(EINVAL);
2027 /* for each output stream, we compute the right encoding parameters */
2028 for (i = 0; i < nb_output_streams; i++) {
2029 ost = &output_streams[i];
2030 oc = output_files[ost->file_index].ctx;
2031 ist = &input_streams[ost->source_index];
2033 if (ost->attachment_filename)
2036 codec = ost->st->codec;
2037 icodec = ist->st->codec;
2039 ost->st->disposition = ist->st->disposition;
2040 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2041 codec->chroma_sample_location = icodec->chroma_sample_location;
2043 if (ost->stream_copy) {
2044 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2046 if (extra_size > INT_MAX) {
2047 return AVERROR(EINVAL);
2050 /* if stream_copy is selected, no need to decode or encode */
2051 codec->codec_id = icodec->codec_id;
2052 codec->codec_type = icodec->codec_type;
2054 if (!codec->codec_tag) {
2055 if (!oc->oformat->codec_tag ||
2056 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2057 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2058 codec->codec_tag = icodec->codec_tag;
2061 codec->bit_rate = icodec->bit_rate;
2062 codec->rc_max_rate = icodec->rc_max_rate;
2063 codec->rc_buffer_size = icodec->rc_buffer_size;
2064 codec->extradata = av_mallocz(extra_size);
2065 if (!codec->extradata) {
2066 return AVERROR(ENOMEM);
2068 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2069 codec->extradata_size = icodec->extradata_size;
2071 codec->time_base = icodec->time_base;
2072 codec->time_base.num *= icodec->ticks_per_frame;
2073 av_reduce(&codec->time_base.num, &codec->time_base.den,
2074 codec->time_base.num, codec->time_base.den, INT_MAX);
2076 codec->time_base = ist->st->time_base;
2078 switch(codec->codec_type) {
2079 case AVMEDIA_TYPE_AUDIO:
2080 if(audio_volume != 256) {
2081 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2084 codec->channel_layout = icodec->channel_layout;
2085 codec->sample_rate = icodec->sample_rate;
2086 codec->channels = icodec->channels;
2087 codec->frame_size = icodec->frame_size;
2088 codec->audio_service_type = icodec->audio_service_type;
2089 codec->block_align = icodec->block_align;
2091 case AVMEDIA_TYPE_VIDEO:
2092 codec->pix_fmt = icodec->pix_fmt;
2093 codec->width = icodec->width;
2094 codec->height = icodec->height;
2095 codec->has_b_frames = icodec->has_b_frames;
2096 if (!codec->sample_aspect_ratio.num) {
2097 codec->sample_aspect_ratio =
2098 ost->st->sample_aspect_ratio =
2099 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2100 ist->st->codec->sample_aspect_ratio.num ?
2101 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2104 case AVMEDIA_TYPE_SUBTITLE:
2105 codec->width = icodec->width;
2106 codec->height = icodec->height;
2108 case AVMEDIA_TYPE_DATA:
2109 case AVMEDIA_TYPE_ATTACHMENT:
2116 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2118 ist->decoding_needed = 1;
2119 ost->encoding_needed = 1;
2121 switch(codec->codec_type) {
2122 case AVMEDIA_TYPE_AUDIO:
2123 ost->fifo = av_fifo_alloc(1024);
2125 return AVERROR(ENOMEM);
2127 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2129 if (!codec->sample_rate)
2130 codec->sample_rate = icodec->sample_rate;
2131 choose_sample_rate(ost->st, ost->enc);
2132 codec->time_base = (AVRational){1, codec->sample_rate};
2134 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2135 codec->sample_fmt = icodec->sample_fmt;
2136 choose_sample_fmt(ost->st, ost->enc);
2138 if (!codec->channels)
2139 codec->channels = icodec->channels;
2140 codec->channel_layout = icodec->channel_layout;
2141 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2142 codec->channel_layout = 0;
2144 ost->audio_resample = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2145 icodec->request_channels = codec-> channels;
2146 ost->resample_sample_fmt = icodec->sample_fmt;
2147 ost->resample_sample_rate = icodec->sample_rate;
2148 ost->resample_channels = icodec->channels;
2150 case AVMEDIA_TYPE_VIDEO:
2151 if (codec->pix_fmt == PIX_FMT_NONE)
2152 codec->pix_fmt = icodec->pix_fmt;
2153 choose_pixel_fmt(ost->st, ost->enc);
2155 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2156 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2160 if (!codec->width || !codec->height) {
2161 codec->width = icodec->width;
2162 codec->height = icodec->height;
2165 ost->video_resample = codec->width != icodec->width ||
2166 codec->height != icodec->height ||
2167 codec->pix_fmt != icodec->pix_fmt;
2168 if (ost->video_resample) {
2169 #if !CONFIG_AVFILTER
2170 avcodec_get_frame_defaults(&ost->pict_tmp);
2171 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2172 codec->width, codec->height)) {
2173 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2176 ost->img_resample_ctx = sws_getContext(
2183 ost->sws_flags, NULL, NULL, NULL);
2184 if (ost->img_resample_ctx == NULL) {
2185 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2189 codec->bits_per_raw_sample= 0;
2192 ost->resample_height = icodec->height;
2193 ost->resample_width = icodec->width;
2194 ost->resample_pix_fmt = icodec->pix_fmt;
2196 if (!ost->frame_rate.num)
2197 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2198 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2199 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2200 ost->frame_rate = ost->enc->supported_framerates[idx];
2202 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2205 if (configure_video_filters(ist, ost)) {
2206 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2211 case AVMEDIA_TYPE_SUBTITLE:
2218 if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2219 char logfilename[1024];
2222 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2223 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2225 if (codec->flags & CODEC_FLAG_PASS1) {
2226 f = fopen(logfilename, "wb");
2228 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2229 logfilename, strerror(errno));
2235 size_t logbuffer_size;
2236 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2237 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2241 codec->stats_in = logbuffer;
2245 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2246 int size = codec->width * codec->height;
2247 bit_buffer_size = FFMAX(bit_buffer_size, 6*size + 200);
2252 bit_buffer = av_malloc(bit_buffer_size);
2254 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2256 return AVERROR(ENOMEM);
2259 /* open each encoder */
2260 for (i = 0; i < nb_output_streams; i++) {
2261 ost = &output_streams[i];
2262 if (ost->encoding_needed) {
2263 AVCodec *codec = ost->enc;
2264 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2266 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2267 ost->st->codec->codec_id, ost->file_index, ost->index);
2268 ret = AVERROR(EINVAL);
2271 if (dec->subtitle_header) {
2272 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2273 if (!ost->st->codec->subtitle_header) {
2274 ret = AVERROR(ENOMEM);
2277 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2278 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2280 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2281 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2282 ost->file_index, ost->index);
2283 ret = AVERROR(EINVAL);
2286 assert_codec_experimental(ost->st->codec, 1);
2287 assert_avoptions(ost->opts);
2288 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2289 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2290 "It takes bits/s as argument, not kbits/s\n");
2291 extra_size += ost->st->codec->extradata_size;
2293 if (ost->st->codec->me_threshold)
2294 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2298 /* init input streams */
2299 for (i = 0; i < nb_input_streams; i++)
2300 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2303 /* discard unused programs */
2304 for (i = 0; i < nb_input_files; i++) {
2305 InputFile *ifile = &input_files[i];
2306 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2307 AVProgram *p = ifile->ctx->programs[j];
2308 int discard = AVDISCARD_ALL;
2310 for (k = 0; k < p->nb_stream_indexes; k++)
2311 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2312 discard = AVDISCARD_DEFAULT;
2315 p->discard = discard;
2319 /* open files and write file headers */
2320 for (i = 0; i < nb_output_files; i++) {
2321 oc = output_files[i].ctx;
2322 oc->interrupt_callback = int_cb;
2323 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2324 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2325 ret = AVERROR(EINVAL);
2328 assert_avoptions(output_files[i].opts);
2329 if (strcmp(oc->oformat->name, "rtp")) {
2335 /* dump the file output parameters - cannot be done before in case
2337 for (i = 0; i < nb_output_files; i++) {
2338 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2341 /* dump the stream mapping */
2342 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2343 for (i = 0; i < nb_output_streams; i++) {
2344 ost = &output_streams[i];
2346 if (ost->attachment_filename) {
2347 /* an attached file */
2348 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2349 ost->attachment_filename, ost->file_index, ost->index);
2352 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2353 input_streams[ost->source_index].file_index,
2354 input_streams[ost->source_index].st->index,
2357 if (ost->sync_ist != &input_streams[ost->source_index])
2358 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2359 ost->sync_ist->file_index,
2360 ost->sync_ist->st->index);
2361 if (ost->stream_copy)
2362 av_log(NULL, AV_LOG_INFO, " (copy)");
2364 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2365 input_streams[ost->source_index].dec->name : "?",
2366 ost->enc ? ost->enc->name : "?");
2367 av_log(NULL, AV_LOG_INFO, "\n");
2371 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2376 print_sdp(output_files, nb_output_files);
2383 * The following code is the main loop of the file converter
2385 static int transcode(OutputFile *output_files,
2386 int nb_output_files,
2387 InputFile *input_files,
2391 AVFormatContext *is, *os;
2395 int no_packet_count=0;
2396 int64_t timer_start;
2398 if (!(no_packet = av_mallocz(nb_input_files)))
2401 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2405 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2408 timer_start = av_gettime();
2410 for(; received_sigterm == 0;) {
2411 int file_index, ist_index;
2416 ipts_min = INT64_MAX;
2419 /* select the stream that we must read now by looking at the
2420 smallest output pts */
2422 for (i = 0; i < nb_output_streams; i++) {
2426 ost = &output_streams[i];
2427 of = &output_files[ost->file_index];
2428 os = output_files[ost->file_index].ctx;
2429 ist = &input_streams[ost->source_index];
2430 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2431 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2433 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2435 if (!input_files[ist->file_index].eof_reached){
2436 if(ipts < ipts_min) {
2438 if(input_sync ) file_index = ist->file_index;
2440 if(opts < opts_min) {
2442 if(!input_sync) file_index = ist->file_index;
2445 if (ost->frame_number >= ost->max_frames) {
2447 for (j = 0; j < of->ctx->nb_streams; j++)
2448 output_streams[of->ost_index + j].is_past_recording_time = 1;
2452 /* if none, if is finished */
2453 if (file_index < 0) {
2454 if(no_packet_count){
2456 memset(no_packet, 0, nb_input_files);
2463 /* read a frame from it and output it in the fifo */
2464 is = input_files[file_index].ctx;
2465 ret= av_read_frame(is, &pkt);
2466 if(ret == AVERROR(EAGAIN)){
2467 no_packet[file_index]=1;
2472 input_files[file_index].eof_reached = 1;
2480 memset(no_packet, 0, nb_input_files);
2483 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2484 is->streams[pkt.stream_index]);
2486 /* the following test is needed in case new streams appear
2487 dynamically in stream : we ignore them */
2488 if (pkt.stream_index >= input_files[file_index].nb_streams)
2489 goto discard_packet;
2490 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2491 ist = &input_streams[ist_index];
2493 goto discard_packet;
2495 if (pkt.dts != AV_NOPTS_VALUE)
2496 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2497 if (pkt.pts != AV_NOPTS_VALUE)
2498 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2500 if(pkt.pts != AV_NOPTS_VALUE)
2501 pkt.pts *= ist->ts_scale;
2502 if(pkt.dts != AV_NOPTS_VALUE)
2503 pkt.dts *= ist->ts_scale;
2505 // 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);
2506 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2507 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2508 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2509 int64_t delta= pkt_dts - ist->next_pts;
2510 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2511 input_files[ist->file_index].ts_offset -= delta;
2512 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2513 delta, input_files[ist->file_index].ts_offset);
2514 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2515 if(pkt.pts != AV_NOPTS_VALUE)
2516 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2520 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2521 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2523 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2524 ist->file_index, ist->st->index);
2527 av_free_packet(&pkt);
2532 av_free_packet(&pkt);
2534 /* dump report by using the output first video and audio streams */
2535 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2538 /* at the end of stream, we must flush the decoder buffers */
2539 for (i = 0; i < nb_input_streams; i++) {
2540 ist = &input_streams[i];
2541 if (ist->decoding_needed) {
2542 output_packet(ist, output_streams, nb_output_streams, NULL);
2545 flush_encoders(output_streams, nb_output_streams);
2549 /* write the trailer if needed and close file */
2550 for(i=0;i<nb_output_files;i++) {
2551 os = output_files[i].ctx;
2552 av_write_trailer(os);
2555 /* dump report by using the first video and audio streams */
2556 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2558 /* close each encoder */
2559 for (i = 0; i < nb_output_streams; i++) {
2560 ost = &output_streams[i];
2561 if (ost->encoding_needed) {
2562 av_freep(&ost->st->codec->stats_in);
2563 avcodec_close(ost->st->codec);
2566 avfilter_graph_free(&ost->graph);
2570 /* close each decoder */
2571 for (i = 0; i < nb_input_streams; i++) {
2572 ist = &input_streams[i];
2573 if (ist->decoding_needed) {
2574 avcodec_close(ist->st->codec);
2582 av_freep(&bit_buffer);
2583 av_freep(&no_packet);
2585 if (output_streams) {
2586 for (i = 0; i < nb_output_streams; i++) {
2587 ost = &output_streams[i];
2589 if (ost->stream_copy)
2590 av_freep(&ost->st->codec->extradata);
2592 fclose(ost->logfile);
2593 ost->logfile = NULL;
2595 av_fifo_free(ost->fifo); /* works even if fifo is not
2596 initialized but set to zero */
2597 av_freep(&ost->st->codec->subtitle_header);
2598 av_free(ost->pict_tmp.data[0]);
2599 av_free(ost->forced_kf_pts);
2600 if (ost->video_resample)
2601 sws_freeContext(ost->img_resample_ctx);
2603 audio_resample_close(ost->resample);
2604 if (ost->reformat_ctx)
2605 av_audio_convert_free(ost->reformat_ctx);
2606 av_dict_free(&ost->opts);
2613 static double parse_frame_aspect_ratio(const char *arg)
2620 p = strchr(arg, ':');
2622 x = strtol(arg, &end, 10);
2624 y = strtol(end+1, &end, 10);
2626 ar = (double)x / (double)y;
2628 ar = strtod(arg, NULL);
2631 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2637 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2639 return parse_option(o, "codec:a", arg, options);
2642 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2644 return parse_option(o, "codec:v", arg, options);
2647 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2649 return parse_option(o, "codec:s", arg, options);
2652 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2654 return parse_option(o, "codec:d", arg, options);
2657 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2659 StreamMap *m = NULL;
2660 int i, negative = 0, file_idx;
2661 int sync_file_idx = -1, sync_stream_idx;
2669 map = av_strdup(arg);
2671 /* parse sync stream first, just pick first matching stream */
2672 if (sync = strchr(map, ',')) {
2674 sync_file_idx = strtol(sync + 1, &sync, 0);
2675 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2676 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2681 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2682 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2683 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2684 sync_stream_idx = i;
2687 if (i == input_files[sync_file_idx].nb_streams) {
2688 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2689 "match any streams.\n", arg);
2695 file_idx = strtol(map, &p, 0);
2696 if (file_idx >= nb_input_files || file_idx < 0) {
2697 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2701 /* disable some already defined maps */
2702 for (i = 0; i < o->nb_stream_maps; i++) {
2703 m = &o->stream_maps[i];
2704 if (file_idx == m->file_index &&
2705 check_stream_specifier(input_files[m->file_index].ctx,
2706 input_files[m->file_index].ctx->streams[m->stream_index],
2707 *p == ':' ? p + 1 : p) > 0)
2711 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2712 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2713 *p == ':' ? p + 1 : p) <= 0)
2715 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2716 &o->nb_stream_maps, o->nb_stream_maps + 1);
2717 m = &o->stream_maps[o->nb_stream_maps - 1];
2719 m->file_index = file_idx;
2720 m->stream_index = i;
2722 if (sync_file_idx >= 0) {
2723 m->sync_file_index = sync_file_idx;
2724 m->sync_stream_index = sync_stream_idx;
2726 m->sync_file_index = file_idx;
2727 m->sync_stream_index = i;
2732 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2740 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
2742 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
2743 &o->nb_attachments, o->nb_attachments + 1);
2744 o->attachments[o->nb_attachments - 1] = arg;
2748 static void parse_meta_type(char *arg, char *type, int *index)
2758 if (*(++arg) == ':')
2759 *index = strtol(++arg, NULL, 0);
2762 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2769 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2771 MetadataMap *m, *m1;
2774 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2775 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2777 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2778 m->file = strtol(arg, &p, 0);
2779 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2781 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2782 if (p = strchr(opt, ':'))
2783 parse_meta_type(p + 1, &m1->type, &m1->index);
2787 if (m->type == 'g' || m1->type == 'g')
2788 o->metadata_global_manual = 1;
2789 if (m->type == 's' || m1->type == 's')
2790 o->metadata_streams_manual = 1;
2791 if (m->type == 'c' || m1->type == 'c')
2792 o->metadata_chapters_manual = 1;
2797 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2799 const char *codec_string = encoder ? "encoder" : "decoder";
2803 avcodec_find_encoder_by_name(name) :
2804 avcodec_find_decoder_by_name(name);
2806 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2809 if(codec->type != type) {
2810 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2816 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
2818 char *codec_name = NULL;
2820 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2822 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
2823 st->codec->codec_id = codec->id;
2826 return avcodec_find_decoder(st->codec->codec_id);
2830 * Add all the streams from the given input file to the global
2831 * list of input streams.
2833 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2835 int i, rfps, rfps_base;
2837 for (i = 0; i < ic->nb_streams; i++) {
2838 AVStream *st = ic->streams[i];
2839 AVCodecContext *dec = st->codec;
2842 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2843 ist = &input_streams[nb_input_streams - 1];
2845 ist->file_index = nb_input_files;
2847 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2849 ist->ts_scale = 1.0;
2850 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
2852 ist->dec = choose_decoder(o, ic, st);
2854 switch (dec->codec_type) {
2855 case AVMEDIA_TYPE_AUDIO:
2856 if (o->audio_disable)
2857 st->discard= AVDISCARD_ALL;
2859 case AVMEDIA_TYPE_VIDEO:
2860 rfps = ic->streams[i]->r_frame_rate.num;
2861 rfps_base = ic->streams[i]->r_frame_rate.den;
2863 dec->flags |= CODEC_FLAG_EMU_EDGE;
2864 dec->height >>= dec->lowres;
2865 dec->width >>= dec->lowres;
2868 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2870 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",
2871 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2872 (float)rfps / rfps_base, rfps, rfps_base);
2875 if (o->video_disable)
2876 st->discard= AVDISCARD_ALL;
2877 else if(video_discard)
2878 st->discard= video_discard;
2880 case AVMEDIA_TYPE_DATA:
2882 case AVMEDIA_TYPE_SUBTITLE:
2883 if (o->subtitle_disable)
2884 st->discard = AVDISCARD_ALL;
2886 case AVMEDIA_TYPE_ATTACHMENT:
2887 case AVMEDIA_TYPE_UNKNOWN:
2895 static void assert_file_overwrite(const char *filename)
2897 if (!file_overwrite &&
2898 (strchr(filename, ':') == NULL || filename[1] == ':' ||
2899 av_strstart(filename, "file:", NULL))) {
2900 if (avio_check(filename, 0) == 0) {
2902 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
2904 if (!read_yesno()) {
2905 fprintf(stderr, "Not overwriting - exiting\n");
2910 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
2917 static void dump_attachment(AVStream *st, const char *filename)
2920 AVIOContext *out = NULL;
2921 AVDictionaryEntry *e;
2923 if (!st->codec->extradata_size) {
2924 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
2925 nb_input_files - 1, st->index);
2928 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
2929 filename = e->value;
2931 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
2932 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
2936 assert_file_overwrite(filename);
2938 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
2939 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
2944 avio_write(out, st->codec->extradata, st->codec->extradata_size);
2949 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2951 AVFormatContext *ic;
2952 AVInputFormat *file_iformat = NULL;
2956 AVDictionary **opts;
2957 int orig_nb_streams; // number of streams before avformat_find_stream_info
2960 if (!(file_iformat = av_find_input_format(o->format))) {
2961 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
2966 if (!strcmp(filename, "-"))
2969 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2970 !strcmp(filename, "/dev/stdin");
2972 /* get default parameters from command line */
2973 ic = avformat_alloc_context();
2975 print_error(filename, AVERROR(ENOMEM));
2978 if (o->nb_audio_sample_rate) {
2979 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2980 av_dict_set(&format_opts, "sample_rate", buf, 0);
2982 if (o->nb_audio_channels) {
2983 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2984 av_dict_set(&format_opts, "channels", buf, 0);
2986 if (o->nb_frame_rates) {
2987 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2989 if (o->nb_frame_sizes) {
2990 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2992 if (o->nb_frame_pix_fmts)
2993 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
2995 ic->flags |= AVFMT_FLAG_NONBLOCK;
2996 ic->interrupt_callback = int_cb;
2998 /* open the input file with generic libav function */
2999 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3001 print_error(filename, err);
3004 assert_avoptions(format_opts);
3006 /* apply forced codec ids */
3007 for (i = 0; i < ic->nb_streams; i++)
3008 choose_decoder(o, ic, ic->streams[i]);
3010 /* Set AVCodecContext options for avformat_find_stream_info */
3011 opts = setup_find_stream_info_opts(ic, codec_opts);
3012 orig_nb_streams = ic->nb_streams;
3014 /* If not enough info to get the stream parameters, we decode the
3015 first frames to get it. (used in mpeg case for example) */
3016 ret = avformat_find_stream_info(ic, opts);
3018 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3019 av_close_input_file(ic);
3023 timestamp = o->start_time;
3024 /* add the stream start time */
3025 if (ic->start_time != AV_NOPTS_VALUE)
3026 timestamp += ic->start_time;
3028 /* if seeking requested, we execute it */
3029 if (o->start_time != 0) {
3030 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3032 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3033 filename, (double)timestamp / AV_TIME_BASE);
3037 /* update the current parameters so that they match the one of the input stream */
3038 add_input_streams(o, ic);
3040 /* dump the file content */
3041 av_dump_format(ic, nb_input_files, filename, 0);
3043 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3044 input_files[nb_input_files - 1].ctx = ic;
3045 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3046 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3047 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3048 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3050 for (i = 0; i < o->nb_dump_attachment; i++) {
3053 for (j = 0; j < ic->nb_streams; j++) {
3054 AVStream *st = ic->streams[j];
3056 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3057 dump_attachment(st, o->dump_attachment[i].u.str);
3061 for (i = 0; i < orig_nb_streams; i++)
3062 av_dict_free(&opts[i]);
3069 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3070 AVCodecContext *avctx)
3076 for (p = kf; *p; p++)
3079 ost->forced_kf_count = n;
3080 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3081 if (!ost->forced_kf_pts) {
3082 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3085 for (i = 0; i < n; i++) {
3086 p = i ? strchr(p, ',') + 1 : kf;
3087 t = parse_time_or_die("force_key_frames", p, 1);
3088 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3092 static uint8_t *get_line(AVIOContext *s)
3098 if (avio_open_dyn_buf(&line) < 0) {
3099 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3103 while ((c = avio_r8(s)) && c != '\n')
3106 avio_close_dyn_buf(line, &buf);
3111 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3114 char filename[1000];
3115 const char *base[3] = { getenv("AVCONV_DATADIR"),
3120 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3124 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3125 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3126 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3129 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3130 i != 1 ? "" : "/.avconv", preset_name);
3131 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3137 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3139 char *codec_name = NULL;
3141 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3143 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3144 NULL, ost->st->codec->codec_type);
3145 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3146 } else if (!strcmp(codec_name, "copy"))
3147 ost->stream_copy = 1;
3149 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3150 ost->st->codec->codec_id = ost->enc->id;
3154 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3157 AVStream *st = avformat_new_stream(oc, NULL);
3158 int idx = oc->nb_streams - 1, ret = 0;
3159 char *bsf = NULL, *next, *codec_tag = NULL;
3160 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3162 char *buf = NULL, *arg = NULL, *preset = NULL;
3163 AVIOContext *s = NULL;
3166 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3170 if (oc->nb_streams - 1 < o->nb_streamid_map)
3171 st->id = o->streamid_map[oc->nb_streams - 1];
3173 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3174 nb_output_streams + 1);
3175 ost = &output_streams[nb_output_streams - 1];
3176 ost->file_index = nb_output_files;
3179 st->codec->codec_type = type;
3180 choose_encoder(o, oc, ost);
3182 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3185 avcodec_get_context_defaults3(st->codec, ost->enc);
3186 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3188 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3189 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3192 if (!buf[0] || buf[0] == '#') {
3196 if (!(arg = strchr(buf, '='))) {
3197 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3201 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3203 } while (!s->eof_reached);
3207 av_log(NULL, AV_LOG_FATAL,
3208 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3209 preset, ost->file_index, ost->index);
3213 ost->max_frames = INT64_MAX;
3214 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3216 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3218 if (next = strchr(bsf, ','))
3220 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3221 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3225 bsfc_prev->next = bsfc;
3227 ost->bitstream_filters = bsfc;
3233 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3235 uint32_t tag = strtol(codec_tag, &next, 0);
3237 tag = AV_RL32(codec_tag);
3238 st->codec->codec_tag = tag;
3241 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3242 if (qscale >= 0 || same_quant) {
3243 st->codec->flags |= CODEC_FLAG_QSCALE;
3244 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3247 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3248 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3250 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3254 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3257 const char *p = str;
3264 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3271 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3275 AVCodecContext *video_enc;
3277 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3279 video_enc = st->codec;
3281 if (!ost->stream_copy) {
3282 const char *p = NULL;
3283 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3284 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3285 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3288 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3289 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3290 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3294 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3295 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3296 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3300 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3301 if (frame_aspect_ratio)
3302 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3304 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3305 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3306 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3309 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3311 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3313 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3314 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3317 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3319 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3321 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3322 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3325 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3328 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3331 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3333 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3336 video_enc->rc_override=
3337 av_realloc(video_enc->rc_override,
3338 sizeof(RcOverride)*(i+1));
3339 video_enc->rc_override[i].start_frame= start;
3340 video_enc->rc_override[i].end_frame = end;
3342 video_enc->rc_override[i].qscale= q;
3343 video_enc->rc_override[i].quality_factor= 1.0;
3346 video_enc->rc_override[i].qscale= 0;
3347 video_enc->rc_override[i].quality_factor= -q/100.0;
3352 video_enc->rc_override_count=i;
3353 if (!video_enc->rc_initial_buffer_occupancy)
3354 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3355 video_enc->intra_dc_precision= intra_dc_precision - 8;
3360 video_enc->flags |= CODEC_FLAG_PASS1;
3362 video_enc->flags |= CODEC_FLAG_PASS2;
3366 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3367 if (forced_key_frames)
3368 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3370 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3372 ost->top_field_first = -1;
3373 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3375 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3378 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3380 ost->avfilter = av_strdup(filters);
3387 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3391 AVCodecContext *audio_enc;
3393 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3396 audio_enc = st->codec;
3397 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3399 if (!ost->stream_copy) {
3400 char *sample_fmt = NULL;
3402 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3404 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3406 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3407 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3411 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3417 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3421 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3422 if (!ost->stream_copy) {
3423 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3430 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3432 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3433 ost->stream_copy = 1;
3437 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3441 AVCodecContext *subtitle_enc;
3443 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3445 subtitle_enc = st->codec;
3447 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3452 /* arg format is "output-stream-index:streamid-value". */
3453 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3459 av_strlcpy(idx_str, arg, sizeof(idx_str));
3460 p = strchr(idx_str, ':');
3462 av_log(NULL, AV_LOG_FATAL,
3463 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3468 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3469 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3470 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3474 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3476 AVFormatContext *is = ifile->ctx;
3477 AVFormatContext *os = ofile->ctx;
3480 for (i = 0; i < is->nb_chapters; i++) {
3481 AVChapter *in_ch = is->chapters[i], *out_ch;
3482 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3483 AV_TIME_BASE_Q, in_ch->time_base);
3484 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3485 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3488 if (in_ch->end < ts_off)
3490 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3493 out_ch = av_mallocz(sizeof(AVChapter));
3495 return AVERROR(ENOMEM);
3497 out_ch->id = in_ch->id;
3498 out_ch->time_base = in_ch->time_base;
3499 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3500 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3503 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3506 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3508 return AVERROR(ENOMEM);
3509 os->chapters[os->nb_chapters - 1] = out_ch;
3514 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3517 AVFormatContext *ic = avformat_alloc_context();
3519 ic->interrupt_callback = int_cb;
3520 err = avformat_open_input(&ic, filename, NULL, NULL);
3523 /* copy stream format */
3524 for(i=0;i<ic->nb_streams;i++) {
3529 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3530 ost = new_output_stream(o, s, codec->type);
3533 // FIXME: a more elegant solution is needed
3534 memcpy(st, ic->streams[i], sizeof(AVStream));
3536 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3538 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3539 choose_sample_fmt(st, codec);
3540 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3541 choose_pixel_fmt(st, codec);
3544 av_close_input_file(ic);
3548 static void opt_output_file(void *optctx, const char *filename)
3550 OptionsContext *o = optctx;
3551 AVFormatContext *oc;
3553 AVOutputFormat *file_oformat;
3557 if (!strcmp(filename, "-"))
3560 oc = avformat_alloc_context();
3562 print_error(filename, AVERROR(ENOMEM));
3567 file_oformat = av_guess_format(o->format, NULL, NULL);
3568 if (!file_oformat) {
3569 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3573 file_oformat = av_guess_format(NULL, filename, NULL);
3574 if (!file_oformat) {
3575 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3581 oc->oformat = file_oformat;
3582 oc->interrupt_callback = int_cb;
3583 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3585 if (!strcmp(file_oformat->name, "ffm") &&
3586 av_strstart(filename, "http:", NULL)) {
3587 /* special case for files sent to avserver: we get the stream
3588 parameters from avserver */
3589 int err = read_avserver_streams(o, oc, filename);
3591 print_error(filename, err);
3594 } else if (!o->nb_stream_maps) {
3595 /* pick the "best" stream of each type */
3596 #define NEW_STREAM(type, index)\
3598 ost = new_ ## type ## _stream(o, oc);\
3599 ost->source_index = index;\
3600 ost->sync_ist = &input_streams[index];\
3601 input_streams[index].discard = 0;\
3604 /* video: highest resolution */
3605 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3606 int area = 0, idx = -1;
3607 for (i = 0; i < nb_input_streams; i++) {
3608 ist = &input_streams[i];
3609 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3610 ist->st->codec->width * ist->st->codec->height > area) {
3611 area = ist->st->codec->width * ist->st->codec->height;
3615 NEW_STREAM(video, idx);
3618 /* audio: most channels */
3619 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3620 int channels = 0, idx = -1;
3621 for (i = 0; i < nb_input_streams; i++) {
3622 ist = &input_streams[i];
3623 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3624 ist->st->codec->channels > channels) {
3625 channels = ist->st->codec->channels;
3629 NEW_STREAM(audio, idx);
3632 /* subtitles: pick first */
3633 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3634 for (i = 0; i < nb_input_streams; i++)
3635 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3636 NEW_STREAM(subtitle, i);
3640 /* do something with data? */
3642 for (i = 0; i < o->nb_stream_maps; i++) {
3643 StreamMap *map = &o->stream_maps[i];
3648 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3649 switch (ist->st->codec->codec_type) {
3650 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3651 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3652 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3653 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3654 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3656 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
3657 map->file_index, map->stream_index);
3661 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3662 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3663 map->sync_stream_index];
3668 /* handle attached files */
3669 for (i = 0; i < o->nb_attachments; i++) {
3671 uint8_t *attachment;
3675 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
3676 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
3680 if ((len = avio_size(pb)) <= 0) {
3681 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
3685 if (!(attachment = av_malloc(len))) {
3686 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
3690 avio_read(pb, attachment, len);
3692 ost = new_attachment_stream(o, oc);
3693 ost->stream_copy = 0;
3694 ost->source_index = -1;
3695 ost->attachment_filename = o->attachments[i];
3696 ost->st->codec->extradata = attachment;
3697 ost->st->codec->extradata_size = len;
3699 p = strrchr(o->attachments[i], '/');
3700 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
3704 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3705 output_files[nb_output_files - 1].ctx = oc;
3706 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3707 output_files[nb_output_files - 1].recording_time = o->recording_time;
3708 output_files[nb_output_files - 1].start_time = o->start_time;
3709 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3710 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3712 /* check filename in case of an image number is expected */
3713 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3714 if (!av_filename_number_test(oc->filename)) {
3715 print_error(oc->filename, AVERROR(EINVAL));
3720 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3721 /* test if it already exists to avoid loosing precious files */
3722 assert_file_overwrite(filename);
3725 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
3726 &oc->interrupt_callback,
3727 &output_files[nb_output_files - 1].opts)) < 0) {
3728 print_error(filename, err);
3733 if (o->mux_preload) {
3735 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3736 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3738 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3739 oc->flags |= AVFMT_FLAG_NONBLOCK;
3742 if (o->chapters_input_file >= nb_input_files) {
3743 if (o->chapters_input_file == INT_MAX) {
3744 /* copy chapters from the first input file that has them*/
3745 o->chapters_input_file = -1;
3746 for (i = 0; i < nb_input_files; i++)
3747 if (input_files[i].ctx->nb_chapters) {
3748 o->chapters_input_file = i;
3752 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3753 o->chapters_input_file);
3757 if (o->chapters_input_file >= 0)
3758 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3759 !o->metadata_chapters_manual);
3762 for (i = 0; i < o->nb_meta_data_maps; i++) {
3763 AVFormatContext *files[2];
3764 AVDictionary **meta[2];
3767 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3768 if ((index) < 0 || (index) >= (nb_elems)) {\
3769 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3774 int in_file_index = o->meta_data_maps[i][1].file;
3775 if (in_file_index < 0)
3777 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3780 files[1] = input_files[in_file_index].ctx;
3782 for (j = 0; j < 2; j++) {
3783 MetadataMap *map = &o->meta_data_maps[i][j];
3785 switch (map->type) {
3787 meta[j] = &files[j]->metadata;
3790 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3791 meta[j] = &files[j]->streams[map->index]->metadata;
3794 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3795 meta[j] = &files[j]->chapters[map->index]->metadata;
3798 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3799 meta[j] = &files[j]->programs[map->index]->metadata;
3804 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3807 /* copy global metadata by default */
3808 if (!o->metadata_global_manual && nb_input_files)
3809 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3810 AV_DICT_DONT_OVERWRITE);
3811 if (!o->metadata_streams_manual)
3812 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3814 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
3816 ist = &input_streams[output_streams[i].source_index];
3817 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3820 /* process manually set metadata */
3821 for (i = 0; i < o->nb_metadata; i++) {
3826 val = strchr(o->metadata[i].u.str, '=');
3828 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3829 o->metadata[i].u.str);
3834 parse_meta_type(o->metadata[i].specifier, &type, &index);
3840 if (index < 0 || index >= oc->nb_streams) {
3841 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3844 m = &oc->streams[index]->metadata;
3847 if (index < 0 || index >= oc->nb_chapters) {
3848 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3851 m = &oc->chapters[index]->metadata;
3854 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3858 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3864 /* same option as mencoder */
3865 static int opt_pass(const char *opt, const char *arg)
3867 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3871 static int64_t getutime(void)
3874 struct rusage rusage;
3876 getrusage(RUSAGE_SELF, &rusage);
3877 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3878 #elif HAVE_GETPROCESSTIMES
3880 FILETIME c, e, k, u;
3881 proc = GetCurrentProcess();
3882 GetProcessTimes(proc, &c, &e, &k, &u);
3883 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3885 return av_gettime();
3889 static int64_t getmaxrss(void)
3891 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3892 struct rusage rusage;
3893 getrusage(RUSAGE_SELF, &rusage);
3894 return (int64_t)rusage.ru_maxrss * 1024;
3895 #elif HAVE_GETPROCESSMEMORYINFO
3897 PROCESS_MEMORY_COUNTERS memcounters;
3898 proc = GetCurrentProcess();
3899 memcounters.cb = sizeof(memcounters);
3900 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3901 return memcounters.PeakPagefileUsage;
3907 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3909 return parse_option(o, "q:a", arg, options);
3912 static void show_usage(void)
3914 printf("Hyper fast Audio and Video encoder\n");
3915 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3919 static void show_help(void)
3921 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3922 av_log_set_callback(log_callback_help);
3924 show_help_options(options, "Main options:\n",
3925 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3926 show_help_options(options, "\nAdvanced options:\n",
3927 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3929 show_help_options(options, "\nVideo options:\n",
3930 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3932 show_help_options(options, "\nAdvanced Video options:\n",
3933 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3934 OPT_VIDEO | OPT_EXPERT);
3935 show_help_options(options, "\nAudio options:\n",
3936 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3938 show_help_options(options, "\nAdvanced Audio options:\n",
3939 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3940 OPT_AUDIO | OPT_EXPERT);
3941 show_help_options(options, "\nSubtitle options:\n",
3942 OPT_SUBTITLE | OPT_GRAB,
3944 show_help_options(options, "\nAudio/Video grab options:\n",
3948 show_help_children(avcodec_get_class(), flags);
3949 show_help_children(avformat_get_class(), flags);
3950 show_help_children(sws_get_class(), flags);
3953 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3955 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3956 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3958 if(!strncmp(arg, "pal-", 4)) {
3961 } else if(!strncmp(arg, "ntsc-", 5)) {
3964 } else if(!strncmp(arg, "film-", 5)) {
3968 /* Try to determine PAL/NTSC by peeking in the input files */
3969 if(nb_input_files) {
3971 for (j = 0; j < nb_input_files; j++) {
3972 for (i = 0; i < input_files[j].nb_streams; i++) {
3973 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3974 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3976 fr = c->time_base.den * 1000 / c->time_base.num;
3980 } else if((fr == 29970) || (fr == 23976)) {
3989 if (norm != UNKNOWN)
3990 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3993 if(norm == UNKNOWN) {
3994 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3995 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3996 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4000 if(!strcmp(arg, "vcd")) {
4001 opt_video_codec(o, "c:v", "mpeg1video");
4002 opt_audio_codec(o, "c:a", "mp2");
4003 parse_option(o, "f", "vcd", options);
4005 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4006 parse_option(o, "r", frame_rates[norm], options);
4007 opt_default("g", norm == PAL ? "15" : "18");
4009 opt_default("b", "1150000");
4010 opt_default("maxrate", "1150000");
4011 opt_default("minrate", "1150000");
4012 opt_default("bufsize", "327680"); // 40*1024*8;
4014 opt_default("b:a", "224000");
4015 parse_option(o, "ar", "44100", options);
4016 parse_option(o, "ac", "2", options);
4018 opt_default("packetsize", "2324");
4019 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4021 /* We have to offset the PTS, so that it is consistent with the SCR.
4022 SCR starts at 36000, but the first two packs contain only padding
4023 and the first pack from the other stream, respectively, may also have
4024 been written before.
4025 So the real data starts at SCR 36000+3*1200. */
4026 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4027 } else if(!strcmp(arg, "svcd")) {
4029 opt_video_codec(o, "c:v", "mpeg2video");
4030 opt_audio_codec(o, "c:a", "mp2");
4031 parse_option(o, "f", "svcd", options);
4033 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4034 parse_option(o, "r", frame_rates[norm], options);
4035 opt_default("g", norm == PAL ? "15" : "18");
4037 opt_default("b", "2040000");
4038 opt_default("maxrate", "2516000");
4039 opt_default("minrate", "0"); //1145000;
4040 opt_default("bufsize", "1835008"); //224*1024*8;
4041 opt_default("flags", "+scan_offset");
4044 opt_default("b:a", "224000");
4045 parse_option(o, "ar", "44100", options);
4047 opt_default("packetsize", "2324");
4049 } else if(!strcmp(arg, "dvd")) {
4051 opt_video_codec(o, "c:v", "mpeg2video");
4052 opt_audio_codec(o, "c:a", "ac3");
4053 parse_option(o, "f", "dvd", options);
4055 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4056 parse_option(o, "r", frame_rates[norm], options);
4057 opt_default("g", norm == PAL ? "15" : "18");
4059 opt_default("b", "6000000");
4060 opt_default("maxrate", "9000000");
4061 opt_default("minrate", "0"); //1500000;
4062 opt_default("bufsize", "1835008"); //224*1024*8;
4064 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4065 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4067 opt_default("b:a", "448000");
4068 parse_option(o, "ar", "48000", options);
4070 } else if(!strncmp(arg, "dv", 2)) {
4072 parse_option(o, "f", "dv", options);
4074 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4075 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4076 norm == PAL ? "yuv420p" : "yuv411p", options);
4077 parse_option(o, "r", frame_rates[norm], options);
4079 parse_option(o, "ar", "48000", options);
4080 parse_option(o, "ac", "2", options);
4083 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4084 return AVERROR(EINVAL);
4089 static int opt_vstats_file(const char *opt, const char *arg)
4091 av_free (vstats_filename);
4092 vstats_filename=av_strdup (arg);
4096 static int opt_vstats(const char *opt, const char *arg)
4099 time_t today2 = time(NULL);
4100 struct tm *today = localtime(&today2);
4102 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4104 return opt_vstats_file(opt, filename);
4107 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4109 return parse_option(o, "frames:v", arg, options);
4112 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4114 return parse_option(o, "frames:a", arg, options);
4117 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4119 return parse_option(o, "frames:d", arg, options);
4122 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4124 return parse_option(o, "tag:v", arg, options);
4127 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4129 return parse_option(o, "tag:a", arg, options);
4132 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4134 return parse_option(o, "tag:s", arg, options);
4137 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4139 return parse_option(o, "filter:v", arg, options);
4142 #define OFFSET(x) offsetof(OptionsContext, x)
4143 static const OptionDef options[] = {
4145 #include "cmdutils_common_opts.h"
4146 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4147 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4148 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4149 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4150 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4151 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4152 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4153 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4154 "outfile[,metadata]:infile[,metadata]" },
4155 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4156 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4157 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4158 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4159 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4160 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4161 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4162 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4163 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4164 "add timings for benchmarking" },
4165 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4166 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4167 "dump each input packet" },
4168 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4169 "when dumping packets, also dump the payload" },
4170 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4171 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4172 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4173 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4174 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4175 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4176 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4177 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4178 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4179 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4180 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4181 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4182 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4183 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4184 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4186 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4188 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4189 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4190 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4193 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4194 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4195 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4196 { "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" },
4197 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4198 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4199 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4200 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4201 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4202 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4203 "use same quantizer as source (implies VBR)" },
4204 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4205 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4206 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4207 "deinterlace pictures" },
4208 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4209 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4211 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4213 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4214 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4215 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4216 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4217 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4218 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4219 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4220 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4221 { "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" },
4224 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4225 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4226 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4227 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4228 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4229 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4230 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4231 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4232 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4234 /* subtitle options */
4235 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4236 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4237 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4240 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4243 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4244 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4246 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4248 /* data codec support */
4249 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4251 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4255 int main(int argc, char **argv)
4257 OptionsContext o = { 0 };
4262 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4263 parse_loglevel(argc, argv, options);
4265 avcodec_register_all();
4267 avdevice_register_all();
4270 avfilter_register_all();
4273 avformat_network_init();
4278 parse_options(&o, argc, argv, options, opt_output_file);
4280 if(nb_output_files <= 0 && nb_input_files == 0) {
4282 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4286 /* file converter / grab */
4287 if (nb_output_files <= 0) {
4288 fprintf(stderr, "At least one output file must be specified\n");
4292 if (nb_input_files == 0) {
4293 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4298 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4300 ti = getutime() - ti;
4302 int maxrss = getmaxrss() / 1024;
4303 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);