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 *presets;
337 SpecifierOpt *copy_initial_nonkeyframes;
338 int nb_copy_initial_nonkeyframes;
340 SpecifierOpt *filters;
345 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
348 for (i = 0; i < o->nb_ ## name; i++) {\
349 char *spec = o->name[i].specifier;\
350 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
351 outvar = o->name[i].u.type;\
357 static void reset_options(OptionsContext *o)
359 const OptionDef *po = options;
361 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
363 void *dst = (uint8_t*)o + po->u.off;
365 if (po->flags & OPT_SPEC) {
366 SpecifierOpt **so = dst;
367 int i, *count = (int*)(so + 1);
368 for (i = 0; i < *count; i++) {
369 av_freep(&(*so)[i].specifier);
370 if (po->flags & OPT_STRING)
371 av_freep(&(*so)[i].u.str);
375 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
380 av_freep(&o->stream_maps);
381 av_freep(&o->meta_data_maps);
382 av_freep(&o->streamid_map);
384 memset(o, 0, sizeof(*o));
386 o->mux_max_delay = 0.7;
387 o->recording_time = INT64_MAX;
388 o->limit_filesize = UINT64_MAX;
389 o->chapters_input_file = INT_MAX;
397 static int configure_video_filters(InputStream *ist, OutputStream *ost)
399 AVFilterContext *last_filter, *filter;
400 /** filter graph containing all filters including input & output */
401 AVCodecContext *codec = ost->st->codec;
402 AVCodecContext *icodec = ist->st->codec;
403 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
404 AVRational sample_aspect_ratio;
408 ost->graph = avfilter_graph_alloc();
410 if (ist->st->sample_aspect_ratio.num){
411 sample_aspect_ratio = ist->st->sample_aspect_ratio;
413 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
415 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
416 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
417 sample_aspect_ratio.num, sample_aspect_ratio.den);
419 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
420 "src", args, NULL, ost->graph);
423 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
424 "out", NULL, &ffsink_ctx, ost->graph);
427 last_filter = ost->input_video_filter;
429 if (codec->width != icodec->width || codec->height != icodec->height) {
430 snprintf(args, 255, "%d:%d:flags=0x%X",
433 (unsigned)ost->sws_flags);
434 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
435 NULL, args, NULL, ost->graph)) < 0)
437 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
439 last_filter = filter;
442 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
443 ost->graph->scale_sws_opts = av_strdup(args);
446 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
447 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
449 outputs->name = av_strdup("in");
450 outputs->filter_ctx = last_filter;
451 outputs->pad_idx = 0;
452 outputs->next = NULL;
454 inputs->name = av_strdup("out");
455 inputs->filter_ctx = ost->output_video_filter;
459 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
461 av_freep(&ost->avfilter);
463 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
467 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
470 codec->width = ost->output_video_filter->inputs[0]->w;
471 codec->height = ost->output_video_filter->inputs[0]->h;
472 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
473 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
474 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
475 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
479 #endif /* CONFIG_AVFILTER */
481 static void term_exit(void)
483 av_log(NULL, AV_LOG_QUIET, "");
486 static volatile int received_sigterm = 0;
487 static volatile int received_nb_signals = 0;
490 sigterm_handler(int sig)
492 received_sigterm = sig;
493 received_nb_signals++;
497 static void term_init(void)
499 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
500 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
502 signal(SIGXCPU, sigterm_handler);
506 static int decode_interrupt_cb(void *ctx)
508 return received_nb_signals > 1;
511 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
513 void exit_program(int ret)
518 for(i=0;i<nb_output_files;i++) {
519 AVFormatContext *s = output_files[i].ctx;
520 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
522 avformat_free_context(s);
523 av_dict_free(&output_files[i].opts);
525 for(i=0;i<nb_input_files;i++) {
526 av_close_input_file(input_files[i].ctx);
528 for (i = 0; i < nb_input_streams; i++) {
529 av_freep(&input_streams[i].decoded_frame);
530 av_freep(&input_streams[i].filtered_frame);
531 av_dict_free(&input_streams[i].opts);
536 av_free(vstats_filename);
538 av_freep(&input_streams);
539 av_freep(&input_files);
540 av_freep(&output_streams);
541 av_freep(&output_files);
546 allocated_audio_buf_size= allocated_audio_out_size= 0;
551 avformat_network_deinit();
553 if (received_sigterm) {
554 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
555 (int) received_sigterm);
562 static void assert_avoptions(AVDictionary *m)
564 AVDictionaryEntry *t;
565 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
566 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
571 static void assert_codec_experimental(AVCodecContext *c, int encoder)
573 const char *codec_string = encoder ? "encoder" : "decoder";
575 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
576 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
577 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
578 "results.\nAdd '-strict experimental' if you want to use it.\n",
579 codec_string, c->codec->name);
580 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
581 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
582 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
583 codec_string, codec->name);
588 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
590 if(codec && codec->sample_fmts){
591 const enum AVSampleFormat *p= codec->sample_fmts;
593 if(*p == st->codec->sample_fmt)
597 av_log(NULL, AV_LOG_WARNING,
598 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
599 av_get_sample_fmt_name(st->codec->sample_fmt),
601 av_get_sample_fmt_name(codec->sample_fmts[0]));
602 st->codec->sample_fmt = codec->sample_fmts[0];
608 * Update the requested input sample format based on the output sample format.
609 * This is currently only used to request float output from decoders which
610 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
611 * Ideally this will be removed in the future when decoders do not do format
612 * conversion and only output in their native format.
614 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
617 /* if sample formats match or a decoder sample format has already been
618 requested, just return */
619 if (enc->sample_fmt == dec->sample_fmt ||
620 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
623 /* if decoder supports more than one output format */
624 if (dec_codec && dec_codec->sample_fmts &&
625 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
626 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
627 const enum AVSampleFormat *p;
628 int min_dec = -1, min_inc = -1;
630 /* find a matching sample format in the encoder */
631 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
632 if (*p == enc->sample_fmt) {
633 dec->request_sample_fmt = *p;
635 } else if (*p > enc->sample_fmt) {
636 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
638 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
641 /* if none match, provide the one that matches quality closest */
642 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
643 enc->sample_fmt - min_dec;
647 static void choose_sample_rate(AVStream *st, AVCodec *codec)
649 if(codec && codec->supported_samplerates){
650 const int *p= codec->supported_samplerates;
652 int best_dist=INT_MAX;
654 int dist= abs(st->codec->sample_rate - *p);
655 if(dist < best_dist){
661 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
663 st->codec->sample_rate= best;
667 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
669 if(codec && codec->pix_fmts){
670 const enum PixelFormat *p= codec->pix_fmts;
671 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
672 if(st->codec->codec_id==CODEC_ID_MJPEG){
673 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
674 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
675 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};
678 for (; *p != PIX_FMT_NONE; p++) {
679 if(*p == st->codec->pix_fmt)
682 if (*p == PIX_FMT_NONE) {
683 if(st->codec->pix_fmt != PIX_FMT_NONE)
684 av_log(NULL, AV_LOG_WARNING,
685 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
686 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
688 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
689 st->codec->pix_fmt = codec->pix_fmts[0];
695 get_sync_ipts(const OutputStream *ost)
697 const InputStream *ist = ost->sync_ist;
698 OutputFile *of = &output_files[ost->file_index];
699 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
702 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
706 AVPacket new_pkt= *pkt;
707 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
708 &new_pkt.data, &new_pkt.size,
709 pkt->data, pkt->size,
710 pkt->flags & AV_PKT_FLAG_KEY);
713 new_pkt.destruct= av_destruct_packet;
715 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
716 bsfc->filter->name, pkt->stream_index,
717 avctx->codec ? avctx->codec->name : "copy");
727 ret= av_interleaved_write_frame(s, pkt);
729 print_error("av_interleaved_write_frame()", ret);
734 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
736 int fill_char = 0x00;
737 if (sample_fmt == AV_SAMPLE_FMT_U8)
739 memset(buf, fill_char, size);
742 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
743 InputStream *ist, AVFrame *decoded_frame)
746 int64_t audio_out_size, audio_buf_size;
748 int size_out, frame_bytes, ret, resample_changed;
749 AVCodecContext *enc= ost->st->codec;
750 AVCodecContext *dec= ist->st->codec;
751 int osize = av_get_bytes_per_sample(enc->sample_fmt);
752 int isize = av_get_bytes_per_sample(dec->sample_fmt);
753 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
754 uint8_t *buf = decoded_frame->data[0];
755 int size = decoded_frame->nb_samples * dec->channels * isize;
756 int64_t allocated_for_size = size;
759 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
760 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
761 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
762 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
763 audio_buf_size*= osize*enc->channels;
765 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
766 if(coded_bps > 8*osize)
767 audio_out_size= audio_out_size * coded_bps / (8*osize);
768 audio_out_size += FF_MIN_BUFFER_SIZE;
770 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
771 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
775 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
776 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
777 if (!audio_buf || !audio_out){
778 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
782 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
783 ost->audio_resample = 1;
785 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
786 ost->resample_channels != dec->channels ||
787 ost->resample_sample_rate != dec->sample_rate;
789 if ((ost->audio_resample && !ost->resample) || resample_changed) {
790 if (resample_changed) {
791 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",
792 ist->file_index, ist->st->index,
793 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
794 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
795 ost->resample_sample_fmt = dec->sample_fmt;
796 ost->resample_channels = dec->channels;
797 ost->resample_sample_rate = dec->sample_rate;
799 audio_resample_close(ost->resample);
801 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
802 if (audio_sync_method <= 1 &&
803 ost->resample_sample_fmt == enc->sample_fmt &&
804 ost->resample_channels == enc->channels &&
805 ost->resample_sample_rate == enc->sample_rate) {
806 ost->resample = NULL;
807 ost->audio_resample = 0;
808 } else if (ost->audio_resample) {
809 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
810 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
811 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
812 enc->sample_rate, dec->sample_rate,
813 enc->sample_fmt, dec->sample_fmt,
815 if (!ost->resample) {
816 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
817 dec->channels, dec->sample_rate,
818 enc->channels, enc->sample_rate);
824 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
825 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
826 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
827 if (ost->reformat_ctx)
828 av_audio_convert_free(ost->reformat_ctx);
829 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
830 dec->sample_fmt, 1, NULL, 0);
831 if (!ost->reformat_ctx) {
832 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
833 av_get_sample_fmt_name(dec->sample_fmt),
834 av_get_sample_fmt_name(enc->sample_fmt));
837 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
840 if(audio_sync_method){
841 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
842 - av_fifo_size(ost->fifo)/(enc->channels * osize);
843 int idelta = delta * dec->sample_rate / enc->sample_rate;
844 int byte_delta = idelta * isize * dec->channels;
846 //FIXME resample delay
847 if(fabs(delta) > 50){
848 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
850 byte_delta= FFMAX(byte_delta, -size);
853 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
854 -byte_delta / (isize * dec->channels));
859 static uint8_t *input_tmp= NULL;
860 input_tmp= av_realloc(input_tmp, byte_delta + size);
862 if(byte_delta > allocated_for_size - size){
863 allocated_for_size= byte_delta + (int64_t)size;
868 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
869 memcpy(input_tmp + byte_delta, buf, size);
872 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
874 }else if(audio_sync_method>1){
875 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
876 av_assert0(ost->audio_resample);
877 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
878 delta, comp, enc->sample_rate);
879 // 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));
880 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
884 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
885 - av_fifo_size(ost->fifo)/(enc->channels * osize); //FIXME wrong
887 if (ost->audio_resample) {
889 size_out = audio_resample(ost->resample,
890 (short *)buftmp, (short *)buf,
891 size / (dec->channels * isize));
892 size_out = size_out * enc->channels * osize;
898 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
899 const void *ibuf[6]= {buftmp};
900 void *obuf[6]= {audio_buf};
901 int istride[6]= {isize};
902 int ostride[6]= {osize};
903 int len= size_out/istride[0];
904 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
905 printf("av_audio_convert() failed\n");
911 size_out = len*osize;
914 /* now encode as many frames as possible */
915 if (enc->frame_size > 1) {
916 /* output resampled raw samples */
917 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
918 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
921 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
923 frame_bytes = enc->frame_size * osize * enc->channels;
925 while (av_fifo_size(ost->fifo) >= frame_bytes) {
927 av_init_packet(&pkt);
929 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
931 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
933 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
936 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
940 pkt.stream_index= ost->index;
943 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
944 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
945 pkt.flags |= AV_PKT_FLAG_KEY;
946 write_frame(s, &pkt, enc, ost->bitstream_filters);
948 ost->sync_opts += enc->frame_size;
952 av_init_packet(&pkt);
954 ost->sync_opts += size_out / (osize * enc->channels);
956 /* output a pcm frame */
957 /* determine the size of the coded buffer */
960 size_out = size_out*coded_bps/8;
962 if(size_out > audio_out_size){
963 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
967 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
968 ret = avcodec_encode_audio(enc, audio_out, size_out,
971 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
975 pkt.stream_index= ost->index;
978 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
979 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
980 pkt.flags |= AV_PKT_FLAG_KEY;
981 write_frame(s, &pkt, enc, ost->bitstream_filters);
985 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
989 AVPicture picture_tmp;
992 dec = ist->st->codec;
994 /* deinterlace : must be done before any resize */
995 if (do_deinterlace) {
998 /* create temporary picture */
999 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1000 buf = av_malloc(size);
1004 picture2 = &picture_tmp;
1005 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1007 if(avpicture_deinterlace(picture2, picture,
1008 dec->pix_fmt, dec->width, dec->height) < 0) {
1009 /* if error, do not deinterlace */
1010 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1019 if (picture != picture2)
1020 *picture = *picture2;
1024 static void do_subtitle_out(AVFormatContext *s,
1030 static uint8_t *subtitle_out = NULL;
1031 int subtitle_out_max_size = 1024 * 1024;
1032 int subtitle_out_size, nb, i;
1033 AVCodecContext *enc;
1036 if (pts == AV_NOPTS_VALUE) {
1037 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1043 enc = ost->st->codec;
1045 if (!subtitle_out) {
1046 subtitle_out = av_malloc(subtitle_out_max_size);
1049 /* Note: DVB subtitle need one packet to draw them and one other
1050 packet to clear them */
1051 /* XXX: signal it in the codec context ? */
1052 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1057 for(i = 0; i < nb; i++) {
1058 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1059 // start_display_time is required to be 0
1060 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1061 sub->end_display_time -= sub->start_display_time;
1062 sub->start_display_time = 0;
1063 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1064 subtitle_out_max_size, sub);
1065 if (subtitle_out_size < 0) {
1066 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1070 av_init_packet(&pkt);
1071 pkt.stream_index = ost->index;
1072 pkt.data = subtitle_out;
1073 pkt.size = subtitle_out_size;
1074 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1075 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1076 /* XXX: the pts correction is handled here. Maybe handling
1077 it in the codec would be better */
1079 pkt.pts += 90 * sub->start_display_time;
1081 pkt.pts += 90 * sub->end_display_time;
1083 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1087 static int bit_buffer_size= 1024*256;
1088 static uint8_t *bit_buffer= NULL;
1090 static void do_video_resample(OutputStream *ost,
1092 AVFrame *in_picture,
1093 AVFrame **out_picture)
1095 int resample_changed = 0;
1096 AVCodecContext *dec = ist->st->codec;
1097 *out_picture = in_picture;
1099 resample_changed = ost->resample_width != dec->width ||
1100 ost->resample_height != dec->height ||
1101 ost->resample_pix_fmt != dec->pix_fmt;
1103 if (resample_changed) {
1104 av_log(NULL, AV_LOG_INFO,
1105 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1106 ist->file_index, ist->st->index,
1107 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1108 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1109 if(!ost->video_resample)
1110 ost->video_resample = 1;
1113 #if !CONFIG_AVFILTER
1114 if (ost->video_resample) {
1115 *out_picture = &ost->pict_tmp;
1116 if (resample_changed) {
1117 /* initialize a new scaler context */
1118 sws_freeContext(ost->img_resample_ctx);
1119 ost->img_resample_ctx = sws_getContext(
1120 ist->st->codec->width,
1121 ist->st->codec->height,
1122 ist->st->codec->pix_fmt,
1123 ost->st->codec->width,
1124 ost->st->codec->height,
1125 ost->st->codec->pix_fmt,
1126 ost->sws_flags, NULL, NULL, NULL);
1127 if (ost->img_resample_ctx == NULL) {
1128 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1132 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1133 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1136 if (resample_changed) {
1137 avfilter_graph_free(&ost->graph);
1138 if (configure_video_filters(ist, ost)) {
1139 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1144 if (resample_changed) {
1145 ost->resample_width = dec->width;
1146 ost->resample_height = dec->height;
1147 ost->resample_pix_fmt = dec->pix_fmt;
1152 static void do_video_out(AVFormatContext *s,
1155 AVFrame *in_picture,
1156 int *frame_size, float quality)
1158 int nb_frames, i, ret, format_video_sync;
1159 AVFrame *final_picture;
1160 AVCodecContext *enc;
1163 enc = ost->st->codec;
1165 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1167 /* by default, we output a single frame */
1172 format_video_sync = video_sync_method;
1173 if (format_video_sync < 0)
1174 format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? 0 :
1175 (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1177 if (format_video_sync) {
1178 double vdelta = sync_ipts - ost->sync_opts;
1179 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1182 else if (format_video_sync == 2) {
1185 }else if(vdelta>0.6)
1186 ost->sync_opts= lrintf(sync_ipts);
1187 }else if (vdelta > 1.1)
1188 nb_frames = lrintf(vdelta);
1189 //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);
1190 if (nb_frames == 0){
1192 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1193 }else if (nb_frames > 1) {
1194 nb_frames_dup += nb_frames - 1;
1195 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1198 ost->sync_opts= lrintf(sync_ipts);
1200 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1204 do_video_resample(ost, ist, in_picture, &final_picture);
1206 /* duplicates frame if needed */
1207 for(i=0;i<nb_frames;i++) {
1209 av_init_packet(&pkt);
1210 pkt.stream_index= ost->index;
1212 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1213 enc->codec->id == CODEC_ID_RAWVIDEO) {
1214 /* raw pictures are written as AVPicture structure to
1215 avoid any copies. We support temporarily the older
1217 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1218 enc->coded_frame->top_field_first = in_picture->top_field_first;
1219 pkt.data= (uint8_t *)final_picture;
1220 pkt.size= sizeof(AVPicture);
1221 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1222 pkt.flags |= AV_PKT_FLAG_KEY;
1224 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1226 AVFrame big_picture;
1228 big_picture= *final_picture;
1229 /* better than nothing: use input picture interlaced
1231 big_picture.interlaced_frame = in_picture->interlaced_frame;
1232 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1233 if (ost->top_field_first == -1)
1234 big_picture.top_field_first = in_picture->top_field_first;
1236 big_picture.top_field_first = !!ost->top_field_first;
1239 /* handles same_quant here. This is not correct because it may
1240 not be a global option */
1241 big_picture.quality = quality;
1242 if (!enc->me_threshold)
1243 big_picture.pict_type = 0;
1244 // big_picture.pts = AV_NOPTS_VALUE;
1245 big_picture.pts= ost->sync_opts;
1246 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1247 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1248 if (ost->forced_kf_index < ost->forced_kf_count &&
1249 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1250 big_picture.pict_type = AV_PICTURE_TYPE_I;
1251 ost->forced_kf_index++;
1253 ret = avcodec_encode_video(enc,
1254 bit_buffer, bit_buffer_size,
1257 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1262 pkt.data= bit_buffer;
1264 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1265 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1266 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1267 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1268 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1270 if(enc->coded_frame->key_frame)
1271 pkt.flags |= AV_PKT_FLAG_KEY;
1272 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1275 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1276 // enc->frame_number-1, ret, enc->pict_type);
1277 /* if two pass, output log */
1278 if (ost->logfile && enc->stats_out) {
1279 fprintf(ost->logfile, "%s", enc->stats_out);
1284 ost->frame_number++;
1288 static double psnr(double d){
1289 return -10.0*log(d)/log(10.0);
1292 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1295 AVCodecContext *enc;
1297 double ti1, bitrate, avg_bitrate;
1299 /* this is executed just the first time do_video_stats is called */
1301 vstats_file = fopen(vstats_filename, "w");
1308 enc = ost->st->codec;
1309 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1310 frame_number = ost->frame_number;
1311 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1312 if (enc->flags&CODEC_FLAG_PSNR)
1313 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1315 fprintf(vstats_file,"f_size= %6d ", frame_size);
1316 /* compute pts value */
1317 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1321 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1322 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1323 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1324 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1325 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1329 static void print_report(OutputFile *output_files,
1330 OutputStream *ost_table, int nb_ostreams,
1331 int is_last_report, int64_t timer_start)
1335 AVFormatContext *oc;
1337 AVCodecContext *enc;
1338 int frame_number, vid, i;
1339 double bitrate, ti1, pts;
1340 static int64_t last_time = -1;
1341 static int qp_histogram[52];
1343 if (!print_stats && !is_last_report)
1346 if (!is_last_report) {
1348 /* display the report every 0.5 seconds */
1349 cur_time = av_gettime();
1350 if (last_time == -1) {
1351 last_time = cur_time;
1354 if ((cur_time - last_time) < 500000)
1356 last_time = cur_time;
1360 oc = output_files[0].ctx;
1362 total_size = avio_size(oc->pb);
1363 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1364 total_size= avio_tell(oc->pb);
1369 for(i=0;i<nb_ostreams;i++) {
1371 ost = &ost_table[i];
1372 enc = ost->st->codec;
1373 if (!ost->stream_copy && enc->coded_frame)
1374 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1375 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1376 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1378 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1379 float t = (av_gettime()-timer_start) / 1000000.0;
1381 frame_number = ost->frame_number;
1382 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1383 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1385 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1389 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1392 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1394 if (enc->flags&CODEC_FLAG_PSNR){
1396 double error, error_sum=0;
1397 double scale, scale_sum=0;
1398 char type[3]= {'Y','U','V'};
1399 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1402 error= enc->error[j];
1403 scale= enc->width*enc->height*255.0*255.0*frame_number;
1405 error= enc->coded_frame->error[j];
1406 scale= enc->width*enc->height*255.0*255.0;
1411 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1413 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1417 /* compute min output value */
1418 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1419 if ((pts < ti1) && (pts > 0))
1425 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1427 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1428 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1429 (double)total_size / 1024, ti1, bitrate);
1431 if (nb_frames_dup || nb_frames_drop)
1432 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1433 nb_frames_dup, nb_frames_drop);
1435 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1439 if (is_last_report) {
1440 int64_t raw= audio_size + video_size + extra_size;
1441 av_log(NULL, AV_LOG_INFO, "\n");
1442 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1446 100.0*(total_size - raw)/raw
1451 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1455 for (i = 0; i < nb_ostreams; i++) {
1456 OutputStream *ost = &ost_table[i];
1457 AVCodecContext *enc = ost->st->codec;
1458 AVFormatContext *os = output_files[ost->file_index].ctx;
1460 if (!ost->encoding_needed)
1463 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1465 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1471 av_init_packet(&pkt);
1472 pkt.stream_index= ost->index;
1474 switch (ost->st->codec->codec_type) {
1475 case AVMEDIA_TYPE_AUDIO:
1476 fifo_bytes = av_fifo_size(ost->fifo);
1478 /* encode any samples remaining in fifo */
1479 if (fifo_bytes > 0) {
1480 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1481 int fs_tmp = enc->frame_size;
1483 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1484 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1485 enc->frame_size = fifo_bytes / (osize * enc->channels);
1487 int frame_bytes = enc->frame_size*osize*enc->channels;
1488 if (allocated_audio_buf_size < frame_bytes)
1490 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1493 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1494 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1495 ost->st->time_base.num, enc->sample_rate);
1496 enc->frame_size = fs_tmp;
1499 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1502 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1506 pkt.flags |= AV_PKT_FLAG_KEY;
1508 case AVMEDIA_TYPE_VIDEO:
1509 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1511 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1515 if(enc->coded_frame && enc->coded_frame->key_frame)
1516 pkt.flags |= AV_PKT_FLAG_KEY;
1517 if (ost->logfile && enc->stats_out) {
1518 fprintf(ost->logfile, "%s", enc->stats_out);
1527 pkt.data = bit_buffer;
1529 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1530 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1531 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1537 * Check whether a packet from ist should be written into ost at this time
1539 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1541 OutputFile *of = &output_files[ost->file_index];
1542 int ist_index = ist - input_streams;
1544 if (ost->source_index != ist_index)
1547 if (of->start_time && ist->pts < of->start_time)
1550 if (of->recording_time != INT64_MAX &&
1551 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1552 (AVRational){1, 1000000}) >= 0) {
1553 ost->is_past_recording_time = 1;
1560 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1562 OutputFile *of = &output_files[ost->file_index];
1563 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1566 av_init_packet(&opkt);
1568 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1569 !ost->copy_initial_nonkeyframes)
1572 /* force the input stream PTS */
1573 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1574 audio_size += pkt->size;
1575 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1576 video_size += pkt->size;
1580 opkt.stream_index = ost->index;
1581 if (pkt->pts != AV_NOPTS_VALUE)
1582 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1584 opkt.pts = AV_NOPTS_VALUE;
1586 if (pkt->dts == AV_NOPTS_VALUE)
1587 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1589 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1590 opkt.dts -= ost_tb_start_time;
1592 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1593 opkt.flags = pkt->flags;
1595 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1596 if( ost->st->codec->codec_id != CODEC_ID_H264
1597 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1598 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1600 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1601 opkt.destruct = av_destruct_packet;
1603 opkt.data = pkt->data;
1604 opkt.size = pkt->size;
1607 write_frame(of->ctx, &opkt, ost->st->codec, ost->bitstream_filters);
1608 ost->st->codec->frame_number++;
1609 ost->frame_number++;
1610 av_free_packet(&opkt);
1613 static void rate_emu_sleep(InputStream *ist)
1615 if (input_files[ist->file_index].rate_emu) {
1616 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1617 int64_t now = av_gettime() - ist->start;
1623 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1625 AVFrame *decoded_frame;
1626 AVCodecContext *avctx = ist->st->codec;
1627 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1630 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1631 return AVERROR(ENOMEM);
1633 avcodec_get_frame_defaults(ist->decoded_frame);
1634 decoded_frame = ist->decoded_frame;
1636 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1642 /* no audio frame */
1646 /* if the decoder provides a pts, use it instead of the last packet pts.
1647 the decoder could be delaying output by a packet or more. */
1648 if (decoded_frame->pts != AV_NOPTS_VALUE)
1649 ist->next_pts = decoded_frame->pts;
1651 /* increment next_pts to use for the case where the input stream does not
1652 have timestamps or there are multiple frames in the packet */
1653 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1656 // preprocess audio (volume)
1657 if (audio_volume != 256) {
1658 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1659 void *samples = decoded_frame->data[0];
1660 switch (avctx->sample_fmt) {
1661 case AV_SAMPLE_FMT_U8:
1663 uint8_t *volp = samples;
1664 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1665 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1666 *volp++ = av_clip_uint8(v);
1670 case AV_SAMPLE_FMT_S16:
1672 int16_t *volp = samples;
1673 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1674 int v = ((*volp) * audio_volume + 128) >> 8;
1675 *volp++ = av_clip_int16(v);
1679 case AV_SAMPLE_FMT_S32:
1681 int32_t *volp = samples;
1682 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1683 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1684 *volp++ = av_clipl_int32(v);
1688 case AV_SAMPLE_FMT_FLT:
1690 float *volp = samples;
1691 float scale = audio_volume / 256.f;
1692 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1697 case AV_SAMPLE_FMT_DBL:
1699 double *volp = samples;
1700 double scale = audio_volume / 256.;
1701 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1707 av_log(NULL, AV_LOG_FATAL,
1708 "Audio volume adjustment on sample format %s is not supported.\n",
1709 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1714 rate_emu_sleep(ist);
1716 for (i = 0; i < nb_output_streams; i++) {
1717 OutputStream *ost = &output_streams[i];
1719 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1721 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
1727 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
1729 AVFrame *decoded_frame, *filtered_frame = NULL;
1730 void *buffer_to_free = NULL;
1734 int frame_available = 1;
1737 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1738 return AVERROR(ENOMEM);
1740 avcodec_get_frame_defaults(ist->decoded_frame);
1741 decoded_frame = ist->decoded_frame;
1742 pkt->pts = *pkt_pts;
1743 pkt->dts = ist->pts;
1744 *pkt_pts = AV_NOPTS_VALUE;
1746 ret = avcodec_decode_video2(ist->st->codec,
1747 decoded_frame, got_output, pkt);
1751 quality = same_quant ? decoded_frame->quality : 0;
1753 /* no picture yet */
1756 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1757 decoded_frame->pkt_dts);
1759 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
1760 else if (ist->st->codec->time_base.num != 0) {
1761 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1762 ist->st->codec->ticks_per_frame;
1763 ist->next_pts += ((int64_t)AV_TIME_BASE *
1764 ist->st->codec->time_base.num * ticks) /
1765 ist->st->codec->time_base.den;
1768 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1770 rate_emu_sleep(ist);
1772 for (i = 0; i < nb_output_streams; i++) {
1773 OutputStream *ost = &output_streams[i];
1776 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1780 if (ost->input_video_filter) {
1782 if (ist->st->sample_aspect_ratio.num)
1783 sar = ist->st->sample_aspect_ratio;
1785 sar = ist->st->codec->sample_aspect_ratio;
1786 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, ist->pts, sar);
1787 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
1788 av_free(buffer_to_free);
1789 return AVERROR(ENOMEM);
1791 avcodec_get_frame_defaults(ist->filtered_frame);
1792 filtered_frame = ist->filtered_frame;
1793 frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1795 while (frame_available) {
1796 AVRational ist_pts_tb;
1797 if (ost->output_video_filter)
1798 get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
1800 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1801 if (ost->picref->video && !ost->frame_aspect_ratio)
1802 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1804 filtered_frame = decoded_frame;
1807 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
1808 same_quant ? quality : ost->st->codec->global_quality);
1809 if (vstats_filename && frame_size)
1810 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
1812 frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1814 avfilter_unref_buffer(ost->picref);
1819 av_free(buffer_to_free);
1823 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1825 AVSubtitle subtitle;
1826 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1827 &subtitle, got_output, pkt);
1833 rate_emu_sleep(ist);
1835 for (i = 0; i < nb_output_streams; i++) {
1836 OutputStream *ost = &output_streams[i];
1838 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1841 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
1844 avsubtitle_free(&subtitle);
1848 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1849 static int output_packet(InputStream *ist,
1850 OutputStream *ost_table, int nb_ostreams,
1851 const AVPacket *pkt)
1855 int64_t pkt_pts = AV_NOPTS_VALUE;
1858 if (ist->next_pts == AV_NOPTS_VALUE)
1859 ist->next_pts = ist->pts;
1863 av_init_packet(&avpkt);
1871 if(pkt->dts != AV_NOPTS_VALUE)
1872 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1873 if(pkt->pts != AV_NOPTS_VALUE)
1874 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1876 //while we have more to decode or while the decoder did output something on EOF
1877 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
1881 ist->pts = ist->next_pts;
1883 if (avpkt.size && avpkt.size != pkt->size) {
1884 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1885 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1886 ist->showed_multi_packet_warning = 1;
1889 switch(ist->st->codec->codec_type) {
1890 case AVMEDIA_TYPE_AUDIO:
1891 ret = transcode_audio (ist, &avpkt, &got_output);
1893 case AVMEDIA_TYPE_VIDEO:
1894 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
1896 case AVMEDIA_TYPE_SUBTITLE:
1897 ret = transcode_subtitles(ist, &avpkt, &got_output);
1905 // touch data and size only if not EOF
1915 /* handle stream copy */
1916 if (!ist->decoding_needed) {
1917 rate_emu_sleep(ist);
1918 ist->pts = ist->next_pts;
1919 switch (ist->st->codec->codec_type) {
1920 case AVMEDIA_TYPE_AUDIO:
1921 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1922 ist->st->codec->sample_rate;
1924 case AVMEDIA_TYPE_VIDEO:
1925 if (ist->st->codec->time_base.num != 0) {
1926 int ticks = ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1927 ist->next_pts += ((int64_t)AV_TIME_BASE *
1928 ist->st->codec->time_base.num * ticks) /
1929 ist->st->codec->time_base.den;
1934 for (i = 0; pkt && i < nb_ostreams; i++) {
1935 OutputStream *ost = &ost_table[i];
1937 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
1940 do_streamcopy(ist, ost, pkt);
1946 static void print_sdp(OutputFile *output_files, int n)
1950 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1954 for (i = 0; i < n; i++)
1955 avc[i] = output_files[i].ctx;
1957 av_sdp_create(avc, n, sdp, sizeof(sdp));
1958 printf("SDP:\n%s\n", sdp);
1963 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1964 char *error, int error_len)
1967 InputStream *ist = &input_streams[ist_index];
1968 if (ist->decoding_needed) {
1969 AVCodec *codec = ist->dec;
1971 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
1972 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1973 return AVERROR(EINVAL);
1976 /* update requested sample format for the decoder based on the
1977 corresponding encoder sample format */
1978 for (i = 0; i < nb_output_streams; i++) {
1979 OutputStream *ost = &output_streams[i];
1980 if (ost->source_index == ist_index) {
1981 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1986 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1987 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
1988 ist->file_index, ist->st->index);
1989 return AVERROR(EINVAL);
1991 assert_codec_experimental(ist->st->codec, 0);
1992 assert_avoptions(ist->opts);
1995 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;
1996 ist->next_pts = AV_NOPTS_VALUE;
1997 init_pts_correction(&ist->pts_ctx);
2003 static int transcode_init(OutputFile *output_files,
2004 int nb_output_files,
2005 InputFile *input_files,
2008 int ret = 0, i, j, k;
2009 AVFormatContext *oc;
2010 AVCodecContext *codec, *icodec;
2016 /* init framerate emulation */
2017 for (i = 0; i < nb_input_files; i++) {
2018 InputFile *ifile = &input_files[i];
2019 if (ifile->rate_emu)
2020 for (j = 0; j < ifile->nb_streams; j++)
2021 input_streams[j + ifile->ist_index].start = av_gettime();
2024 /* output stream init */
2025 for (i = 0; i < nb_output_files; i++) {
2026 oc = output_files[i].ctx;
2027 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2028 av_dump_format(oc, i, oc->filename, 1);
2029 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2030 return AVERROR(EINVAL);
2034 /* for each output stream, we compute the right encoding parameters */
2035 for (i = 0; i < nb_output_streams; i++) {
2036 ost = &output_streams[i];
2037 oc = output_files[ost->file_index].ctx;
2038 ist = &input_streams[ost->source_index];
2040 if (ost->attachment_filename)
2043 codec = ost->st->codec;
2044 icodec = ist->st->codec;
2046 ost->st->disposition = ist->st->disposition;
2047 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2048 codec->chroma_sample_location = icodec->chroma_sample_location;
2050 if (ost->stream_copy) {
2051 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2053 if (extra_size > INT_MAX) {
2054 return AVERROR(EINVAL);
2057 /* if stream_copy is selected, no need to decode or encode */
2058 codec->codec_id = icodec->codec_id;
2059 codec->codec_type = icodec->codec_type;
2061 if (!codec->codec_tag) {
2062 if (!oc->oformat->codec_tag ||
2063 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2064 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2065 codec->codec_tag = icodec->codec_tag;
2068 codec->bit_rate = icodec->bit_rate;
2069 codec->rc_max_rate = icodec->rc_max_rate;
2070 codec->rc_buffer_size = icodec->rc_buffer_size;
2071 codec->extradata = av_mallocz(extra_size);
2072 if (!codec->extradata) {
2073 return AVERROR(ENOMEM);
2075 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2076 codec->extradata_size = icodec->extradata_size;
2078 codec->time_base = icodec->time_base;
2079 codec->time_base.num *= icodec->ticks_per_frame;
2080 av_reduce(&codec->time_base.num, &codec->time_base.den,
2081 codec->time_base.num, codec->time_base.den, INT_MAX);
2083 codec->time_base = ist->st->time_base;
2085 switch(codec->codec_type) {
2086 case AVMEDIA_TYPE_AUDIO:
2087 if(audio_volume != 256) {
2088 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2091 codec->channel_layout = icodec->channel_layout;
2092 codec->sample_rate = icodec->sample_rate;
2093 codec->channels = icodec->channels;
2094 codec->frame_size = icodec->frame_size;
2095 codec->audio_service_type = icodec->audio_service_type;
2096 codec->block_align = icodec->block_align;
2098 case AVMEDIA_TYPE_VIDEO:
2099 codec->pix_fmt = icodec->pix_fmt;
2100 codec->width = icodec->width;
2101 codec->height = icodec->height;
2102 codec->has_b_frames = icodec->has_b_frames;
2103 if (!codec->sample_aspect_ratio.num) {
2104 codec->sample_aspect_ratio =
2105 ost->st->sample_aspect_ratio =
2106 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2107 ist->st->codec->sample_aspect_ratio.num ?
2108 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2111 case AVMEDIA_TYPE_SUBTITLE:
2112 codec->width = icodec->width;
2113 codec->height = icodec->height;
2115 case AVMEDIA_TYPE_DATA:
2116 case AVMEDIA_TYPE_ATTACHMENT:
2123 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2125 ist->decoding_needed = 1;
2126 ost->encoding_needed = 1;
2128 switch(codec->codec_type) {
2129 case AVMEDIA_TYPE_AUDIO:
2130 ost->fifo = av_fifo_alloc(1024);
2132 return AVERROR(ENOMEM);
2134 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2136 if (!codec->sample_rate)
2137 codec->sample_rate = icodec->sample_rate;
2138 choose_sample_rate(ost->st, ost->enc);
2139 codec->time_base = (AVRational){1, codec->sample_rate};
2141 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2142 codec->sample_fmt = icodec->sample_fmt;
2143 choose_sample_fmt(ost->st, ost->enc);
2145 if (!codec->channels)
2146 codec->channels = icodec->channels;
2147 codec->channel_layout = icodec->channel_layout;
2148 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2149 codec->channel_layout = 0;
2151 ost->audio_resample = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2152 icodec->request_channels = codec-> channels;
2153 ost->resample_sample_fmt = icodec->sample_fmt;
2154 ost->resample_sample_rate = icodec->sample_rate;
2155 ost->resample_channels = icodec->channels;
2157 case AVMEDIA_TYPE_VIDEO:
2158 if (codec->pix_fmt == PIX_FMT_NONE)
2159 codec->pix_fmt = icodec->pix_fmt;
2160 choose_pixel_fmt(ost->st, ost->enc);
2162 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2163 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2167 if (!codec->width || !codec->height) {
2168 codec->width = icodec->width;
2169 codec->height = icodec->height;
2172 ost->video_resample = codec->width != icodec->width ||
2173 codec->height != icodec->height ||
2174 codec->pix_fmt != icodec->pix_fmt;
2175 if (ost->video_resample) {
2176 #if !CONFIG_AVFILTER
2177 avcodec_get_frame_defaults(&ost->pict_tmp);
2178 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2179 codec->width, codec->height)) {
2180 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2183 ost->img_resample_ctx = sws_getContext(
2190 ost->sws_flags, NULL, NULL, NULL);
2191 if (ost->img_resample_ctx == NULL) {
2192 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2196 codec->bits_per_raw_sample= 0;
2199 ost->resample_height = icodec->height;
2200 ost->resample_width = icodec->width;
2201 ost->resample_pix_fmt = icodec->pix_fmt;
2203 if (!ost->frame_rate.num)
2204 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2205 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2206 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2207 ost->frame_rate = ost->enc->supported_framerates[idx];
2209 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2212 if (configure_video_filters(ist, ost)) {
2213 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2218 case AVMEDIA_TYPE_SUBTITLE:
2225 if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2226 char logfilename[1024];
2229 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2230 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2232 if (codec->flags & CODEC_FLAG_PASS1) {
2233 f = fopen(logfilename, "wb");
2235 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2236 logfilename, strerror(errno));
2242 size_t logbuffer_size;
2243 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2244 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2248 codec->stats_in = logbuffer;
2252 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2253 int size = codec->width * codec->height;
2254 bit_buffer_size = FFMAX(bit_buffer_size, 6*size + 200);
2259 bit_buffer = av_malloc(bit_buffer_size);
2261 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2263 return AVERROR(ENOMEM);
2266 /* open each encoder */
2267 for (i = 0; i < nb_output_streams; i++) {
2268 ost = &output_streams[i];
2269 if (ost->encoding_needed) {
2270 AVCodec *codec = ost->enc;
2271 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2273 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2274 ost->st->codec->codec_id, ost->file_index, ost->index);
2275 ret = AVERROR(EINVAL);
2278 if (dec->subtitle_header) {
2279 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2280 if (!ost->st->codec->subtitle_header) {
2281 ret = AVERROR(ENOMEM);
2284 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2285 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2287 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2288 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2289 ost->file_index, ost->index);
2290 ret = AVERROR(EINVAL);
2293 assert_codec_experimental(ost->st->codec, 1);
2294 assert_avoptions(ost->opts);
2295 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2296 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2297 "It takes bits/s as argument, not kbits/s\n");
2298 extra_size += ost->st->codec->extradata_size;
2300 if (ost->st->codec->me_threshold)
2301 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2305 /* init input streams */
2306 for (i = 0; i < nb_input_streams; i++)
2307 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2310 /* discard unused programs */
2311 for (i = 0; i < nb_input_files; i++) {
2312 InputFile *ifile = &input_files[i];
2313 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2314 AVProgram *p = ifile->ctx->programs[j];
2315 int discard = AVDISCARD_ALL;
2317 for (k = 0; k < p->nb_stream_indexes; k++)
2318 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2319 discard = AVDISCARD_DEFAULT;
2322 p->discard = discard;
2326 /* open files and write file headers */
2327 for (i = 0; i < nb_output_files; i++) {
2328 oc = output_files[i].ctx;
2329 oc->interrupt_callback = int_cb;
2330 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2331 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2332 ret = AVERROR(EINVAL);
2335 assert_avoptions(output_files[i].opts);
2336 if (strcmp(oc->oformat->name, "rtp")) {
2342 /* dump the file output parameters - cannot be done before in case
2344 for (i = 0; i < nb_output_files; i++) {
2345 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2348 /* dump the stream mapping */
2349 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2350 for (i = 0; i < nb_output_streams; i++) {
2351 ost = &output_streams[i];
2353 if (ost->attachment_filename) {
2354 /* an attached file */
2355 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2356 ost->attachment_filename, ost->file_index, ost->index);
2359 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2360 input_streams[ost->source_index].file_index,
2361 input_streams[ost->source_index].st->index,
2364 if (ost->sync_ist != &input_streams[ost->source_index])
2365 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2366 ost->sync_ist->file_index,
2367 ost->sync_ist->st->index);
2368 if (ost->stream_copy)
2369 av_log(NULL, AV_LOG_INFO, " (copy)");
2371 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2372 input_streams[ost->source_index].dec->name : "?",
2373 ost->enc ? ost->enc->name : "?");
2374 av_log(NULL, AV_LOG_INFO, "\n");
2378 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2383 print_sdp(output_files, nb_output_files);
2390 * The following code is the main loop of the file converter
2392 static int transcode(OutputFile *output_files,
2393 int nb_output_files,
2394 InputFile *input_files,
2398 AVFormatContext *is, *os;
2402 int no_packet_count=0;
2403 int64_t timer_start;
2405 if (!(no_packet = av_mallocz(nb_input_files)))
2408 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2412 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2415 timer_start = av_gettime();
2417 for(; received_sigterm == 0;) {
2418 int file_index, ist_index;
2423 ipts_min = INT64_MAX;
2426 /* select the stream that we must read now by looking at the
2427 smallest output pts */
2429 for (i = 0; i < nb_output_streams; i++) {
2433 ost = &output_streams[i];
2434 of = &output_files[ost->file_index];
2435 os = output_files[ost->file_index].ctx;
2436 ist = &input_streams[ost->source_index];
2437 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2438 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2440 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2442 if (!input_files[ist->file_index].eof_reached){
2443 if(ipts < ipts_min) {
2445 if(input_sync ) file_index = ist->file_index;
2447 if(opts < opts_min) {
2449 if(!input_sync) file_index = ist->file_index;
2452 if (ost->frame_number >= ost->max_frames) {
2454 for (j = 0; j < of->ctx->nb_streams; j++)
2455 output_streams[of->ost_index + j].is_past_recording_time = 1;
2459 /* if none, if is finished */
2460 if (file_index < 0) {
2461 if(no_packet_count){
2463 memset(no_packet, 0, nb_input_files);
2470 /* read a frame from it and output it in the fifo */
2471 is = input_files[file_index].ctx;
2472 ret= av_read_frame(is, &pkt);
2473 if(ret == AVERROR(EAGAIN)){
2474 no_packet[file_index]=1;
2479 input_files[file_index].eof_reached = 1;
2487 memset(no_packet, 0, nb_input_files);
2490 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2491 is->streams[pkt.stream_index]);
2493 /* the following test is needed in case new streams appear
2494 dynamically in stream : we ignore them */
2495 if (pkt.stream_index >= input_files[file_index].nb_streams)
2496 goto discard_packet;
2497 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2498 ist = &input_streams[ist_index];
2500 goto discard_packet;
2502 if (pkt.dts != AV_NOPTS_VALUE)
2503 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2504 if (pkt.pts != AV_NOPTS_VALUE)
2505 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2507 if(pkt.pts != AV_NOPTS_VALUE)
2508 pkt.pts *= ist->ts_scale;
2509 if(pkt.dts != AV_NOPTS_VALUE)
2510 pkt.dts *= ist->ts_scale;
2512 // 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);
2513 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2514 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2515 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2516 int64_t delta= pkt_dts - ist->next_pts;
2517 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2518 input_files[ist->file_index].ts_offset -= delta;
2519 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2520 delta, input_files[ist->file_index].ts_offset);
2521 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2522 if(pkt.pts != AV_NOPTS_VALUE)
2523 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2527 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2528 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2530 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2531 ist->file_index, ist->st->index);
2534 av_free_packet(&pkt);
2539 av_free_packet(&pkt);
2541 /* dump report by using the output first video and audio streams */
2542 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2545 /* at the end of stream, we must flush the decoder buffers */
2546 for (i = 0; i < nb_input_streams; i++) {
2547 ist = &input_streams[i];
2548 if (ist->decoding_needed) {
2549 output_packet(ist, output_streams, nb_output_streams, NULL);
2552 flush_encoders(output_streams, nb_output_streams);
2556 /* write the trailer if needed and close file */
2557 for(i=0;i<nb_output_files;i++) {
2558 os = output_files[i].ctx;
2559 av_write_trailer(os);
2562 /* dump report by using the first video and audio streams */
2563 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2565 /* close each encoder */
2566 for (i = 0; i < nb_output_streams; i++) {
2567 ost = &output_streams[i];
2568 if (ost->encoding_needed) {
2569 av_freep(&ost->st->codec->stats_in);
2570 avcodec_close(ost->st->codec);
2573 avfilter_graph_free(&ost->graph);
2577 /* close each decoder */
2578 for (i = 0; i < nb_input_streams; i++) {
2579 ist = &input_streams[i];
2580 if (ist->decoding_needed) {
2581 avcodec_close(ist->st->codec);
2589 av_freep(&bit_buffer);
2590 av_freep(&no_packet);
2592 if (output_streams) {
2593 for (i = 0; i < nb_output_streams; i++) {
2594 ost = &output_streams[i];
2596 if (ost->stream_copy)
2597 av_freep(&ost->st->codec->extradata);
2599 fclose(ost->logfile);
2600 ost->logfile = NULL;
2602 av_fifo_free(ost->fifo); /* works even if fifo is not
2603 initialized but set to zero */
2604 av_freep(&ost->st->codec->subtitle_header);
2605 av_free(ost->pict_tmp.data[0]);
2606 av_free(ost->forced_kf_pts);
2607 if (ost->video_resample)
2608 sws_freeContext(ost->img_resample_ctx);
2610 audio_resample_close(ost->resample);
2611 if (ost->reformat_ctx)
2612 av_audio_convert_free(ost->reformat_ctx);
2613 av_dict_free(&ost->opts);
2620 static double parse_frame_aspect_ratio(const char *arg)
2627 p = strchr(arg, ':');
2629 x = strtol(arg, &end, 10);
2631 y = strtol(end+1, &end, 10);
2633 ar = (double)x / (double)y;
2635 ar = strtod(arg, NULL);
2638 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2644 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2646 return parse_option(o, "codec:a", arg, options);
2649 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2651 return parse_option(o, "codec:v", arg, options);
2654 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2656 return parse_option(o, "codec:s", arg, options);
2659 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2661 return parse_option(o, "codec:d", arg, options);
2664 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2666 StreamMap *m = NULL;
2667 int i, negative = 0, file_idx;
2668 int sync_file_idx = -1, sync_stream_idx;
2676 map = av_strdup(arg);
2678 /* parse sync stream first, just pick first matching stream */
2679 if (sync = strchr(map, ',')) {
2681 sync_file_idx = strtol(sync + 1, &sync, 0);
2682 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2683 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2688 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2689 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2690 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2691 sync_stream_idx = i;
2694 if (i == input_files[sync_file_idx].nb_streams) {
2695 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2696 "match any streams.\n", arg);
2702 file_idx = strtol(map, &p, 0);
2703 if (file_idx >= nb_input_files || file_idx < 0) {
2704 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2708 /* disable some already defined maps */
2709 for (i = 0; i < o->nb_stream_maps; i++) {
2710 m = &o->stream_maps[i];
2711 if (file_idx == m->file_index &&
2712 check_stream_specifier(input_files[m->file_index].ctx,
2713 input_files[m->file_index].ctx->streams[m->stream_index],
2714 *p == ':' ? p + 1 : p) > 0)
2718 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2719 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2720 *p == ':' ? p + 1 : p) <= 0)
2722 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2723 &o->nb_stream_maps, o->nb_stream_maps + 1);
2724 m = &o->stream_maps[o->nb_stream_maps - 1];
2726 m->file_index = file_idx;
2727 m->stream_index = i;
2729 if (sync_file_idx >= 0) {
2730 m->sync_file_index = sync_file_idx;
2731 m->sync_stream_index = sync_stream_idx;
2733 m->sync_file_index = file_idx;
2734 m->sync_stream_index = i;
2739 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2747 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
2749 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
2750 &o->nb_attachments, o->nb_attachments + 1);
2751 o->attachments[o->nb_attachments - 1] = arg;
2755 static void parse_meta_type(char *arg, char *type, int *index)
2765 if (*(++arg) == ':')
2766 *index = strtol(++arg, NULL, 0);
2769 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2776 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2778 MetadataMap *m, *m1;
2781 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2782 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2784 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2785 m->file = strtol(arg, &p, 0);
2786 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2788 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2789 if (p = strchr(opt, ':'))
2790 parse_meta_type(p + 1, &m1->type, &m1->index);
2794 if (m->type == 'g' || m1->type == 'g')
2795 o->metadata_global_manual = 1;
2796 if (m->type == 's' || m1->type == 's')
2797 o->metadata_streams_manual = 1;
2798 if (m->type == 'c' || m1->type == 'c')
2799 o->metadata_chapters_manual = 1;
2804 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2806 const char *codec_string = encoder ? "encoder" : "decoder";
2810 avcodec_find_encoder_by_name(name) :
2811 avcodec_find_decoder_by_name(name);
2813 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2816 if(codec->type != type) {
2817 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2823 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
2825 char *codec_name = NULL;
2827 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2829 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
2830 st->codec->codec_id = codec->id;
2833 return avcodec_find_decoder(st->codec->codec_id);
2837 * Add all the streams from the given input file to the global
2838 * list of input streams.
2840 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2842 int i, rfps, rfps_base;
2844 for (i = 0; i < ic->nb_streams; i++) {
2845 AVStream *st = ic->streams[i];
2846 AVCodecContext *dec = st->codec;
2849 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2850 ist = &input_streams[nb_input_streams - 1];
2852 ist->file_index = nb_input_files;
2854 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2856 ist->ts_scale = 1.0;
2857 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
2859 ist->dec = choose_decoder(o, ic, st);
2861 switch (dec->codec_type) {
2862 case AVMEDIA_TYPE_AUDIO:
2863 if (o->audio_disable)
2864 st->discard= AVDISCARD_ALL;
2866 case AVMEDIA_TYPE_VIDEO:
2867 rfps = ic->streams[i]->r_frame_rate.num;
2868 rfps_base = ic->streams[i]->r_frame_rate.den;
2870 dec->flags |= CODEC_FLAG_EMU_EDGE;
2871 dec->height >>= dec->lowres;
2872 dec->width >>= dec->lowres;
2875 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2877 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",
2878 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2879 (float)rfps / rfps_base, rfps, rfps_base);
2882 if (o->video_disable)
2883 st->discard= AVDISCARD_ALL;
2884 else if(video_discard)
2885 st->discard= video_discard;
2887 case AVMEDIA_TYPE_DATA:
2889 case AVMEDIA_TYPE_SUBTITLE:
2890 if (o->subtitle_disable)
2891 st->discard = AVDISCARD_ALL;
2893 case AVMEDIA_TYPE_ATTACHMENT:
2894 case AVMEDIA_TYPE_UNKNOWN:
2902 static void assert_file_overwrite(const char *filename)
2904 if (!file_overwrite &&
2905 (strchr(filename, ':') == NULL || filename[1] == ':' ||
2906 av_strstart(filename, "file:", NULL))) {
2907 if (avio_check(filename, 0) == 0) {
2909 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
2911 if (!read_yesno()) {
2912 fprintf(stderr, "Not overwriting - exiting\n");
2917 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
2924 static void dump_attachment(AVStream *st, const char *filename)
2927 AVIOContext *out = NULL;
2928 AVDictionaryEntry *e;
2930 if (!st->codec->extradata_size) {
2931 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
2932 nb_input_files - 1, st->index);
2935 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
2936 filename = e->value;
2938 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
2939 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
2943 assert_file_overwrite(filename);
2945 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
2946 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
2951 avio_write(out, st->codec->extradata, st->codec->extradata_size);
2956 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2958 AVFormatContext *ic;
2959 AVInputFormat *file_iformat = NULL;
2963 AVDictionary **opts;
2964 int orig_nb_streams; // number of streams before avformat_find_stream_info
2967 if (!(file_iformat = av_find_input_format(o->format))) {
2968 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
2973 if (!strcmp(filename, "-"))
2976 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2977 !strcmp(filename, "/dev/stdin");
2979 /* get default parameters from command line */
2980 ic = avformat_alloc_context();
2982 print_error(filename, AVERROR(ENOMEM));
2985 if (o->nb_audio_sample_rate) {
2986 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2987 av_dict_set(&format_opts, "sample_rate", buf, 0);
2989 if (o->nb_audio_channels) {
2990 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2991 av_dict_set(&format_opts, "channels", buf, 0);
2993 if (o->nb_frame_rates) {
2994 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2996 if (o->nb_frame_sizes) {
2997 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2999 if (o->nb_frame_pix_fmts)
3000 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3002 ic->flags |= AVFMT_FLAG_NONBLOCK;
3003 ic->interrupt_callback = int_cb;
3005 /* open the input file with generic libav function */
3006 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3008 print_error(filename, err);
3011 assert_avoptions(format_opts);
3013 /* apply forced codec ids */
3014 for (i = 0; i < ic->nb_streams; i++)
3015 choose_decoder(o, ic, ic->streams[i]);
3017 /* Set AVCodecContext options for avformat_find_stream_info */
3018 opts = setup_find_stream_info_opts(ic, codec_opts);
3019 orig_nb_streams = ic->nb_streams;
3021 /* If not enough info to get the stream parameters, we decode the
3022 first frames to get it. (used in mpeg case for example) */
3023 ret = avformat_find_stream_info(ic, opts);
3025 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3026 av_close_input_file(ic);
3030 timestamp = o->start_time;
3031 /* add the stream start time */
3032 if (ic->start_time != AV_NOPTS_VALUE)
3033 timestamp += ic->start_time;
3035 /* if seeking requested, we execute it */
3036 if (o->start_time != 0) {
3037 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3039 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3040 filename, (double)timestamp / AV_TIME_BASE);
3044 /* update the current parameters so that they match the one of the input stream */
3045 add_input_streams(o, ic);
3047 /* dump the file content */
3048 av_dump_format(ic, nb_input_files, filename, 0);
3050 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3051 input_files[nb_input_files - 1].ctx = ic;
3052 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3053 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3054 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3055 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3057 for (i = 0; i < o->nb_dump_attachment; i++) {
3060 for (j = 0; j < ic->nb_streams; j++) {
3061 AVStream *st = ic->streams[j];
3063 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3064 dump_attachment(st, o->dump_attachment[i].u.str);
3068 for (i = 0; i < orig_nb_streams; i++)
3069 av_dict_free(&opts[i]);
3076 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3077 AVCodecContext *avctx)
3083 for (p = kf; *p; p++)
3086 ost->forced_kf_count = n;
3087 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3088 if (!ost->forced_kf_pts) {
3089 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3092 for (i = 0; i < n; i++) {
3093 p = i ? strchr(p, ',') + 1 : kf;
3094 t = parse_time_or_die("force_key_frames", p, 1);
3095 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3099 static uint8_t *get_line(AVIOContext *s)
3105 if (avio_open_dyn_buf(&line) < 0) {
3106 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3110 while ((c = avio_r8(s)) && c != '\n')
3113 avio_close_dyn_buf(line, &buf);
3118 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3121 char filename[1000];
3122 const char *base[3] = { getenv("AVCONV_DATADIR"),
3127 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3131 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3132 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3133 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3136 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3137 i != 1 ? "" : "/.avconv", preset_name);
3138 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3144 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3146 char *codec_name = NULL;
3148 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3150 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3151 NULL, ost->st->codec->codec_type);
3152 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3153 } else if (!strcmp(codec_name, "copy"))
3154 ost->stream_copy = 1;
3156 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3157 ost->st->codec->codec_id = ost->enc->id;
3161 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3164 AVStream *st = avformat_new_stream(oc, NULL);
3165 int idx = oc->nb_streams - 1, ret = 0;
3166 char *bsf = NULL, *next, *codec_tag = NULL;
3167 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3169 char *buf = NULL, *arg = NULL, *preset = NULL;
3170 AVIOContext *s = NULL;
3173 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3177 if (oc->nb_streams - 1 < o->nb_streamid_map)
3178 st->id = o->streamid_map[oc->nb_streams - 1];
3180 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3181 nb_output_streams + 1);
3182 ost = &output_streams[nb_output_streams - 1];
3183 ost->file_index = nb_output_files;
3186 st->codec->codec_type = type;
3187 choose_encoder(o, oc, ost);
3189 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3192 avcodec_get_context_defaults3(st->codec, ost->enc);
3193 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3195 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3196 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3199 if (!buf[0] || buf[0] == '#') {
3203 if (!(arg = strchr(buf, '='))) {
3204 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3208 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3210 } while (!s->eof_reached);
3214 av_log(NULL, AV_LOG_FATAL,
3215 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3216 preset, ost->file_index, ost->index);
3220 ost->max_frames = INT64_MAX;
3221 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3223 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3225 if (next = strchr(bsf, ','))
3227 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3228 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3232 bsfc_prev->next = bsfc;
3234 ost->bitstream_filters = bsfc;
3240 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3242 uint32_t tag = strtol(codec_tag, &next, 0);
3244 tag = AV_RL32(codec_tag);
3245 st->codec->codec_tag = tag;
3248 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3249 if (qscale >= 0 || same_quant) {
3250 st->codec->flags |= CODEC_FLAG_QSCALE;
3251 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3254 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3255 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3257 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3261 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3264 const char *p = str;
3271 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3278 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3282 AVCodecContext *video_enc;
3284 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3286 video_enc = st->codec;
3288 if (!ost->stream_copy) {
3289 const char *p = NULL;
3290 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3291 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3292 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3295 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3296 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3297 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3301 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3302 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3303 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3307 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3308 if (frame_aspect_ratio)
3309 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3311 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3312 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3313 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3316 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3318 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3320 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3321 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3324 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3326 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3328 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3329 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3332 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3335 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3338 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3340 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3343 video_enc->rc_override=
3344 av_realloc(video_enc->rc_override,
3345 sizeof(RcOverride)*(i+1));
3346 video_enc->rc_override[i].start_frame= start;
3347 video_enc->rc_override[i].end_frame = end;
3349 video_enc->rc_override[i].qscale= q;
3350 video_enc->rc_override[i].quality_factor= 1.0;
3353 video_enc->rc_override[i].qscale= 0;
3354 video_enc->rc_override[i].quality_factor= -q/100.0;
3359 video_enc->rc_override_count=i;
3360 if (!video_enc->rc_initial_buffer_occupancy)
3361 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3362 video_enc->intra_dc_precision= intra_dc_precision - 8;
3367 video_enc->flags |= CODEC_FLAG_PASS1;
3369 video_enc->flags |= CODEC_FLAG_PASS2;
3373 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3374 if (forced_key_frames)
3375 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3377 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3379 ost->top_field_first = -1;
3380 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3382 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3385 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3387 ost->avfilter = av_strdup(filters);
3394 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3398 AVCodecContext *audio_enc;
3400 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3403 audio_enc = st->codec;
3404 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3406 if (!ost->stream_copy) {
3407 char *sample_fmt = NULL;
3409 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3411 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3413 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3414 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3418 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3424 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3428 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3429 if (!ost->stream_copy) {
3430 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3437 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3439 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3440 ost->stream_copy = 1;
3444 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3448 AVCodecContext *subtitle_enc;
3450 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3452 subtitle_enc = st->codec;
3454 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3459 /* arg format is "output-stream-index:streamid-value". */
3460 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3466 av_strlcpy(idx_str, arg, sizeof(idx_str));
3467 p = strchr(idx_str, ':');
3469 av_log(NULL, AV_LOG_FATAL,
3470 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3475 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3476 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3477 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3481 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3483 AVFormatContext *is = ifile->ctx;
3484 AVFormatContext *os = ofile->ctx;
3487 for (i = 0; i < is->nb_chapters; i++) {
3488 AVChapter *in_ch = is->chapters[i], *out_ch;
3489 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3490 AV_TIME_BASE_Q, in_ch->time_base);
3491 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3492 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3495 if (in_ch->end < ts_off)
3497 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3500 out_ch = av_mallocz(sizeof(AVChapter));
3502 return AVERROR(ENOMEM);
3504 out_ch->id = in_ch->id;
3505 out_ch->time_base = in_ch->time_base;
3506 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3507 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3510 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3513 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3515 return AVERROR(ENOMEM);
3516 os->chapters[os->nb_chapters - 1] = out_ch;
3521 static void opt_output_file(void *optctx, const char *filename)
3523 OptionsContext *o = optctx;
3524 AVFormatContext *oc;
3526 AVOutputFormat *file_oformat;
3530 if (!strcmp(filename, "-"))
3533 oc = avformat_alloc_context();
3535 print_error(filename, AVERROR(ENOMEM));
3540 file_oformat = av_guess_format(o->format, NULL, NULL);
3541 if (!file_oformat) {
3542 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3546 file_oformat = av_guess_format(NULL, filename, NULL);
3547 if (!file_oformat) {
3548 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3554 oc->oformat = file_oformat;
3555 oc->interrupt_callback = int_cb;
3556 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3558 if (!o->nb_stream_maps) {
3559 /* pick the "best" stream of each type */
3560 #define NEW_STREAM(type, index)\
3562 ost = new_ ## type ## _stream(o, oc);\
3563 ost->source_index = index;\
3564 ost->sync_ist = &input_streams[index];\
3565 input_streams[index].discard = 0;\
3568 /* video: highest resolution */
3569 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3570 int area = 0, idx = -1;
3571 for (i = 0; i < nb_input_streams; i++) {
3572 ist = &input_streams[i];
3573 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3574 ist->st->codec->width * ist->st->codec->height > area) {
3575 area = ist->st->codec->width * ist->st->codec->height;
3579 NEW_STREAM(video, idx);
3582 /* audio: most channels */
3583 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3584 int channels = 0, idx = -1;
3585 for (i = 0; i < nb_input_streams; i++) {
3586 ist = &input_streams[i];
3587 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3588 ist->st->codec->channels > channels) {
3589 channels = ist->st->codec->channels;
3593 NEW_STREAM(audio, idx);
3596 /* subtitles: pick first */
3597 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3598 for (i = 0; i < nb_input_streams; i++)
3599 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3600 NEW_STREAM(subtitle, i);
3604 /* do something with data? */
3606 for (i = 0; i < o->nb_stream_maps; i++) {
3607 StreamMap *map = &o->stream_maps[i];
3612 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3613 switch (ist->st->codec->codec_type) {
3614 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3615 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3616 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3617 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3618 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3620 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
3621 map->file_index, map->stream_index);
3625 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3626 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3627 map->sync_stream_index];
3632 /* handle attached files */
3633 for (i = 0; i < o->nb_attachments; i++) {
3635 uint8_t *attachment;
3639 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
3640 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
3644 if ((len = avio_size(pb)) <= 0) {
3645 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
3649 if (!(attachment = av_malloc(len))) {
3650 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
3654 avio_read(pb, attachment, len);
3656 ost = new_attachment_stream(o, oc);
3657 ost->stream_copy = 0;
3658 ost->source_index = -1;
3659 ost->attachment_filename = o->attachments[i];
3660 ost->st->codec->extradata = attachment;
3661 ost->st->codec->extradata_size = len;
3663 p = strrchr(o->attachments[i], '/');
3664 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
3668 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3669 output_files[nb_output_files - 1].ctx = oc;
3670 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3671 output_files[nb_output_files - 1].recording_time = o->recording_time;
3672 output_files[nb_output_files - 1].start_time = o->start_time;
3673 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3674 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3676 /* check filename in case of an image number is expected */
3677 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3678 if (!av_filename_number_test(oc->filename)) {
3679 print_error(oc->filename, AVERROR(EINVAL));
3684 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3685 /* test if it already exists to avoid losing precious files */
3686 assert_file_overwrite(filename);
3689 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
3690 &oc->interrupt_callback,
3691 &output_files[nb_output_files - 1].opts)) < 0) {
3692 print_error(filename, err);
3697 if (o->mux_preload) {
3699 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3700 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3702 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3703 oc->flags |= AVFMT_FLAG_NONBLOCK;
3706 if (o->chapters_input_file >= nb_input_files) {
3707 if (o->chapters_input_file == INT_MAX) {
3708 /* copy chapters from the first input file that has them*/
3709 o->chapters_input_file = -1;
3710 for (i = 0; i < nb_input_files; i++)
3711 if (input_files[i].ctx->nb_chapters) {
3712 o->chapters_input_file = i;
3716 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3717 o->chapters_input_file);
3721 if (o->chapters_input_file >= 0)
3722 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3723 !o->metadata_chapters_manual);
3726 for (i = 0; i < o->nb_meta_data_maps; i++) {
3727 AVFormatContext *files[2];
3728 AVDictionary **meta[2];
3731 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3732 if ((index) < 0 || (index) >= (nb_elems)) {\
3733 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3738 int in_file_index = o->meta_data_maps[i][1].file;
3739 if (in_file_index < 0)
3741 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3744 files[1] = input_files[in_file_index].ctx;
3746 for (j = 0; j < 2; j++) {
3747 MetadataMap *map = &o->meta_data_maps[i][j];
3749 switch (map->type) {
3751 meta[j] = &files[j]->metadata;
3754 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3755 meta[j] = &files[j]->streams[map->index]->metadata;
3758 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3759 meta[j] = &files[j]->chapters[map->index]->metadata;
3762 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3763 meta[j] = &files[j]->programs[map->index]->metadata;
3768 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3771 /* copy global metadata by default */
3772 if (!o->metadata_global_manual && nb_input_files)
3773 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3774 AV_DICT_DONT_OVERWRITE);
3775 if (!o->metadata_streams_manual)
3776 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3778 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
3780 ist = &input_streams[output_streams[i].source_index];
3781 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3784 /* process manually set metadata */
3785 for (i = 0; i < o->nb_metadata; i++) {
3790 val = strchr(o->metadata[i].u.str, '=');
3792 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3793 o->metadata[i].u.str);
3798 parse_meta_type(o->metadata[i].specifier, &type, &index);
3804 if (index < 0 || index >= oc->nb_streams) {
3805 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3808 m = &oc->streams[index]->metadata;
3811 if (index < 0 || index >= oc->nb_chapters) {
3812 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3815 m = &oc->chapters[index]->metadata;
3818 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3822 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3828 /* same option as mencoder */
3829 static int opt_pass(const char *opt, const char *arg)
3831 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3835 static int64_t getutime(void)
3838 struct rusage rusage;
3840 getrusage(RUSAGE_SELF, &rusage);
3841 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3842 #elif HAVE_GETPROCESSTIMES
3844 FILETIME c, e, k, u;
3845 proc = GetCurrentProcess();
3846 GetProcessTimes(proc, &c, &e, &k, &u);
3847 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3849 return av_gettime();
3853 static int64_t getmaxrss(void)
3855 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3856 struct rusage rusage;
3857 getrusage(RUSAGE_SELF, &rusage);
3858 return (int64_t)rusage.ru_maxrss * 1024;
3859 #elif HAVE_GETPROCESSMEMORYINFO
3861 PROCESS_MEMORY_COUNTERS memcounters;
3862 proc = GetCurrentProcess();
3863 memcounters.cb = sizeof(memcounters);
3864 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3865 return memcounters.PeakPagefileUsage;
3871 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3873 return parse_option(o, "q:a", arg, options);
3876 static void show_usage(void)
3878 printf("Hyper fast Audio and Video encoder\n");
3879 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3883 static void show_help(void)
3885 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3886 av_log_set_callback(log_callback_help);
3888 show_help_options(options, "Main options:\n",
3889 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3890 show_help_options(options, "\nAdvanced options:\n",
3891 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3893 show_help_options(options, "\nVideo options:\n",
3894 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3896 show_help_options(options, "\nAdvanced Video options:\n",
3897 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3898 OPT_VIDEO | OPT_EXPERT);
3899 show_help_options(options, "\nAudio options:\n",
3900 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3902 show_help_options(options, "\nAdvanced Audio options:\n",
3903 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3904 OPT_AUDIO | OPT_EXPERT);
3905 show_help_options(options, "\nSubtitle options:\n",
3906 OPT_SUBTITLE | OPT_GRAB,
3908 show_help_options(options, "\nAudio/Video grab options:\n",
3912 show_help_children(avcodec_get_class(), flags);
3913 show_help_children(avformat_get_class(), flags);
3914 show_help_children(sws_get_class(), flags);
3917 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3919 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3920 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3922 if(!strncmp(arg, "pal-", 4)) {
3925 } else if(!strncmp(arg, "ntsc-", 5)) {
3928 } else if(!strncmp(arg, "film-", 5)) {
3932 /* Try to determine PAL/NTSC by peeking in the input files */
3933 if(nb_input_files) {
3935 for (j = 0; j < nb_input_files; j++) {
3936 for (i = 0; i < input_files[j].nb_streams; i++) {
3937 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3938 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3940 fr = c->time_base.den * 1000 / c->time_base.num;
3944 } else if((fr == 29970) || (fr == 23976)) {
3953 if (norm != UNKNOWN)
3954 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3957 if(norm == UNKNOWN) {
3958 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3959 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3960 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3964 if(!strcmp(arg, "vcd")) {
3965 opt_video_codec(o, "c:v", "mpeg1video");
3966 opt_audio_codec(o, "c:a", "mp2");
3967 parse_option(o, "f", "vcd", options);
3969 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3970 parse_option(o, "r", frame_rates[norm], options);
3971 opt_default("g", norm == PAL ? "15" : "18");
3973 opt_default("b", "1150000");
3974 opt_default("maxrate", "1150000");
3975 opt_default("minrate", "1150000");
3976 opt_default("bufsize", "327680"); // 40*1024*8;
3978 opt_default("b:a", "224000");
3979 parse_option(o, "ar", "44100", options);
3980 parse_option(o, "ac", "2", options);
3982 opt_default("packetsize", "2324");
3983 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3985 /* We have to offset the PTS, so that it is consistent with the SCR.
3986 SCR starts at 36000, but the first two packs contain only padding
3987 and the first pack from the other stream, respectively, may also have
3988 been written before.
3989 So the real data starts at SCR 36000+3*1200. */
3990 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3991 } else if(!strcmp(arg, "svcd")) {
3993 opt_video_codec(o, "c:v", "mpeg2video");
3994 opt_audio_codec(o, "c:a", "mp2");
3995 parse_option(o, "f", "svcd", options);
3997 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3998 parse_option(o, "r", frame_rates[norm], options);
3999 opt_default("g", norm == PAL ? "15" : "18");
4001 opt_default("b", "2040000");
4002 opt_default("maxrate", "2516000");
4003 opt_default("minrate", "0"); //1145000;
4004 opt_default("bufsize", "1835008"); //224*1024*8;
4005 opt_default("flags", "+scan_offset");
4008 opt_default("b:a", "224000");
4009 parse_option(o, "ar", "44100", options);
4011 opt_default("packetsize", "2324");
4013 } else if(!strcmp(arg, "dvd")) {
4015 opt_video_codec(o, "c:v", "mpeg2video");
4016 opt_audio_codec(o, "c:a", "ac3");
4017 parse_option(o, "f", "dvd", options);
4019 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4020 parse_option(o, "r", frame_rates[norm], options);
4021 opt_default("g", norm == PAL ? "15" : "18");
4023 opt_default("b", "6000000");
4024 opt_default("maxrate", "9000000");
4025 opt_default("minrate", "0"); //1500000;
4026 opt_default("bufsize", "1835008"); //224*1024*8;
4028 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4029 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4031 opt_default("b:a", "448000");
4032 parse_option(o, "ar", "48000", options);
4034 } else if(!strncmp(arg, "dv", 2)) {
4036 parse_option(o, "f", "dv", options);
4038 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4039 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4040 norm == PAL ? "yuv420p" : "yuv411p", options);
4041 parse_option(o, "r", frame_rates[norm], options);
4043 parse_option(o, "ar", "48000", options);
4044 parse_option(o, "ac", "2", options);
4047 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4048 return AVERROR(EINVAL);
4053 static int opt_vstats_file(const char *opt, const char *arg)
4055 av_free (vstats_filename);
4056 vstats_filename=av_strdup (arg);
4060 static int opt_vstats(const char *opt, const char *arg)
4063 time_t today2 = time(NULL);
4064 struct tm *today = localtime(&today2);
4066 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4068 return opt_vstats_file(opt, filename);
4071 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4073 return parse_option(o, "frames:v", arg, options);
4076 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4078 return parse_option(o, "frames:a", arg, options);
4081 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4083 return parse_option(o, "frames:d", arg, options);
4086 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4088 return parse_option(o, "tag:v", arg, options);
4091 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4093 return parse_option(o, "tag:a", arg, options);
4096 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4098 return parse_option(o, "tag:s", arg, options);
4101 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4103 return parse_option(o, "filter:v", arg, options);
4106 #define OFFSET(x) offsetof(OptionsContext, x)
4107 static const OptionDef options[] = {
4109 #include "cmdutils_common_opts.h"
4110 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4111 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4112 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4113 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4114 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4115 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4116 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4117 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4118 "outfile[,metadata]:infile[,metadata]" },
4119 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4120 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4121 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4122 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4123 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4124 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4125 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4126 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4127 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4128 "add timings for benchmarking" },
4129 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4130 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4131 "dump each input packet" },
4132 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4133 "when dumping packets, also dump the payload" },
4134 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4135 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4136 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4137 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4138 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4139 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4140 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4141 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4142 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4143 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4144 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4145 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4146 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4147 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4148 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4150 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4152 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4153 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4154 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4157 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4158 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4159 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4160 { "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" },
4161 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4162 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4163 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4164 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4165 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4166 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4167 "use same quantizer as source (implies VBR)" },
4168 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4169 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4170 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4171 "deinterlace pictures" },
4172 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4173 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4175 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4177 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4178 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4179 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4180 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4181 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4182 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4183 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4184 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4185 { "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" },
4188 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4189 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4190 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4191 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4192 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4193 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4194 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4195 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4196 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4198 /* subtitle options */
4199 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4200 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4201 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4204 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4207 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4208 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4210 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4212 /* data codec support */
4213 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4215 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4219 int main(int argc, char **argv)
4221 OptionsContext o = { 0 };
4226 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4227 parse_loglevel(argc, argv, options);
4229 avcodec_register_all();
4231 avdevice_register_all();
4234 avfilter_register_all();
4237 avformat_network_init();
4242 parse_options(&o, argc, argv, options, opt_output_file);
4244 if(nb_output_files <= 0 && nb_input_files == 0) {
4246 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4250 /* file converter / grab */
4251 if (nb_output_files <= 0) {
4252 fprintf(stderr, "At least one output file must be specified\n");
4256 if (nb_input_files == 0) {
4257 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4262 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4264 ti = getutime() - ti;
4266 int maxrss = getmaxrss() / 1024;
4267 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);