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 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
142 typedef struct InputStream {
145 int discard; /* true if stream data should be discarded */
146 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
148 AVFrame *decoded_frame;
149 AVFrame *filtered_frame;
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 *metadata_map;
337 SpecifierOpt *presets;
339 SpecifierOpt *copy_initial_nonkeyframes;
340 int nb_copy_initial_nonkeyframes;
342 SpecifierOpt *filters;
347 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
350 for (i = 0; i < o->nb_ ## name; i++) {\
351 char *spec = o->name[i].specifier;\
352 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
353 outvar = o->name[i].u.type;\
359 static void reset_options(OptionsContext *o)
361 const OptionDef *po = options;
363 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
365 void *dst = (uint8_t*)o + po->u.off;
367 if (po->flags & OPT_SPEC) {
368 SpecifierOpt **so = dst;
369 int i, *count = (int*)(so + 1);
370 for (i = 0; i < *count; i++) {
371 av_freep(&(*so)[i].specifier);
372 if (po->flags & OPT_STRING)
373 av_freep(&(*so)[i].u.str);
377 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
382 av_freep(&o->stream_maps);
383 av_freep(&o->meta_data_maps);
384 av_freep(&o->streamid_map);
386 memset(o, 0, sizeof(*o));
388 o->mux_max_delay = 0.7;
389 o->recording_time = INT64_MAX;
390 o->limit_filesize = UINT64_MAX;
391 o->chapters_input_file = INT_MAX;
399 static int configure_video_filters(InputStream *ist, OutputStream *ost)
401 AVFilterContext *last_filter, *filter;
402 /** filter graph containing all filters including input & output */
403 AVCodecContext *codec = ost->st->codec;
404 AVCodecContext *icodec = ist->st->codec;
405 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
406 AVRational sample_aspect_ratio;
410 ost->graph = avfilter_graph_alloc();
412 if (ist->st->sample_aspect_ratio.num){
413 sample_aspect_ratio = ist->st->sample_aspect_ratio;
415 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
417 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
418 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
419 sample_aspect_ratio.num, sample_aspect_ratio.den);
421 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
422 "src", args, NULL, ost->graph);
425 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
426 "out", NULL, &ffsink_ctx, ost->graph);
429 last_filter = ost->input_video_filter;
431 if (codec->width != icodec->width || codec->height != icodec->height) {
432 snprintf(args, 255, "%d:%d:flags=0x%X",
435 (unsigned)ost->sws_flags);
436 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
437 NULL, args, NULL, ost->graph)) < 0)
439 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
441 last_filter = filter;
444 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
445 ost->graph->scale_sws_opts = av_strdup(args);
448 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
449 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
451 outputs->name = av_strdup("in");
452 outputs->filter_ctx = last_filter;
453 outputs->pad_idx = 0;
454 outputs->next = NULL;
456 inputs->name = av_strdup("out");
457 inputs->filter_ctx = ost->output_video_filter;
461 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
463 av_freep(&ost->avfilter);
465 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
469 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
472 codec->width = ost->output_video_filter->inputs[0]->w;
473 codec->height = ost->output_video_filter->inputs[0]->h;
474 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
475 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
476 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
477 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
481 #endif /* CONFIG_AVFILTER */
483 static void term_exit(void)
485 av_log(NULL, AV_LOG_QUIET, "");
488 static volatile int received_sigterm = 0;
489 static volatile int received_nb_signals = 0;
492 sigterm_handler(int sig)
494 received_sigterm = sig;
495 received_nb_signals++;
499 static void term_init(void)
501 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
502 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
504 signal(SIGXCPU, sigterm_handler);
508 static int decode_interrupt_cb(void *ctx)
510 return received_nb_signals > 1;
513 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
515 void exit_program(int ret)
520 for(i=0;i<nb_output_files;i++) {
521 AVFormatContext *s = output_files[i].ctx;
522 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
524 avformat_free_context(s);
525 av_dict_free(&output_files[i].opts);
527 for(i=0;i<nb_input_files;i++) {
528 avformat_close_input(&input_files[i].ctx);
530 for (i = 0; i < nb_input_streams; i++) {
531 av_freep(&input_streams[i].decoded_frame);
532 av_freep(&input_streams[i].filtered_frame);
533 av_dict_free(&input_streams[i].opts);
538 av_free(vstats_filename);
540 av_freep(&input_streams);
541 av_freep(&input_files);
542 av_freep(&output_streams);
543 av_freep(&output_files);
548 allocated_audio_buf_size= allocated_audio_out_size= 0;
553 avformat_network_deinit();
555 if (received_sigterm) {
556 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
557 (int) received_sigterm);
564 static void assert_avoptions(AVDictionary *m)
566 AVDictionaryEntry *t;
567 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
568 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
573 static void assert_codec_experimental(AVCodecContext *c, int encoder)
575 const char *codec_string = encoder ? "encoder" : "decoder";
577 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
578 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
579 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
580 "results.\nAdd '-strict experimental' if you want to use it.\n",
581 codec_string, c->codec->name);
582 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
583 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
584 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
585 codec_string, codec->name);
590 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
592 if(codec && codec->sample_fmts){
593 const enum AVSampleFormat *p= codec->sample_fmts;
595 if(*p == st->codec->sample_fmt)
599 av_log(NULL, AV_LOG_WARNING,
600 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
601 av_get_sample_fmt_name(st->codec->sample_fmt),
603 av_get_sample_fmt_name(codec->sample_fmts[0]));
604 st->codec->sample_fmt = codec->sample_fmts[0];
610 * Update the requested input sample format based on the output sample format.
611 * This is currently only used to request float output from decoders which
612 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
613 * Ideally this will be removed in the future when decoders do not do format
614 * conversion and only output in their native format.
616 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
619 /* if sample formats match or a decoder sample format has already been
620 requested, just return */
621 if (enc->sample_fmt == dec->sample_fmt ||
622 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
625 /* if decoder supports more than one output format */
626 if (dec_codec && dec_codec->sample_fmts &&
627 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
628 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
629 const enum AVSampleFormat *p;
630 int min_dec = -1, min_inc = -1;
632 /* find a matching sample format in the encoder */
633 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
634 if (*p == enc->sample_fmt) {
635 dec->request_sample_fmt = *p;
637 } else if (*p > enc->sample_fmt) {
638 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
640 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
643 /* if none match, provide the one that matches quality closest */
644 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
645 enc->sample_fmt - min_dec;
649 static void choose_sample_rate(AVStream *st, AVCodec *codec)
651 if(codec && codec->supported_samplerates){
652 const int *p= codec->supported_samplerates;
654 int best_dist=INT_MAX;
656 int dist= abs(st->codec->sample_rate - *p);
657 if(dist < best_dist){
663 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
665 st->codec->sample_rate= best;
669 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
671 if(codec && codec->pix_fmts){
672 const enum PixelFormat *p= codec->pix_fmts;
673 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
674 if(st->codec->codec_id==CODEC_ID_MJPEG){
675 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
676 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
677 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};
680 for (; *p != PIX_FMT_NONE; p++) {
681 if(*p == st->codec->pix_fmt)
684 if (*p == PIX_FMT_NONE) {
685 if(st->codec->pix_fmt != PIX_FMT_NONE)
686 av_log(NULL, AV_LOG_WARNING,
687 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
688 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
690 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
691 st->codec->pix_fmt = codec->pix_fmts[0];
697 get_sync_ipts(const OutputStream *ost)
699 const InputStream *ist = ost->sync_ist;
700 OutputFile *of = &output_files[ost->file_index];
701 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
704 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
708 AVPacket new_pkt= *pkt;
709 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
710 &new_pkt.data, &new_pkt.size,
711 pkt->data, pkt->size,
712 pkt->flags & AV_PKT_FLAG_KEY);
715 new_pkt.destruct= av_destruct_packet;
717 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
718 bsfc->filter->name, pkt->stream_index,
719 avctx->codec ? avctx->codec->name : "copy");
729 ret= av_interleaved_write_frame(s, pkt);
731 print_error("av_interleaved_write_frame()", ret);
736 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
738 int fill_char = 0x00;
739 if (sample_fmt == AV_SAMPLE_FMT_U8)
741 memset(buf, fill_char, size);
744 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
745 InputStream *ist, AVFrame *decoded_frame)
748 int64_t audio_out_size, audio_buf_size;
750 int size_out, frame_bytes, ret, resample_changed;
751 AVCodecContext *enc= ost->st->codec;
752 AVCodecContext *dec= ist->st->codec;
753 int osize = av_get_bytes_per_sample(enc->sample_fmt);
754 int isize = av_get_bytes_per_sample(dec->sample_fmt);
755 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
756 uint8_t *buf = decoded_frame->data[0];
757 int size = decoded_frame->nb_samples * dec->channels * isize;
758 int64_t allocated_for_size = size;
761 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
762 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
763 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
764 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
765 audio_buf_size*= osize*enc->channels;
767 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
768 if(coded_bps > 8*osize)
769 audio_out_size= audio_out_size * coded_bps / (8*osize);
770 audio_out_size += FF_MIN_BUFFER_SIZE;
772 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
773 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
777 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
778 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
779 if (!audio_buf || !audio_out){
780 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
784 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
785 ost->audio_resample = 1;
787 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
788 ost->resample_channels != dec->channels ||
789 ost->resample_sample_rate != dec->sample_rate;
791 if ((ost->audio_resample && !ost->resample) || resample_changed) {
792 if (resample_changed) {
793 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",
794 ist->file_index, ist->st->index,
795 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
796 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
797 ost->resample_sample_fmt = dec->sample_fmt;
798 ost->resample_channels = dec->channels;
799 ost->resample_sample_rate = dec->sample_rate;
801 audio_resample_close(ost->resample);
803 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
804 if (audio_sync_method <= 1 &&
805 ost->resample_sample_fmt == enc->sample_fmt &&
806 ost->resample_channels == enc->channels &&
807 ost->resample_sample_rate == enc->sample_rate) {
808 ost->resample = NULL;
809 ost->audio_resample = 0;
810 } else if (ost->audio_resample) {
811 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
812 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
813 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
814 enc->sample_rate, dec->sample_rate,
815 enc->sample_fmt, dec->sample_fmt,
817 if (!ost->resample) {
818 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
819 dec->channels, dec->sample_rate,
820 enc->channels, enc->sample_rate);
826 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
827 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
828 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
829 if (ost->reformat_ctx)
830 av_audio_convert_free(ost->reformat_ctx);
831 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
832 dec->sample_fmt, 1, NULL, 0);
833 if (!ost->reformat_ctx) {
834 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
835 av_get_sample_fmt_name(dec->sample_fmt),
836 av_get_sample_fmt_name(enc->sample_fmt));
839 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
842 if(audio_sync_method){
843 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
844 - av_fifo_size(ost->fifo)/(enc->channels * osize);
845 int idelta = delta * dec->sample_rate / enc->sample_rate;
846 int byte_delta = idelta * isize * dec->channels;
848 //FIXME resample delay
849 if(fabs(delta) > 50){
850 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
852 byte_delta= FFMAX(byte_delta, -size);
855 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
856 -byte_delta / (isize * dec->channels));
861 static uint8_t *input_tmp= NULL;
862 input_tmp= av_realloc(input_tmp, byte_delta + size);
864 if(byte_delta > allocated_for_size - size){
865 allocated_for_size= byte_delta + (int64_t)size;
870 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
871 memcpy(input_tmp + byte_delta, buf, size);
874 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
876 }else if(audio_sync_method>1){
877 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
878 av_assert0(ost->audio_resample);
879 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
880 delta, comp, enc->sample_rate);
881 // 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));
882 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
886 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
887 - av_fifo_size(ost->fifo)/(enc->channels * osize); //FIXME wrong
889 if (ost->audio_resample) {
891 size_out = audio_resample(ost->resample,
892 (short *)buftmp, (short *)buf,
893 size / (dec->channels * isize));
894 size_out = size_out * enc->channels * osize;
900 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
901 const void *ibuf[6]= {buftmp};
902 void *obuf[6]= {audio_buf};
903 int istride[6]= {isize};
904 int ostride[6]= {osize};
905 int len= size_out/istride[0];
906 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
907 printf("av_audio_convert() failed\n");
913 size_out = len*osize;
916 /* now encode as many frames as possible */
917 if (enc->frame_size > 1) {
918 /* output resampled raw samples */
919 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
920 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
923 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
925 frame_bytes = enc->frame_size * osize * enc->channels;
927 while (av_fifo_size(ost->fifo) >= frame_bytes) {
929 av_init_packet(&pkt);
931 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
933 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
935 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
938 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
942 pkt.stream_index= ost->index;
945 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
946 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
947 pkt.flags |= AV_PKT_FLAG_KEY;
948 write_frame(s, &pkt, enc, ost->bitstream_filters);
950 ost->sync_opts += enc->frame_size;
954 av_init_packet(&pkt);
956 ost->sync_opts += size_out / (osize * enc->channels);
958 /* output a pcm frame */
959 /* determine the size of the coded buffer */
962 size_out = size_out*coded_bps/8;
964 if(size_out > audio_out_size){
965 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
969 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
970 ret = avcodec_encode_audio(enc, audio_out, size_out,
973 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
977 pkt.stream_index= ost->index;
980 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
981 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
982 pkt.flags |= AV_PKT_FLAG_KEY;
983 write_frame(s, &pkt, enc, ost->bitstream_filters);
987 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
991 AVPicture picture_tmp;
994 dec = ist->st->codec;
996 /* deinterlace : must be done before any resize */
997 if (do_deinterlace) {
1000 /* create temporary picture */
1001 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1002 buf = av_malloc(size);
1006 picture2 = &picture_tmp;
1007 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1009 if(avpicture_deinterlace(picture2, picture,
1010 dec->pix_fmt, dec->width, dec->height) < 0) {
1011 /* if error, do not deinterlace */
1012 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1021 if (picture != picture2)
1022 *picture = *picture2;
1026 static void do_subtitle_out(AVFormatContext *s,
1032 static uint8_t *subtitle_out = NULL;
1033 int subtitle_out_max_size = 1024 * 1024;
1034 int subtitle_out_size, nb, i;
1035 AVCodecContext *enc;
1038 if (pts == AV_NOPTS_VALUE) {
1039 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1045 enc = ost->st->codec;
1047 if (!subtitle_out) {
1048 subtitle_out = av_malloc(subtitle_out_max_size);
1051 /* Note: DVB subtitle need one packet to draw them and one other
1052 packet to clear them */
1053 /* XXX: signal it in the codec context ? */
1054 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1059 for(i = 0; i < nb; i++) {
1060 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1061 // start_display_time is required to be 0
1062 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1063 sub->end_display_time -= sub->start_display_time;
1064 sub->start_display_time = 0;
1065 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1066 subtitle_out_max_size, sub);
1067 if (subtitle_out_size < 0) {
1068 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1072 av_init_packet(&pkt);
1073 pkt.stream_index = ost->index;
1074 pkt.data = subtitle_out;
1075 pkt.size = subtitle_out_size;
1076 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1077 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1078 /* XXX: the pts correction is handled here. Maybe handling
1079 it in the codec would be better */
1081 pkt.pts += 90 * sub->start_display_time;
1083 pkt.pts += 90 * sub->end_display_time;
1085 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1089 static int bit_buffer_size= 1024*256;
1090 static uint8_t *bit_buffer= NULL;
1092 static void do_video_resample(OutputStream *ost,
1094 AVFrame *in_picture,
1095 AVFrame **out_picture)
1097 int resample_changed = 0;
1098 AVCodecContext *dec = ist->st->codec;
1099 *out_picture = in_picture;
1101 resample_changed = ost->resample_width != dec->width ||
1102 ost->resample_height != dec->height ||
1103 ost->resample_pix_fmt != dec->pix_fmt;
1105 if (resample_changed) {
1106 av_log(NULL, AV_LOG_INFO,
1107 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1108 ist->file_index, ist->st->index,
1109 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1110 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1111 if(!ost->video_resample)
1112 ost->video_resample = 1;
1115 #if !CONFIG_AVFILTER
1116 if (ost->video_resample) {
1117 *out_picture = &ost->pict_tmp;
1118 if (resample_changed) {
1119 /* initialize a new scaler context */
1120 sws_freeContext(ost->img_resample_ctx);
1121 ost->img_resample_ctx = sws_getContext(
1122 ist->st->codec->width,
1123 ist->st->codec->height,
1124 ist->st->codec->pix_fmt,
1125 ost->st->codec->width,
1126 ost->st->codec->height,
1127 ost->st->codec->pix_fmt,
1128 ost->sws_flags, NULL, NULL, NULL);
1129 if (ost->img_resample_ctx == NULL) {
1130 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1134 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1135 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1138 if (resample_changed) {
1139 avfilter_graph_free(&ost->graph);
1140 if (configure_video_filters(ist, ost)) {
1141 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1146 if (resample_changed) {
1147 ost->resample_width = dec->width;
1148 ost->resample_height = dec->height;
1149 ost->resample_pix_fmt = dec->pix_fmt;
1154 static void do_video_out(AVFormatContext *s,
1157 AVFrame *in_picture,
1158 int *frame_size, float quality)
1160 int nb_frames, i, ret, format_video_sync;
1161 AVFrame *final_picture;
1162 AVCodecContext *enc;
1165 enc = ost->st->codec;
1167 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1169 /* by default, we output a single frame */
1174 format_video_sync = video_sync_method;
1175 if (format_video_sync < 0)
1176 format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? 0 :
1177 (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1179 if (format_video_sync) {
1180 double vdelta = sync_ipts - ost->sync_opts;
1181 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1184 else if (format_video_sync == 2) {
1187 }else if(vdelta>0.6)
1188 ost->sync_opts= lrintf(sync_ipts);
1189 }else if (vdelta > 1.1)
1190 nb_frames = lrintf(vdelta);
1191 //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);
1192 if (nb_frames == 0){
1194 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1195 }else if (nb_frames > 1) {
1196 nb_frames_dup += nb_frames - 1;
1197 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1200 ost->sync_opts= lrintf(sync_ipts);
1202 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1206 do_video_resample(ost, ist, in_picture, &final_picture);
1208 /* duplicates frame if needed */
1209 for(i=0;i<nb_frames;i++) {
1211 av_init_packet(&pkt);
1212 pkt.stream_index= ost->index;
1214 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1215 enc->codec->id == CODEC_ID_RAWVIDEO) {
1216 /* raw pictures are written as AVPicture structure to
1217 avoid any copies. We support temporarily the older
1219 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1220 enc->coded_frame->top_field_first = in_picture->top_field_first;
1221 pkt.data= (uint8_t *)final_picture;
1222 pkt.size= sizeof(AVPicture);
1223 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1224 pkt.flags |= AV_PKT_FLAG_KEY;
1226 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1228 AVFrame big_picture;
1230 big_picture= *final_picture;
1231 /* better than nothing: use input picture interlaced
1233 big_picture.interlaced_frame = in_picture->interlaced_frame;
1234 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1235 if (ost->top_field_first == -1)
1236 big_picture.top_field_first = in_picture->top_field_first;
1238 big_picture.top_field_first = !!ost->top_field_first;
1241 /* handles same_quant here. This is not correct because it may
1242 not be a global option */
1243 big_picture.quality = quality;
1244 if (!enc->me_threshold)
1245 big_picture.pict_type = 0;
1246 // big_picture.pts = AV_NOPTS_VALUE;
1247 big_picture.pts= ost->sync_opts;
1248 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1249 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1250 if (ost->forced_kf_index < ost->forced_kf_count &&
1251 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1252 big_picture.pict_type = AV_PICTURE_TYPE_I;
1253 ost->forced_kf_index++;
1255 ret = avcodec_encode_video(enc,
1256 bit_buffer, bit_buffer_size,
1259 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1264 pkt.data= bit_buffer;
1266 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1267 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1268 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1269 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1270 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1272 if(enc->coded_frame->key_frame)
1273 pkt.flags |= AV_PKT_FLAG_KEY;
1274 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1277 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1278 // enc->frame_number-1, ret, enc->pict_type);
1279 /* if two pass, output log */
1280 if (ost->logfile && enc->stats_out) {
1281 fprintf(ost->logfile, "%s", enc->stats_out);
1286 ost->frame_number++;
1290 static double psnr(double d){
1291 return -10.0*log(d)/log(10.0);
1294 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1297 AVCodecContext *enc;
1299 double ti1, bitrate, avg_bitrate;
1301 /* this is executed just the first time do_video_stats is called */
1303 vstats_file = fopen(vstats_filename, "w");
1310 enc = ost->st->codec;
1311 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1312 frame_number = ost->frame_number;
1313 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1314 if (enc->flags&CODEC_FLAG_PSNR)
1315 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1317 fprintf(vstats_file,"f_size= %6d ", frame_size);
1318 /* compute pts value */
1319 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1323 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1324 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1325 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1326 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1327 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1331 static void print_report(OutputFile *output_files,
1332 OutputStream *ost_table, int nb_ostreams,
1333 int is_last_report, int64_t timer_start)
1337 AVFormatContext *oc;
1339 AVCodecContext *enc;
1340 int frame_number, vid, i;
1341 double bitrate, ti1, pts;
1342 static int64_t last_time = -1;
1343 static int qp_histogram[52];
1345 if (!print_stats && !is_last_report)
1348 if (!is_last_report) {
1350 /* display the report every 0.5 seconds */
1351 cur_time = av_gettime();
1352 if (last_time == -1) {
1353 last_time = cur_time;
1356 if ((cur_time - last_time) < 500000)
1358 last_time = cur_time;
1362 oc = output_files[0].ctx;
1364 total_size = avio_size(oc->pb);
1365 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1366 total_size= avio_tell(oc->pb);
1371 for(i=0;i<nb_ostreams;i++) {
1373 ost = &ost_table[i];
1374 enc = ost->st->codec;
1375 if (!ost->stream_copy && enc->coded_frame)
1376 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1377 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1378 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1380 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1381 float t = (av_gettime()-timer_start) / 1000000.0;
1383 frame_number = ost->frame_number;
1384 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1385 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1387 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1391 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1394 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1396 if (enc->flags&CODEC_FLAG_PSNR){
1398 double error, error_sum=0;
1399 double scale, scale_sum=0;
1400 char type[3]= {'Y','U','V'};
1401 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1404 error= enc->error[j];
1405 scale= enc->width*enc->height*255.0*255.0*frame_number;
1407 error= enc->coded_frame->error[j];
1408 scale= enc->width*enc->height*255.0*255.0;
1413 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1415 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1419 /* compute min output value */
1420 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1421 if ((pts < ti1) && (pts > 0))
1427 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1429 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1430 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1431 (double)total_size / 1024, ti1, bitrate);
1433 if (nb_frames_dup || nb_frames_drop)
1434 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1435 nb_frames_dup, nb_frames_drop);
1437 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1441 if (is_last_report) {
1442 int64_t raw= audio_size + video_size + extra_size;
1443 av_log(NULL, AV_LOG_INFO, "\n");
1444 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1448 100.0*(total_size - raw)/raw
1453 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1457 for (i = 0; i < nb_ostreams; i++) {
1458 OutputStream *ost = &ost_table[i];
1459 AVCodecContext *enc = ost->st->codec;
1460 AVFormatContext *os = output_files[ost->file_index].ctx;
1462 if (!ost->encoding_needed)
1465 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1467 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1473 av_init_packet(&pkt);
1474 pkt.stream_index= ost->index;
1476 switch (ost->st->codec->codec_type) {
1477 case AVMEDIA_TYPE_AUDIO:
1478 fifo_bytes = av_fifo_size(ost->fifo);
1480 /* encode any samples remaining in fifo */
1481 if (fifo_bytes > 0) {
1482 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1483 int fs_tmp = enc->frame_size;
1485 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1486 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1487 enc->frame_size = fifo_bytes / (osize * enc->channels);
1489 int frame_bytes = enc->frame_size*osize*enc->channels;
1490 if (allocated_audio_buf_size < frame_bytes)
1492 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1495 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1496 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1497 ost->st->time_base.num, enc->sample_rate);
1498 enc->frame_size = fs_tmp;
1501 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1504 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1508 pkt.flags |= AV_PKT_FLAG_KEY;
1510 case AVMEDIA_TYPE_VIDEO:
1511 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1513 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1517 if(enc->coded_frame && enc->coded_frame->key_frame)
1518 pkt.flags |= AV_PKT_FLAG_KEY;
1519 if (ost->logfile && enc->stats_out) {
1520 fprintf(ost->logfile, "%s", enc->stats_out);
1529 pkt.data = bit_buffer;
1531 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1532 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1533 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1539 * Check whether a packet from ist should be written into ost at this time
1541 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1543 OutputFile *of = &output_files[ost->file_index];
1544 int ist_index = ist - input_streams;
1546 if (ost->source_index != ist_index)
1549 if (of->start_time && ist->pts < of->start_time)
1552 if (of->recording_time != INT64_MAX &&
1553 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1554 (AVRational){1, 1000000}) >= 0) {
1555 ost->is_past_recording_time = 1;
1562 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1564 OutputFile *of = &output_files[ost->file_index];
1565 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1568 av_init_packet(&opkt);
1570 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1571 !ost->copy_initial_nonkeyframes)
1574 /* force the input stream PTS */
1575 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1576 audio_size += pkt->size;
1577 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1578 video_size += pkt->size;
1582 opkt.stream_index = ost->index;
1583 if (pkt->pts != AV_NOPTS_VALUE)
1584 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1586 opkt.pts = AV_NOPTS_VALUE;
1588 if (pkt->dts == AV_NOPTS_VALUE)
1589 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1591 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1592 opkt.dts -= ost_tb_start_time;
1594 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1595 opkt.flags = pkt->flags;
1597 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1598 if( ost->st->codec->codec_id != CODEC_ID_H264
1599 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1600 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1602 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1603 opkt.destruct = av_destruct_packet;
1605 opkt.data = pkt->data;
1606 opkt.size = pkt->size;
1609 write_frame(of->ctx, &opkt, ost->st->codec, ost->bitstream_filters);
1610 ost->st->codec->frame_number++;
1611 ost->frame_number++;
1612 av_free_packet(&opkt);
1615 static void rate_emu_sleep(InputStream *ist)
1617 if (input_files[ist->file_index].rate_emu) {
1618 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1619 int64_t now = av_gettime() - ist->start;
1625 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1627 AVFrame *decoded_frame;
1628 AVCodecContext *avctx = ist->st->codec;
1629 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1632 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1633 return AVERROR(ENOMEM);
1635 avcodec_get_frame_defaults(ist->decoded_frame);
1636 decoded_frame = ist->decoded_frame;
1638 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1644 /* no audio frame */
1648 /* if the decoder provides a pts, use it instead of the last packet pts.
1649 the decoder could be delaying output by a packet or more. */
1650 if (decoded_frame->pts != AV_NOPTS_VALUE)
1651 ist->next_pts = decoded_frame->pts;
1653 /* increment next_pts to use for the case where the input stream does not
1654 have timestamps or there are multiple frames in the packet */
1655 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1658 // preprocess audio (volume)
1659 if (audio_volume != 256) {
1660 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1661 void *samples = decoded_frame->data[0];
1662 switch (avctx->sample_fmt) {
1663 case AV_SAMPLE_FMT_U8:
1665 uint8_t *volp = samples;
1666 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1667 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1668 *volp++ = av_clip_uint8(v);
1672 case AV_SAMPLE_FMT_S16:
1674 int16_t *volp = samples;
1675 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1676 int v = ((*volp) * audio_volume + 128) >> 8;
1677 *volp++ = av_clip_int16(v);
1681 case AV_SAMPLE_FMT_S32:
1683 int32_t *volp = samples;
1684 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1685 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1686 *volp++ = av_clipl_int32(v);
1690 case AV_SAMPLE_FMT_FLT:
1692 float *volp = samples;
1693 float scale = audio_volume / 256.f;
1694 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1699 case AV_SAMPLE_FMT_DBL:
1701 double *volp = samples;
1702 double scale = audio_volume / 256.;
1703 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1709 av_log(NULL, AV_LOG_FATAL,
1710 "Audio volume adjustment on sample format %s is not supported.\n",
1711 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1716 rate_emu_sleep(ist);
1718 for (i = 0; i < nb_output_streams; i++) {
1719 OutputStream *ost = &output_streams[i];
1721 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1723 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
1729 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
1731 AVFrame *decoded_frame, *filtered_frame = NULL;
1732 void *buffer_to_free = NULL;
1736 int frame_available = 1;
1739 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1740 return AVERROR(ENOMEM);
1742 avcodec_get_frame_defaults(ist->decoded_frame);
1743 decoded_frame = ist->decoded_frame;
1744 pkt->pts = *pkt_pts;
1745 pkt->dts = ist->pts;
1746 *pkt_pts = AV_NOPTS_VALUE;
1748 ret = avcodec_decode_video2(ist->st->codec,
1749 decoded_frame, got_output, pkt);
1753 quality = same_quant ? decoded_frame->quality : 0;
1755 /* no picture yet */
1758 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1759 decoded_frame->pkt_dts);
1761 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
1762 else if (ist->st->codec->time_base.num != 0) {
1763 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1764 ist->st->codec->ticks_per_frame;
1765 ist->next_pts += ((int64_t)AV_TIME_BASE *
1766 ist->st->codec->time_base.num * ticks) /
1767 ist->st->codec->time_base.den;
1770 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1772 rate_emu_sleep(ist);
1774 for (i = 0; i < nb_output_streams; i++) {
1775 OutputStream *ost = &output_streams[i];
1778 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1782 if (ost->input_video_filter) {
1784 if (ist->st->sample_aspect_ratio.num)
1785 sar = ist->st->sample_aspect_ratio;
1787 sar = ist->st->codec->sample_aspect_ratio;
1788 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, ist->pts, sar);
1789 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
1790 av_free(buffer_to_free);
1791 return AVERROR(ENOMEM);
1793 avcodec_get_frame_defaults(ist->filtered_frame);
1794 filtered_frame = ist->filtered_frame;
1795 frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1797 while (frame_available) {
1798 AVRational ist_pts_tb;
1799 if (ost->output_video_filter)
1800 get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
1802 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1803 if (ost->picref->video && !ost->frame_aspect_ratio)
1804 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1806 filtered_frame = decoded_frame;
1809 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
1810 same_quant ? quality : ost->st->codec->global_quality);
1811 if (vstats_filename && frame_size)
1812 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
1814 frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1816 avfilter_unref_buffer(ost->picref);
1821 av_free(buffer_to_free);
1825 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1827 AVSubtitle subtitle;
1828 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1829 &subtitle, got_output, pkt);
1835 rate_emu_sleep(ist);
1837 for (i = 0; i < nb_output_streams; i++) {
1838 OutputStream *ost = &output_streams[i];
1840 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1843 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
1846 avsubtitle_free(&subtitle);
1850 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1851 static int output_packet(InputStream *ist,
1852 OutputStream *ost_table, int nb_ostreams,
1853 const AVPacket *pkt)
1857 int64_t pkt_pts = AV_NOPTS_VALUE;
1860 if (ist->next_pts == AV_NOPTS_VALUE)
1861 ist->next_pts = ist->pts;
1865 av_init_packet(&avpkt);
1873 if(pkt->dts != AV_NOPTS_VALUE)
1874 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1875 if(pkt->pts != AV_NOPTS_VALUE)
1876 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1878 //while we have more to decode or while the decoder did output something on EOF
1879 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
1883 ist->pts = ist->next_pts;
1885 if (avpkt.size && avpkt.size != pkt->size) {
1886 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1887 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1888 ist->showed_multi_packet_warning = 1;
1891 switch(ist->st->codec->codec_type) {
1892 case AVMEDIA_TYPE_AUDIO:
1893 ret = transcode_audio (ist, &avpkt, &got_output);
1895 case AVMEDIA_TYPE_VIDEO:
1896 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
1898 case AVMEDIA_TYPE_SUBTITLE:
1899 ret = transcode_subtitles(ist, &avpkt, &got_output);
1907 // touch data and size only if not EOF
1917 /* handle stream copy */
1918 if (!ist->decoding_needed) {
1919 rate_emu_sleep(ist);
1920 ist->pts = ist->next_pts;
1921 switch (ist->st->codec->codec_type) {
1922 case AVMEDIA_TYPE_AUDIO:
1923 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1924 ist->st->codec->sample_rate;
1926 case AVMEDIA_TYPE_VIDEO:
1927 if (ist->st->codec->time_base.num != 0) {
1928 int ticks = ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1929 ist->next_pts += ((int64_t)AV_TIME_BASE *
1930 ist->st->codec->time_base.num * ticks) /
1931 ist->st->codec->time_base.den;
1936 for (i = 0; pkt && i < nb_ostreams; i++) {
1937 OutputStream *ost = &ost_table[i];
1939 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
1942 do_streamcopy(ist, ost, pkt);
1948 static void print_sdp(OutputFile *output_files, int n)
1952 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1956 for (i = 0; i < n; i++)
1957 avc[i] = output_files[i].ctx;
1959 av_sdp_create(avc, n, sdp, sizeof(sdp));
1960 printf("SDP:\n%s\n", sdp);
1965 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1966 char *error, int error_len)
1969 InputStream *ist = &input_streams[ist_index];
1970 if (ist->decoding_needed) {
1971 AVCodec *codec = ist->dec;
1973 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
1974 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1975 return AVERROR(EINVAL);
1978 /* update requested sample format for the decoder based on the
1979 corresponding encoder sample format */
1980 for (i = 0; i < nb_output_streams; i++) {
1981 OutputStream *ost = &output_streams[i];
1982 if (ost->source_index == ist_index) {
1983 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1988 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1989 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
1990 ist->file_index, ist->st->index);
1991 return AVERROR(EINVAL);
1993 assert_codec_experimental(ist->st->codec, 0);
1994 assert_avoptions(ist->opts);
1997 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;
1998 ist->next_pts = AV_NOPTS_VALUE;
1999 init_pts_correction(&ist->pts_ctx);
2005 static int transcode_init(OutputFile *output_files,
2006 int nb_output_files,
2007 InputFile *input_files,
2010 int ret = 0, i, j, k;
2011 AVFormatContext *oc;
2012 AVCodecContext *codec, *icodec;
2018 /* init framerate emulation */
2019 for (i = 0; i < nb_input_files; i++) {
2020 InputFile *ifile = &input_files[i];
2021 if (ifile->rate_emu)
2022 for (j = 0; j < ifile->nb_streams; j++)
2023 input_streams[j + ifile->ist_index].start = av_gettime();
2026 /* output stream init */
2027 for (i = 0; i < nb_output_files; i++) {
2028 oc = output_files[i].ctx;
2029 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2030 av_dump_format(oc, i, oc->filename, 1);
2031 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2032 return AVERROR(EINVAL);
2036 /* for each output stream, we compute the right encoding parameters */
2037 for (i = 0; i < nb_output_streams; i++) {
2038 ost = &output_streams[i];
2039 oc = output_files[ost->file_index].ctx;
2040 ist = &input_streams[ost->source_index];
2042 if (ost->attachment_filename)
2045 codec = ost->st->codec;
2046 icodec = ist->st->codec;
2048 ost->st->disposition = ist->st->disposition;
2049 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2050 codec->chroma_sample_location = icodec->chroma_sample_location;
2052 if (ost->stream_copy) {
2053 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2055 if (extra_size > INT_MAX) {
2056 return AVERROR(EINVAL);
2059 /* if stream_copy is selected, no need to decode or encode */
2060 codec->codec_id = icodec->codec_id;
2061 codec->codec_type = icodec->codec_type;
2063 if (!codec->codec_tag) {
2064 if (!oc->oformat->codec_tag ||
2065 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2066 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2067 codec->codec_tag = icodec->codec_tag;
2070 codec->bit_rate = icodec->bit_rate;
2071 codec->rc_max_rate = icodec->rc_max_rate;
2072 codec->rc_buffer_size = icodec->rc_buffer_size;
2073 codec->extradata = av_mallocz(extra_size);
2074 if (!codec->extradata) {
2075 return AVERROR(ENOMEM);
2077 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2078 codec->extradata_size = icodec->extradata_size;
2080 codec->time_base = icodec->time_base;
2081 codec->time_base.num *= icodec->ticks_per_frame;
2082 av_reduce(&codec->time_base.num, &codec->time_base.den,
2083 codec->time_base.num, codec->time_base.den, INT_MAX);
2085 codec->time_base = ist->st->time_base;
2087 switch(codec->codec_type) {
2088 case AVMEDIA_TYPE_AUDIO:
2089 if(audio_volume != 256) {
2090 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2093 codec->channel_layout = icodec->channel_layout;
2094 codec->sample_rate = icodec->sample_rate;
2095 codec->channels = icodec->channels;
2096 codec->frame_size = icodec->frame_size;
2097 codec->audio_service_type = icodec->audio_service_type;
2098 codec->block_align = icodec->block_align;
2100 case AVMEDIA_TYPE_VIDEO:
2101 codec->pix_fmt = icodec->pix_fmt;
2102 codec->width = icodec->width;
2103 codec->height = icodec->height;
2104 codec->has_b_frames = icodec->has_b_frames;
2105 if (!codec->sample_aspect_ratio.num) {
2106 codec->sample_aspect_ratio =
2107 ost->st->sample_aspect_ratio =
2108 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2109 ist->st->codec->sample_aspect_ratio.num ?
2110 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2113 case AVMEDIA_TYPE_SUBTITLE:
2114 codec->width = icodec->width;
2115 codec->height = icodec->height;
2117 case AVMEDIA_TYPE_DATA:
2118 case AVMEDIA_TYPE_ATTACHMENT:
2125 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2127 ist->decoding_needed = 1;
2128 ost->encoding_needed = 1;
2130 switch(codec->codec_type) {
2131 case AVMEDIA_TYPE_AUDIO:
2132 ost->fifo = av_fifo_alloc(1024);
2134 return AVERROR(ENOMEM);
2136 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2138 if (!codec->sample_rate)
2139 codec->sample_rate = icodec->sample_rate;
2140 choose_sample_rate(ost->st, ost->enc);
2141 codec->time_base = (AVRational){1, codec->sample_rate};
2143 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2144 codec->sample_fmt = icodec->sample_fmt;
2145 choose_sample_fmt(ost->st, ost->enc);
2147 if (!codec->channels)
2148 codec->channels = icodec->channels;
2149 codec->channel_layout = icodec->channel_layout;
2150 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2151 codec->channel_layout = 0;
2153 ost->audio_resample = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2154 icodec->request_channels = codec-> channels;
2155 ost->resample_sample_fmt = icodec->sample_fmt;
2156 ost->resample_sample_rate = icodec->sample_rate;
2157 ost->resample_channels = icodec->channels;
2159 case AVMEDIA_TYPE_VIDEO:
2160 if (codec->pix_fmt == PIX_FMT_NONE)
2161 codec->pix_fmt = icodec->pix_fmt;
2162 choose_pixel_fmt(ost->st, ost->enc);
2164 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2165 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2169 if (!codec->width || !codec->height) {
2170 codec->width = icodec->width;
2171 codec->height = icodec->height;
2174 ost->video_resample = codec->width != icodec->width ||
2175 codec->height != icodec->height ||
2176 codec->pix_fmt != icodec->pix_fmt;
2177 if (ost->video_resample) {
2178 #if !CONFIG_AVFILTER
2179 avcodec_get_frame_defaults(&ost->pict_tmp);
2180 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2181 codec->width, codec->height)) {
2182 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2185 ost->img_resample_ctx = sws_getContext(
2192 ost->sws_flags, NULL, NULL, NULL);
2193 if (ost->img_resample_ctx == NULL) {
2194 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2198 codec->bits_per_raw_sample= 0;
2201 ost->resample_height = icodec->height;
2202 ost->resample_width = icodec->width;
2203 ost->resample_pix_fmt = icodec->pix_fmt;
2205 if (!ost->frame_rate.num)
2206 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2207 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2208 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2209 ost->frame_rate = ost->enc->supported_framerates[idx];
2211 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2214 if (configure_video_filters(ist, ost)) {
2215 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2220 case AVMEDIA_TYPE_SUBTITLE:
2227 if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2228 char logfilename[1024];
2231 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2232 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2234 if (codec->flags & CODEC_FLAG_PASS1) {
2235 f = fopen(logfilename, "wb");
2237 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2238 logfilename, strerror(errno));
2244 size_t logbuffer_size;
2245 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2246 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2250 codec->stats_in = logbuffer;
2254 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2255 int size = codec->width * codec->height;
2256 bit_buffer_size = FFMAX(bit_buffer_size, 6*size + 200);
2261 bit_buffer = av_malloc(bit_buffer_size);
2263 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2265 return AVERROR(ENOMEM);
2268 /* open each encoder */
2269 for (i = 0; i < nb_output_streams; i++) {
2270 ost = &output_streams[i];
2271 if (ost->encoding_needed) {
2272 AVCodec *codec = ost->enc;
2273 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2275 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2276 ost->st->codec->codec_id, ost->file_index, ost->index);
2277 ret = AVERROR(EINVAL);
2280 if (dec->subtitle_header) {
2281 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2282 if (!ost->st->codec->subtitle_header) {
2283 ret = AVERROR(ENOMEM);
2286 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2287 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2289 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2290 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2291 ost->file_index, ost->index);
2292 ret = AVERROR(EINVAL);
2295 assert_codec_experimental(ost->st->codec, 1);
2296 assert_avoptions(ost->opts);
2297 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2298 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2299 "It takes bits/s as argument, not kbits/s\n");
2300 extra_size += ost->st->codec->extradata_size;
2302 if (ost->st->codec->me_threshold)
2303 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2307 /* init input streams */
2308 for (i = 0; i < nb_input_streams; i++)
2309 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2312 /* discard unused programs */
2313 for (i = 0; i < nb_input_files; i++) {
2314 InputFile *ifile = &input_files[i];
2315 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2316 AVProgram *p = ifile->ctx->programs[j];
2317 int discard = AVDISCARD_ALL;
2319 for (k = 0; k < p->nb_stream_indexes; k++)
2320 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2321 discard = AVDISCARD_DEFAULT;
2324 p->discard = discard;
2328 /* open files and write file headers */
2329 for (i = 0; i < nb_output_files; i++) {
2330 oc = output_files[i].ctx;
2331 oc->interrupt_callback = int_cb;
2332 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2333 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2334 ret = AVERROR(EINVAL);
2337 assert_avoptions(output_files[i].opts);
2338 if (strcmp(oc->oformat->name, "rtp")) {
2344 /* dump the file output parameters - cannot be done before in case
2346 for (i = 0; i < nb_output_files; i++) {
2347 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2350 /* dump the stream mapping */
2351 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2352 for (i = 0; i < nb_output_streams; i++) {
2353 ost = &output_streams[i];
2355 if (ost->attachment_filename) {
2356 /* an attached file */
2357 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2358 ost->attachment_filename, ost->file_index, ost->index);
2361 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2362 input_streams[ost->source_index].file_index,
2363 input_streams[ost->source_index].st->index,
2366 if (ost->sync_ist != &input_streams[ost->source_index])
2367 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2368 ost->sync_ist->file_index,
2369 ost->sync_ist->st->index);
2370 if (ost->stream_copy)
2371 av_log(NULL, AV_LOG_INFO, " (copy)");
2373 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2374 input_streams[ost->source_index].dec->name : "?",
2375 ost->enc ? ost->enc->name : "?");
2376 av_log(NULL, AV_LOG_INFO, "\n");
2380 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2385 print_sdp(output_files, nb_output_files);
2392 * The following code is the main loop of the file converter
2394 static int transcode(OutputFile *output_files,
2395 int nb_output_files,
2396 InputFile *input_files,
2400 AVFormatContext *is, *os;
2404 int no_packet_count=0;
2405 int64_t timer_start;
2407 if (!(no_packet = av_mallocz(nb_input_files)))
2410 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2414 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2417 timer_start = av_gettime();
2419 for(; received_sigterm == 0;) {
2420 int file_index, ist_index;
2425 ipts_min = INT64_MAX;
2428 /* select the stream that we must read now by looking at the
2429 smallest output pts */
2431 for (i = 0; i < nb_output_streams; i++) {
2435 ost = &output_streams[i];
2436 of = &output_files[ost->file_index];
2437 os = output_files[ost->file_index].ctx;
2438 ist = &input_streams[ost->source_index];
2439 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2440 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2442 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2444 if (!input_files[ist->file_index].eof_reached){
2445 if(ipts < ipts_min) {
2447 if(input_sync ) file_index = ist->file_index;
2449 if(opts < opts_min) {
2451 if(!input_sync) file_index = ist->file_index;
2454 if (ost->frame_number >= ost->max_frames) {
2456 for (j = 0; j < of->ctx->nb_streams; j++)
2457 output_streams[of->ost_index + j].is_past_recording_time = 1;
2461 /* if none, if is finished */
2462 if (file_index < 0) {
2463 if(no_packet_count){
2465 memset(no_packet, 0, nb_input_files);
2472 /* read a frame from it and output it in the fifo */
2473 is = input_files[file_index].ctx;
2474 ret= av_read_frame(is, &pkt);
2475 if(ret == AVERROR(EAGAIN)){
2476 no_packet[file_index]=1;
2481 input_files[file_index].eof_reached = 1;
2489 memset(no_packet, 0, nb_input_files);
2492 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2493 is->streams[pkt.stream_index]);
2495 /* the following test is needed in case new streams appear
2496 dynamically in stream : we ignore them */
2497 if (pkt.stream_index >= input_files[file_index].nb_streams)
2498 goto discard_packet;
2499 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2500 ist = &input_streams[ist_index];
2502 goto discard_packet;
2504 if (pkt.dts != AV_NOPTS_VALUE)
2505 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2506 if (pkt.pts != AV_NOPTS_VALUE)
2507 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2509 if(pkt.pts != AV_NOPTS_VALUE)
2510 pkt.pts *= ist->ts_scale;
2511 if(pkt.dts != AV_NOPTS_VALUE)
2512 pkt.dts *= ist->ts_scale;
2514 // 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);
2515 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2516 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2517 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2518 int64_t delta= pkt_dts - ist->next_pts;
2519 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2520 input_files[ist->file_index].ts_offset -= delta;
2521 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2522 delta, input_files[ist->file_index].ts_offset);
2523 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2524 if(pkt.pts != AV_NOPTS_VALUE)
2525 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2529 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2530 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2532 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2533 ist->file_index, ist->st->index);
2536 av_free_packet(&pkt);
2541 av_free_packet(&pkt);
2543 /* dump report by using the output first video and audio streams */
2544 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2547 /* at the end of stream, we must flush the decoder buffers */
2548 for (i = 0; i < nb_input_streams; i++) {
2549 ist = &input_streams[i];
2550 if (ist->decoding_needed) {
2551 output_packet(ist, output_streams, nb_output_streams, NULL);
2554 flush_encoders(output_streams, nb_output_streams);
2558 /* write the trailer if needed and close file */
2559 for(i=0;i<nb_output_files;i++) {
2560 os = output_files[i].ctx;
2561 av_write_trailer(os);
2564 /* dump report by using the first video and audio streams */
2565 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2567 /* close each encoder */
2568 for (i = 0; i < nb_output_streams; i++) {
2569 ost = &output_streams[i];
2570 if (ost->encoding_needed) {
2571 av_freep(&ost->st->codec->stats_in);
2572 avcodec_close(ost->st->codec);
2575 avfilter_graph_free(&ost->graph);
2579 /* close each decoder */
2580 for (i = 0; i < nb_input_streams; i++) {
2581 ist = &input_streams[i];
2582 if (ist->decoding_needed) {
2583 avcodec_close(ist->st->codec);
2591 av_freep(&bit_buffer);
2592 av_freep(&no_packet);
2594 if (output_streams) {
2595 for (i = 0; i < nb_output_streams; i++) {
2596 ost = &output_streams[i];
2598 if (ost->stream_copy)
2599 av_freep(&ost->st->codec->extradata);
2601 fclose(ost->logfile);
2602 ost->logfile = NULL;
2604 av_fifo_free(ost->fifo); /* works even if fifo is not
2605 initialized but set to zero */
2606 av_freep(&ost->st->codec->subtitle_header);
2607 av_free(ost->pict_tmp.data[0]);
2608 av_free(ost->forced_kf_pts);
2609 if (ost->video_resample)
2610 sws_freeContext(ost->img_resample_ctx);
2612 audio_resample_close(ost->resample);
2613 if (ost->reformat_ctx)
2614 av_audio_convert_free(ost->reformat_ctx);
2615 av_dict_free(&ost->opts);
2622 static double parse_frame_aspect_ratio(const char *arg)
2629 p = strchr(arg, ':');
2631 x = strtol(arg, &end, 10);
2633 y = strtol(end+1, &end, 10);
2635 ar = (double)x / (double)y;
2637 ar = strtod(arg, NULL);
2640 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2646 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2648 return parse_option(o, "codec:a", arg, options);
2651 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2653 return parse_option(o, "codec:v", arg, options);
2656 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2658 return parse_option(o, "codec:s", arg, options);
2661 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2663 return parse_option(o, "codec:d", arg, options);
2666 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2668 StreamMap *m = NULL;
2669 int i, negative = 0, file_idx;
2670 int sync_file_idx = -1, sync_stream_idx;
2678 map = av_strdup(arg);
2680 /* parse sync stream first, just pick first matching stream */
2681 if (sync = strchr(map, ',')) {
2683 sync_file_idx = strtol(sync + 1, &sync, 0);
2684 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2685 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2690 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2691 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2692 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2693 sync_stream_idx = i;
2696 if (i == input_files[sync_file_idx].nb_streams) {
2697 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2698 "match any streams.\n", arg);
2704 file_idx = strtol(map, &p, 0);
2705 if (file_idx >= nb_input_files || file_idx < 0) {
2706 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2710 /* disable some already defined maps */
2711 for (i = 0; i < o->nb_stream_maps; i++) {
2712 m = &o->stream_maps[i];
2713 if (file_idx == m->file_index &&
2714 check_stream_specifier(input_files[m->file_index].ctx,
2715 input_files[m->file_index].ctx->streams[m->stream_index],
2716 *p == ':' ? p + 1 : p) > 0)
2720 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2721 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2722 *p == ':' ? p + 1 : p) <= 0)
2724 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2725 &o->nb_stream_maps, o->nb_stream_maps + 1);
2726 m = &o->stream_maps[o->nb_stream_maps - 1];
2728 m->file_index = file_idx;
2729 m->stream_index = i;
2731 if (sync_file_idx >= 0) {
2732 m->sync_file_index = sync_file_idx;
2733 m->sync_stream_index = sync_stream_idx;
2735 m->sync_file_index = file_idx;
2736 m->sync_stream_index = i;
2741 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2749 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
2751 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
2752 &o->nb_attachments, o->nb_attachments + 1);
2753 o->attachments[o->nb_attachments - 1] = arg;
2758 * Parse a metadata specifier in arg.
2759 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
2760 * @param index for type c/p, chapter/program index is written here
2761 * @param stream_spec for type s, the stream specifier is written here
2763 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
2771 if (*(++arg) && *arg != ':') {
2772 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
2775 *stream_spec = *arg == ':' ? arg + 1 : "";
2779 if (*(++arg) == ':')
2780 *index = strtol(++arg, NULL, 0);
2783 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2790 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
2792 AVDictionary **meta_in = NULL;
2793 AVDictionary **meta_out;
2795 char type_in, type_out;
2796 const char *istream_spec = NULL, *ostream_spec = NULL;
2797 int idx_in = 0, idx_out = 0;
2799 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
2800 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
2802 if (type_in == 'g' || type_out == 'g')
2803 o->metadata_global_manual = 1;
2804 if (type_in == 's' || type_out == 's')
2805 o->metadata_streams_manual = 1;
2806 if (type_in == 'c' || type_out == 'c')
2807 o->metadata_chapters_manual = 1;
2809 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
2810 if ((index) < 0 || (index) >= (nb_elems)) {\
2811 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
2816 #define SET_DICT(type, meta, context, index)\
2819 meta = &context->metadata;\
2822 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
2823 meta = &context->chapters[index]->metadata;\
2826 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
2827 meta = &context->programs[index]->metadata;\
2831 SET_DICT(type_in, meta_in, ic, idx_in);
2832 SET_DICT(type_out, meta_out, oc, idx_out);
2834 /* for input streams choose first matching stream */
2835 if (type_in == 's') {
2836 for (i = 0; i < ic->nb_streams; i++) {
2837 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
2838 meta_in = &ic->streams[i]->metadata;
2844 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
2849 if (type_out == 's') {
2850 for (i = 0; i < oc->nb_streams; i++) {
2851 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
2852 meta_out = &oc->streams[i]->metadata;
2853 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
2858 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
2863 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2865 const char *codec_string = encoder ? "encoder" : "decoder";
2869 avcodec_find_encoder_by_name(name) :
2870 avcodec_find_decoder_by_name(name);
2872 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2875 if(codec->type != type) {
2876 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2882 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
2884 char *codec_name = NULL;
2886 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2888 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
2889 st->codec->codec_id = codec->id;
2892 return avcodec_find_decoder(st->codec->codec_id);
2896 * Add all the streams from the given input file to the global
2897 * list of input streams.
2899 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2901 int i, rfps, rfps_base;
2903 for (i = 0; i < ic->nb_streams; i++) {
2904 AVStream *st = ic->streams[i];
2905 AVCodecContext *dec = st->codec;
2908 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2909 ist = &input_streams[nb_input_streams - 1];
2911 ist->file_index = nb_input_files;
2913 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2915 ist->ts_scale = 1.0;
2916 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
2918 ist->dec = choose_decoder(o, ic, st);
2920 switch (dec->codec_type) {
2921 case AVMEDIA_TYPE_AUDIO:
2922 if (o->audio_disable)
2923 st->discard= AVDISCARD_ALL;
2925 case AVMEDIA_TYPE_VIDEO:
2926 rfps = ic->streams[i]->r_frame_rate.num;
2927 rfps_base = ic->streams[i]->r_frame_rate.den;
2929 dec->flags |= CODEC_FLAG_EMU_EDGE;
2930 dec->height >>= dec->lowres;
2931 dec->width >>= dec->lowres;
2934 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2936 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",
2937 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2938 (float)rfps / rfps_base, rfps, rfps_base);
2941 if (o->video_disable)
2942 st->discard= AVDISCARD_ALL;
2943 else if(video_discard)
2944 st->discard= video_discard;
2946 case AVMEDIA_TYPE_DATA:
2948 case AVMEDIA_TYPE_SUBTITLE:
2949 if (o->subtitle_disable)
2950 st->discard = AVDISCARD_ALL;
2952 case AVMEDIA_TYPE_ATTACHMENT:
2953 case AVMEDIA_TYPE_UNKNOWN:
2961 static void assert_file_overwrite(const char *filename)
2963 if (!file_overwrite &&
2964 (strchr(filename, ':') == NULL || filename[1] == ':' ||
2965 av_strstart(filename, "file:", NULL))) {
2966 if (avio_check(filename, 0) == 0) {
2968 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
2970 if (!read_yesno()) {
2971 fprintf(stderr, "Not overwriting - exiting\n");
2976 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
2983 static void dump_attachment(AVStream *st, const char *filename)
2986 AVIOContext *out = NULL;
2987 AVDictionaryEntry *e;
2989 if (!st->codec->extradata_size) {
2990 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
2991 nb_input_files - 1, st->index);
2994 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
2995 filename = e->value;
2997 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
2998 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3002 assert_file_overwrite(filename);
3004 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3005 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3010 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3015 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3017 AVFormatContext *ic;
3018 AVInputFormat *file_iformat = NULL;
3022 AVDictionary **opts;
3023 int orig_nb_streams; // number of streams before avformat_find_stream_info
3026 if (!(file_iformat = av_find_input_format(o->format))) {
3027 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3032 if (!strcmp(filename, "-"))
3035 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3036 !strcmp(filename, "/dev/stdin");
3038 /* get default parameters from command line */
3039 ic = avformat_alloc_context();
3041 print_error(filename, AVERROR(ENOMEM));
3044 if (o->nb_audio_sample_rate) {
3045 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3046 av_dict_set(&format_opts, "sample_rate", buf, 0);
3048 if (o->nb_audio_channels) {
3049 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3050 av_dict_set(&format_opts, "channels", buf, 0);
3052 if (o->nb_frame_rates) {
3053 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3055 if (o->nb_frame_sizes) {
3056 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3058 if (o->nb_frame_pix_fmts)
3059 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3061 ic->flags |= AVFMT_FLAG_NONBLOCK;
3062 ic->interrupt_callback = int_cb;
3064 /* open the input file with generic libav function */
3065 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3067 print_error(filename, err);
3070 assert_avoptions(format_opts);
3072 /* apply forced codec ids */
3073 for (i = 0; i < ic->nb_streams; i++)
3074 choose_decoder(o, ic, ic->streams[i]);
3076 /* Set AVCodecContext options for avformat_find_stream_info */
3077 opts = setup_find_stream_info_opts(ic, codec_opts);
3078 orig_nb_streams = ic->nb_streams;
3080 /* If not enough info to get the stream parameters, we decode the
3081 first frames to get it. (used in mpeg case for example) */
3082 ret = avformat_find_stream_info(ic, opts);
3084 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3085 avformat_close_input(&ic);
3089 timestamp = o->start_time;
3090 /* add the stream start time */
3091 if (ic->start_time != AV_NOPTS_VALUE)
3092 timestamp += ic->start_time;
3094 /* if seeking requested, we execute it */
3095 if (o->start_time != 0) {
3096 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3098 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3099 filename, (double)timestamp / AV_TIME_BASE);
3103 /* update the current parameters so that they match the one of the input stream */
3104 add_input_streams(o, ic);
3106 /* dump the file content */
3107 av_dump_format(ic, nb_input_files, filename, 0);
3109 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3110 input_files[nb_input_files - 1].ctx = ic;
3111 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3112 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3113 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3114 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3116 for (i = 0; i < o->nb_dump_attachment; i++) {
3119 for (j = 0; j < ic->nb_streams; j++) {
3120 AVStream *st = ic->streams[j];
3122 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3123 dump_attachment(st, o->dump_attachment[i].u.str);
3127 for (i = 0; i < orig_nb_streams; i++)
3128 av_dict_free(&opts[i]);
3135 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3136 AVCodecContext *avctx)
3142 for (p = kf; *p; p++)
3145 ost->forced_kf_count = n;
3146 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3147 if (!ost->forced_kf_pts) {
3148 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3151 for (i = 0; i < n; i++) {
3152 p = i ? strchr(p, ',') + 1 : kf;
3153 t = parse_time_or_die("force_key_frames", p, 1);
3154 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3158 static uint8_t *get_line(AVIOContext *s)
3164 if (avio_open_dyn_buf(&line) < 0) {
3165 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3169 while ((c = avio_r8(s)) && c != '\n')
3172 avio_close_dyn_buf(line, &buf);
3177 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3180 char filename[1000];
3181 const char *base[3] = { getenv("AVCONV_DATADIR"),
3186 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3190 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3191 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3192 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3195 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3196 i != 1 ? "" : "/.avconv", preset_name);
3197 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3203 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3205 char *codec_name = NULL;
3207 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3209 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3210 NULL, ost->st->codec->codec_type);
3211 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3212 } else if (!strcmp(codec_name, "copy"))
3213 ost->stream_copy = 1;
3215 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3216 ost->st->codec->codec_id = ost->enc->id;
3220 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3223 AVStream *st = avformat_new_stream(oc, NULL);
3224 int idx = oc->nb_streams - 1, ret = 0;
3225 char *bsf = NULL, *next, *codec_tag = NULL;
3226 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3228 char *buf = NULL, *arg = NULL, *preset = NULL;
3229 AVIOContext *s = NULL;
3232 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3236 if (oc->nb_streams - 1 < o->nb_streamid_map)
3237 st->id = o->streamid_map[oc->nb_streams - 1];
3239 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3240 nb_output_streams + 1);
3241 ost = &output_streams[nb_output_streams - 1];
3242 ost->file_index = nb_output_files;
3245 st->codec->codec_type = type;
3246 choose_encoder(o, oc, ost);
3248 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3251 avcodec_get_context_defaults3(st->codec, ost->enc);
3252 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3254 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3255 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3258 if (!buf[0] || buf[0] == '#') {
3262 if (!(arg = strchr(buf, '='))) {
3263 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3267 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3269 } while (!s->eof_reached);
3273 av_log(NULL, AV_LOG_FATAL,
3274 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3275 preset, ost->file_index, ost->index);
3279 ost->max_frames = INT64_MAX;
3280 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3282 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3284 if (next = strchr(bsf, ','))
3286 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3287 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3291 bsfc_prev->next = bsfc;
3293 ost->bitstream_filters = bsfc;
3299 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3301 uint32_t tag = strtol(codec_tag, &next, 0);
3303 tag = AV_RL32(codec_tag);
3304 st->codec->codec_tag = tag;
3307 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3308 if (qscale >= 0 || same_quant) {
3309 st->codec->flags |= CODEC_FLAG_QSCALE;
3310 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3313 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3314 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3316 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3320 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3323 const char *p = str;
3330 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3337 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3341 AVCodecContext *video_enc;
3343 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3345 video_enc = st->codec;
3347 if (!ost->stream_copy) {
3348 const char *p = NULL;
3349 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3350 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3351 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3354 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3355 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3356 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3360 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3361 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3362 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3366 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3367 if (frame_aspect_ratio)
3368 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3370 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3371 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3372 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3375 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3377 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3379 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3380 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3383 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3385 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3387 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3388 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3391 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3394 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3397 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3399 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3402 video_enc->rc_override=
3403 av_realloc(video_enc->rc_override,
3404 sizeof(RcOverride)*(i+1));
3405 video_enc->rc_override[i].start_frame= start;
3406 video_enc->rc_override[i].end_frame = end;
3408 video_enc->rc_override[i].qscale= q;
3409 video_enc->rc_override[i].quality_factor= 1.0;
3412 video_enc->rc_override[i].qscale= 0;
3413 video_enc->rc_override[i].quality_factor= -q/100.0;
3418 video_enc->rc_override_count=i;
3419 if (!video_enc->rc_initial_buffer_occupancy)
3420 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3421 video_enc->intra_dc_precision= intra_dc_precision - 8;
3426 video_enc->flags |= CODEC_FLAG_PASS1;
3428 video_enc->flags |= CODEC_FLAG_PASS2;
3432 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3433 if (forced_key_frames)
3434 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3436 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3438 ost->top_field_first = -1;
3439 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3441 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3444 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3446 ost->avfilter = av_strdup(filters);
3453 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3457 AVCodecContext *audio_enc;
3459 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3462 audio_enc = st->codec;
3463 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3465 if (!ost->stream_copy) {
3466 char *sample_fmt = NULL;
3468 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3470 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3472 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3473 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3477 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3483 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3487 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3488 if (!ost->stream_copy) {
3489 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3496 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3498 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3499 ost->stream_copy = 1;
3503 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3507 AVCodecContext *subtitle_enc;
3509 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3511 subtitle_enc = st->codec;
3513 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3518 /* arg format is "output-stream-index:streamid-value". */
3519 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3525 av_strlcpy(idx_str, arg, sizeof(idx_str));
3526 p = strchr(idx_str, ':');
3528 av_log(NULL, AV_LOG_FATAL,
3529 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3534 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3535 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3536 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3540 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3542 AVFormatContext *is = ifile->ctx;
3543 AVFormatContext *os = ofile->ctx;
3546 for (i = 0; i < is->nb_chapters; i++) {
3547 AVChapter *in_ch = is->chapters[i], *out_ch;
3548 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3549 AV_TIME_BASE_Q, in_ch->time_base);
3550 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3551 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3554 if (in_ch->end < ts_off)
3556 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3559 out_ch = av_mallocz(sizeof(AVChapter));
3561 return AVERROR(ENOMEM);
3563 out_ch->id = in_ch->id;
3564 out_ch->time_base = in_ch->time_base;
3565 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3566 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3569 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3572 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3574 return AVERROR(ENOMEM);
3575 os->chapters[os->nb_chapters - 1] = out_ch;
3580 static void opt_output_file(void *optctx, const char *filename)
3582 OptionsContext *o = optctx;
3583 AVFormatContext *oc;
3585 AVOutputFormat *file_oformat;
3589 if (!strcmp(filename, "-"))
3592 oc = avformat_alloc_context();
3594 print_error(filename, AVERROR(ENOMEM));
3599 file_oformat = av_guess_format(o->format, NULL, NULL);
3600 if (!file_oformat) {
3601 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3605 file_oformat = av_guess_format(NULL, filename, NULL);
3606 if (!file_oformat) {
3607 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3613 oc->oformat = file_oformat;
3614 oc->interrupt_callback = int_cb;
3615 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3617 if (!o->nb_stream_maps) {
3618 /* pick the "best" stream of each type */
3619 #define NEW_STREAM(type, index)\
3621 ost = new_ ## type ## _stream(o, oc);\
3622 ost->source_index = index;\
3623 ost->sync_ist = &input_streams[index];\
3624 input_streams[index].discard = 0;\
3627 /* video: highest resolution */
3628 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3629 int area = 0, idx = -1;
3630 for (i = 0; i < nb_input_streams; i++) {
3631 ist = &input_streams[i];
3632 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3633 ist->st->codec->width * ist->st->codec->height > area) {
3634 area = ist->st->codec->width * ist->st->codec->height;
3638 NEW_STREAM(video, idx);
3641 /* audio: most channels */
3642 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3643 int channels = 0, idx = -1;
3644 for (i = 0; i < nb_input_streams; i++) {
3645 ist = &input_streams[i];
3646 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3647 ist->st->codec->channels > channels) {
3648 channels = ist->st->codec->channels;
3652 NEW_STREAM(audio, idx);
3655 /* subtitles: pick first */
3656 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3657 for (i = 0; i < nb_input_streams; i++)
3658 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3659 NEW_STREAM(subtitle, i);
3663 /* do something with data? */
3665 for (i = 0; i < o->nb_stream_maps; i++) {
3666 StreamMap *map = &o->stream_maps[i];
3671 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3672 switch (ist->st->codec->codec_type) {
3673 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3674 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3675 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3676 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3677 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3679 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
3680 map->file_index, map->stream_index);
3684 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3685 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3686 map->sync_stream_index];
3691 /* handle attached files */
3692 for (i = 0; i < o->nb_attachments; i++) {
3694 uint8_t *attachment;
3698 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
3699 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
3703 if ((len = avio_size(pb)) <= 0) {
3704 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
3708 if (!(attachment = av_malloc(len))) {
3709 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
3713 avio_read(pb, attachment, len);
3715 ost = new_attachment_stream(o, oc);
3716 ost->stream_copy = 0;
3717 ost->source_index = -1;
3718 ost->attachment_filename = o->attachments[i];
3719 ost->st->codec->extradata = attachment;
3720 ost->st->codec->extradata_size = len;
3722 p = strrchr(o->attachments[i], '/');
3723 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
3727 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3728 output_files[nb_output_files - 1].ctx = oc;
3729 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3730 output_files[nb_output_files - 1].recording_time = o->recording_time;
3731 output_files[nb_output_files - 1].start_time = o->start_time;
3732 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3733 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3735 /* check filename in case of an image number is expected */
3736 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3737 if (!av_filename_number_test(oc->filename)) {
3738 print_error(oc->filename, AVERROR(EINVAL));
3743 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3744 /* test if it already exists to avoid losing precious files */
3745 assert_file_overwrite(filename);
3748 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
3749 &oc->interrupt_callback,
3750 &output_files[nb_output_files - 1].opts)) < 0) {
3751 print_error(filename, err);
3756 if (o->mux_preload) {
3758 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3759 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3761 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3762 oc->flags |= AVFMT_FLAG_NONBLOCK;
3765 for (i = 0; i < o->nb_metadata_map; i++) {
3767 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
3769 if (in_file_index < 0)
3771 if (in_file_index >= nb_input_files) {
3772 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
3775 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
3779 if (o->chapters_input_file >= nb_input_files) {
3780 if (o->chapters_input_file == INT_MAX) {
3781 /* copy chapters from the first input file that has them*/
3782 o->chapters_input_file = -1;
3783 for (i = 0; i < nb_input_files; i++)
3784 if (input_files[i].ctx->nb_chapters) {
3785 o->chapters_input_file = i;
3789 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3790 o->chapters_input_file);
3794 if (o->chapters_input_file >= 0)
3795 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3796 !o->metadata_chapters_manual);
3798 /* copy global metadata by default */
3799 if (!o->metadata_global_manual && nb_input_files)
3800 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3801 AV_DICT_DONT_OVERWRITE);
3802 if (!o->metadata_streams_manual)
3803 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3805 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
3807 ist = &input_streams[output_streams[i].source_index];
3808 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3811 /* process manually set metadata */
3812 for (i = 0; i < o->nb_metadata; i++) {
3815 const char *stream_spec;
3816 int index = 0, j, ret;
3818 val = strchr(o->metadata[i].u.str, '=');
3820 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3821 o->metadata[i].u.str);
3826 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
3828 for (j = 0; j < oc->nb_streams; j++) {
3829 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
3830 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
3834 printf("ret %d, stream_spec %s\n", ret, stream_spec);
3842 if (index < 0 || index >= oc->nb_chapters) {
3843 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3846 m = &oc->chapters[index]->metadata;
3849 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3852 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3859 /* same option as mencoder */
3860 static int opt_pass(const char *opt, const char *arg)
3862 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3866 static int64_t getutime(void)
3869 struct rusage rusage;
3871 getrusage(RUSAGE_SELF, &rusage);
3872 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3873 #elif HAVE_GETPROCESSTIMES
3875 FILETIME c, e, k, u;
3876 proc = GetCurrentProcess();
3877 GetProcessTimes(proc, &c, &e, &k, &u);
3878 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3880 return av_gettime();
3884 static int64_t getmaxrss(void)
3886 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3887 struct rusage rusage;
3888 getrusage(RUSAGE_SELF, &rusage);
3889 return (int64_t)rusage.ru_maxrss * 1024;
3890 #elif HAVE_GETPROCESSMEMORYINFO
3892 PROCESS_MEMORY_COUNTERS memcounters;
3893 proc = GetCurrentProcess();
3894 memcounters.cb = sizeof(memcounters);
3895 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3896 return memcounters.PeakPagefileUsage;
3902 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3904 return parse_option(o, "q:a", arg, options);
3907 static void show_usage(void)
3909 printf("Hyper fast Audio and Video encoder\n");
3910 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3914 static void show_help(void)
3916 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3917 av_log_set_callback(log_callback_help);
3919 show_help_options(options, "Main options:\n",
3920 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3921 show_help_options(options, "\nAdvanced options:\n",
3922 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3924 show_help_options(options, "\nVideo options:\n",
3925 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3927 show_help_options(options, "\nAdvanced Video options:\n",
3928 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3929 OPT_VIDEO | OPT_EXPERT);
3930 show_help_options(options, "\nAudio options:\n",
3931 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3933 show_help_options(options, "\nAdvanced Audio options:\n",
3934 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3935 OPT_AUDIO | OPT_EXPERT);
3936 show_help_options(options, "\nSubtitle options:\n",
3937 OPT_SUBTITLE | OPT_GRAB,
3939 show_help_options(options, "\nAudio/Video grab options:\n",
3943 show_help_children(avcodec_get_class(), flags);
3944 show_help_children(avformat_get_class(), flags);
3945 show_help_children(sws_get_class(), flags);
3948 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3950 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3951 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3953 if(!strncmp(arg, "pal-", 4)) {
3956 } else if(!strncmp(arg, "ntsc-", 5)) {
3959 } else if(!strncmp(arg, "film-", 5)) {
3963 /* Try to determine PAL/NTSC by peeking in the input files */
3964 if(nb_input_files) {
3966 for (j = 0; j < nb_input_files; j++) {
3967 for (i = 0; i < input_files[j].nb_streams; i++) {
3968 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3969 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3971 fr = c->time_base.den * 1000 / c->time_base.num;
3975 } else if((fr == 29970) || (fr == 23976)) {
3984 if (norm != UNKNOWN)
3985 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3988 if(norm == UNKNOWN) {
3989 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3990 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3991 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3995 if(!strcmp(arg, "vcd")) {
3996 opt_video_codec(o, "c:v", "mpeg1video");
3997 opt_audio_codec(o, "c:a", "mp2");
3998 parse_option(o, "f", "vcd", options);
4000 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4001 parse_option(o, "r", frame_rates[norm], options);
4002 opt_default("g", norm == PAL ? "15" : "18");
4004 opt_default("b", "1150000");
4005 opt_default("maxrate", "1150000");
4006 opt_default("minrate", "1150000");
4007 opt_default("bufsize", "327680"); // 40*1024*8;
4009 opt_default("b:a", "224000");
4010 parse_option(o, "ar", "44100", options);
4011 parse_option(o, "ac", "2", options);
4013 opt_default("packetsize", "2324");
4014 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4016 /* We have to offset the PTS, so that it is consistent with the SCR.
4017 SCR starts at 36000, but the first two packs contain only padding
4018 and the first pack from the other stream, respectively, may also have
4019 been written before.
4020 So the real data starts at SCR 36000+3*1200. */
4021 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4022 } else if(!strcmp(arg, "svcd")) {
4024 opt_video_codec(o, "c:v", "mpeg2video");
4025 opt_audio_codec(o, "c:a", "mp2");
4026 parse_option(o, "f", "svcd", options);
4028 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4029 parse_option(o, "r", frame_rates[norm], options);
4030 opt_default("g", norm == PAL ? "15" : "18");
4032 opt_default("b", "2040000");
4033 opt_default("maxrate", "2516000");
4034 opt_default("minrate", "0"); //1145000;
4035 opt_default("bufsize", "1835008"); //224*1024*8;
4036 opt_default("flags", "+scan_offset");
4039 opt_default("b:a", "224000");
4040 parse_option(o, "ar", "44100", options);
4042 opt_default("packetsize", "2324");
4044 } else if(!strcmp(arg, "dvd")) {
4046 opt_video_codec(o, "c:v", "mpeg2video");
4047 opt_audio_codec(o, "c:a", "ac3");
4048 parse_option(o, "f", "dvd", options);
4050 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4051 parse_option(o, "r", frame_rates[norm], options);
4052 opt_default("g", norm == PAL ? "15" : "18");
4054 opt_default("b", "6000000");
4055 opt_default("maxrate", "9000000");
4056 opt_default("minrate", "0"); //1500000;
4057 opt_default("bufsize", "1835008"); //224*1024*8;
4059 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4060 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4062 opt_default("b:a", "448000");
4063 parse_option(o, "ar", "48000", options);
4065 } else if(!strncmp(arg, "dv", 2)) {
4067 parse_option(o, "f", "dv", options);
4069 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4070 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4071 norm == PAL ? "yuv420p" : "yuv411p", options);
4072 parse_option(o, "r", frame_rates[norm], options);
4074 parse_option(o, "ar", "48000", options);
4075 parse_option(o, "ac", "2", options);
4078 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4079 return AVERROR(EINVAL);
4084 static int opt_vstats_file(const char *opt, const char *arg)
4086 av_free (vstats_filename);
4087 vstats_filename=av_strdup (arg);
4091 static int opt_vstats(const char *opt, const char *arg)
4094 time_t today2 = time(NULL);
4095 struct tm *today = localtime(&today2);
4097 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4099 return opt_vstats_file(opt, filename);
4102 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4104 return parse_option(o, "frames:v", arg, options);
4107 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4109 return parse_option(o, "frames:a", arg, options);
4112 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4114 return parse_option(o, "frames:d", arg, options);
4117 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4119 return parse_option(o, "tag:v", arg, options);
4122 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4124 return parse_option(o, "tag:a", arg, options);
4127 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4129 return parse_option(o, "tag:s", arg, options);
4132 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4134 return parse_option(o, "filter:v", arg, options);
4137 #define OFFSET(x) offsetof(OptionsContext, x)
4138 static const OptionDef options[] = {
4140 #include "cmdutils_common_opts.h"
4141 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4142 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4143 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4144 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4145 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4146 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4147 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4148 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4149 "outfile[,metadata]:infile[,metadata]" },
4150 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4151 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4152 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4153 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4154 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4155 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4156 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4157 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4158 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4159 "add timings for benchmarking" },
4160 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4161 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4162 "dump each input packet" },
4163 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4164 "when dumping packets, also dump the payload" },
4165 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4166 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4167 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4168 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4169 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4170 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4171 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4172 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4173 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4174 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4175 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4176 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4177 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4178 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4179 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4181 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4183 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4184 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4185 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4188 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4189 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4190 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4191 { "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" },
4192 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4193 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4194 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4195 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4196 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4197 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4198 "use same quantizer as source (implies VBR)" },
4199 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4200 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4201 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4202 "deinterlace pictures" },
4203 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4204 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4206 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4208 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4209 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4210 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4211 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4212 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4213 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4214 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4215 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4216 { "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" },
4219 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4220 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4221 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4222 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4223 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4224 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4225 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4226 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4227 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4229 /* subtitle options */
4230 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4231 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4232 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4235 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4238 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4239 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4241 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4243 /* data codec support */
4244 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4246 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4250 int main(int argc, char **argv)
4252 OptionsContext o = { 0 };
4257 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4258 parse_loglevel(argc, argv, options);
4260 avcodec_register_all();
4262 avdevice_register_all();
4265 avfilter_register_all();
4268 avformat_network_init();
4273 parse_options(&o, argc, argv, options, opt_output_file);
4275 if(nb_output_files <= 0 && nb_input_files == 0) {
4277 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4281 /* file converter / grab */
4282 if (nb_output_files <= 0) {
4283 fprintf(stderr, "At least one output file must be specified\n");
4287 if (nb_input_files == 0) {
4288 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4293 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4295 ti = getutime() - ti;
4297 int maxrss = getmaxrss() / 1024;
4298 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);