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 /* indexed by output file stream index */
101 static int *streamid_map = NULL;
102 static int nb_streamid_map = 0;
104 static uint16_t *intra_matrix = NULL;
105 static uint16_t *inter_matrix = NULL;
106 static int video_discard = 0;
107 static int same_quant = 0;
108 static int do_deinterlace = 0;
109 static int top_field_first = -1;
110 static int intra_dc_precision = 8;
111 static int qp_hist = 0;
113 static char *vfilters = NULL;
116 static int file_overwrite = 0;
117 static int do_benchmark = 0;
118 static int do_hex_dump = 0;
119 static int do_pkt_dump = 0;
120 static int do_psnr = 0;
121 static int do_pass = 0;
122 static char *pass_logfilename_prefix = NULL;
123 static int video_sync_method= -1;
124 static int audio_sync_method= 0;
125 static float audio_drift_threshold= 0.1;
126 static int copy_ts= 0;
128 static int opt_shortest = 0;
129 static char *vstats_filename;
130 static FILE *vstats_file;
131 static int copy_initial_nonkeyframes = 0;
133 static int audio_volume = 256;
135 static int exit_on_error = 0;
136 static int using_stdin = 0;
137 static int verbose = 1;
138 static int64_t video_size = 0;
139 static int64_t audio_size = 0;
140 static int64_t extra_size = 0;
141 static int nb_frames_dup = 0;
142 static int nb_frames_drop = 0;
143 static int input_sync;
145 static float dts_delta_threshold = 10;
147 static uint8_t *audio_buf;
148 static uint8_t *audio_out;
149 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
151 static short *samples;
153 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
155 typedef struct InputStream {
158 int discard; /* true if stream data should be discarded */
159 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
162 int64_t start; /* time when read started */
163 int64_t next_pts; /* synthetic pts for cases where pkt.pts
165 int64_t pts; /* current pts */
166 PtsCorrectionContext pts_ctx;
168 int is_start; /* is 1 at the start and after a discontinuity */
169 int showed_multi_packet_warning;
173 typedef struct InputFile {
174 AVFormatContext *ctx;
175 int eof_reached; /* true if eof reached */
176 int ist_index; /* index of first stream in ist_table */
177 int buffer_size; /* current total buffer size */
179 int nb_streams; /* number of stream that avconv is aware of; may be different
180 from ctx.nb_streams if new streams appear during av_read_frame() */
184 typedef struct OutputStream {
185 int file_index; /* file index */
186 int index; /* stream index in the output file */
187 int source_index; /* InputStream index */
188 AVStream *st; /* stream in the output file */
189 int encoding_needed; /* true if encoding needed for this stream */
191 /* input pts and corresponding output pts
193 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
194 struct InputStream *sync_ist; /* input stream to sync against */
195 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
196 AVBitStreamFilterContext *bitstream_filters;
202 AVFrame pict_tmp; /* temporary image for resampling */
203 struct SwsContext *img_resample_ctx; /* for image resampling */
206 int resample_pix_fmt;
207 AVRational frame_rate;
210 float frame_aspect_ratio;
212 /* forced key frames */
213 int64_t *forced_kf_pts;
219 ReSampleContext *resample; /* for audio resampling */
220 int resample_sample_fmt;
221 int resample_channels;
222 int resample_sample_rate;
224 AVAudioConvert *reformat_ctx;
225 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
229 AVFilterContext *output_video_filter;
230 AVFilterContext *input_video_filter;
231 AVFilterBufferRef *picref;
233 AVFilterGraph *graph;
238 int is_past_recording_time;
242 typedef struct OutputFile {
243 AVFormatContext *ctx;
245 int ost_index; /* index of the first stream in output_streams */
246 int64_t recording_time; /* desired length of the resulting file in microseconds */
247 int64_t start_time; /* start time in microseconds */
248 uint64_t limit_filesize;
251 static InputStream *input_streams = NULL;
252 static int nb_input_streams = 0;
253 static InputFile *input_files = NULL;
254 static int nb_input_files = 0;
256 static OutputStream *output_streams = NULL;
257 static int nb_output_streams = 0;
258 static OutputFile *output_files = NULL;
259 static int nb_output_files = 0;
261 typedef struct OptionsContext {
262 /* input/output options */
266 SpecifierOpt *codec_names;
268 SpecifierOpt *audio_channels;
269 int nb_audio_channels;
270 SpecifierOpt *audio_sample_rate;
271 int nb_audio_sample_rate;
272 SpecifierOpt *frame_rates;
274 SpecifierOpt *frame_sizes;
276 SpecifierOpt *frame_pix_fmts;
277 int nb_frame_pix_fmts;
280 int64_t input_ts_offset;
283 SpecifierOpt *ts_scale;
287 StreamMap *stream_maps;
289 /* first item specifies output metadata, second is input */
290 MetadataMap (*meta_data_maps)[2];
291 int nb_meta_data_maps;
292 int metadata_global_manual;
293 int metadata_streams_manual;
294 int metadata_chapters_manual;
296 int chapters_input_file;
298 int64_t recording_time;
299 uint64_t limit_filesize;
305 int subtitle_disable;
308 SpecifierOpt *metadata;
310 SpecifierOpt *max_frames;
312 SpecifierOpt *bitstream_filters;
313 int nb_bitstream_filters;
314 SpecifierOpt *codec_tags;
316 SpecifierOpt *sample_fmts;
318 SpecifierOpt *qscale;
320 SpecifierOpt *forced_key_frames;
321 int nb_forced_key_frames;
322 SpecifierOpt *force_fps;
324 SpecifierOpt *frame_aspect_ratios;
325 int nb_frame_aspect_ratios;
326 SpecifierOpt *rc_overrides;
330 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
333 for (i = 0; i < o->nb_ ## name; i++) {\
334 char *spec = o->name[i].specifier;\
335 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
336 outvar = o->name[i].u.type;\
342 static void reset_options(OptionsContext *o)
344 const OptionDef *po = options;
346 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
348 void *dst = (uint8_t*)o + po->u.off;
350 if (po->flags & OPT_SPEC) {
351 SpecifierOpt **so = dst;
352 int i, *count = (int*)(so + 1);
353 for (i = 0; i < *count; i++) {
354 av_freep(&(*so)[i].specifier);
355 if (po->flags & OPT_STRING)
356 av_freep(&(*so)[i].u.str);
360 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
365 av_freep(&o->stream_maps);
366 av_freep(&o->meta_data_maps);
368 memset(o, 0, sizeof(*o));
370 o->mux_preload = 0.5;
371 o->mux_max_delay = 0.7;
372 o->recording_time = INT64_MAX;
373 o->limit_filesize = UINT64_MAX;
374 o->chapters_input_file = INT_MAX;
382 static int configure_video_filters(InputStream *ist, OutputStream *ost)
384 AVFilterContext *last_filter, *filter;
385 /** filter graph containing all filters including input & output */
386 AVCodecContext *codec = ost->st->codec;
387 AVCodecContext *icodec = ist->st->codec;
388 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
389 AVRational sample_aspect_ratio;
393 ost->graph = avfilter_graph_alloc();
395 if (ist->st->sample_aspect_ratio.num){
396 sample_aspect_ratio = ist->st->sample_aspect_ratio;
398 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
400 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
401 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
402 sample_aspect_ratio.num, sample_aspect_ratio.den);
404 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
405 "src", args, NULL, ost->graph);
408 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
409 "out", NULL, &ffsink_ctx, ost->graph);
412 last_filter = ost->input_video_filter;
414 if (codec->width != icodec->width || codec->height != icodec->height) {
415 snprintf(args, 255, "%d:%d:flags=0x%X",
419 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
420 NULL, args, NULL, ost->graph)) < 0)
422 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
424 last_filter = filter;
427 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
428 ost->graph->scale_sws_opts = av_strdup(args);
431 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
432 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
434 outputs->name = av_strdup("in");
435 outputs->filter_ctx = last_filter;
436 outputs->pad_idx = 0;
437 outputs->next = NULL;
439 inputs->name = av_strdup("out");
440 inputs->filter_ctx = ost->output_video_filter;
444 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
446 av_freep(&ost->avfilter);
448 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
452 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
455 codec->width = ost->output_video_filter->inputs[0]->w;
456 codec->height = ost->output_video_filter->inputs[0]->h;
457 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
458 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
459 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
460 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
464 #endif /* CONFIG_AVFILTER */
466 static void term_exit(void)
468 av_log(NULL, AV_LOG_QUIET, "");
471 static volatile int received_sigterm = 0;
472 static volatile int received_nb_signals = 0;
475 sigterm_handler(int sig)
477 received_sigterm = sig;
478 received_nb_signals++;
482 static void term_init(void)
484 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
485 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
487 signal(SIGXCPU, sigterm_handler);
491 static int decode_interrupt_cb(void)
493 return received_nb_signals > 1;
496 void exit_program(int ret)
501 for(i=0;i<nb_output_files;i++) {
502 AVFormatContext *s = output_files[i].ctx;
503 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
505 avformat_free_context(s);
506 av_dict_free(&output_files[i].opts);
508 for(i=0;i<nb_input_files;i++) {
509 av_close_input_file(input_files[i].ctx);
511 for (i = 0; i < nb_input_streams; i++)
512 av_dict_free(&input_streams[i].opts);
514 av_free(intra_matrix);
515 av_free(inter_matrix);
519 av_free(vstats_filename);
521 av_freep(&input_streams);
522 av_freep(&input_files);
523 av_freep(&output_streams);
524 av_freep(&output_files);
529 allocated_audio_buf_size= allocated_audio_out_size= 0;
536 if (received_sigterm) {
538 "Received signal %d: terminating.\n",
539 (int) received_sigterm);
543 exit(ret); /* not all OS-es handle main() return value */
546 static void assert_avoptions(AVDictionary *m)
548 AVDictionaryEntry *t;
549 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
550 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
555 static void assert_codec_experimental(AVCodecContext *c, int encoder)
557 const char *codec_string = encoder ? "encoder" : "decoder";
559 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
560 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
561 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
562 "results.\nAdd '-strict experimental' if you want to use it.\n",
563 codec_string, c->codec->name);
564 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
565 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
566 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
567 codec_string, codec->name);
572 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
574 if(codec && codec->sample_fmts){
575 const enum AVSampleFormat *p= codec->sample_fmts;
577 if(*p == st->codec->sample_fmt)
581 av_log(NULL, AV_LOG_WARNING,
582 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
583 av_get_sample_fmt_name(st->codec->sample_fmt),
585 av_get_sample_fmt_name(codec->sample_fmts[0]));
586 st->codec->sample_fmt = codec->sample_fmts[0];
592 * Update the requested input sample format based on the output sample format.
593 * This is currently only used to request float output from decoders which
594 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
595 * Ideally this will be removed in the future when decoders do not do format
596 * conversion and only output in their native format.
598 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
601 /* if sample formats match or a decoder sample format has already been
602 requested, just return */
603 if (enc->sample_fmt == dec->sample_fmt ||
604 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
607 /* if decoder supports more than one output format */
608 if (dec_codec && dec_codec->sample_fmts &&
609 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
610 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
611 const enum AVSampleFormat *p;
612 int min_dec = -1, min_inc = -1;
614 /* find a matching sample format in the encoder */
615 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
616 if (*p == enc->sample_fmt) {
617 dec->request_sample_fmt = *p;
619 } else if (*p > enc->sample_fmt) {
620 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
622 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
625 /* if none match, provide the one that matches quality closest */
626 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
627 enc->sample_fmt - min_dec;
631 static void choose_sample_rate(AVStream *st, AVCodec *codec)
633 if(codec && codec->supported_samplerates){
634 const int *p= codec->supported_samplerates;
636 int best_dist=INT_MAX;
638 int dist= abs(st->codec->sample_rate - *p);
639 if(dist < best_dist){
645 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
647 st->codec->sample_rate= best;
651 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
653 if(codec && codec->pix_fmts){
654 const enum PixelFormat *p= codec->pix_fmts;
655 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
656 if(st->codec->codec_id==CODEC_ID_MJPEG){
657 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
658 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
659 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
663 if(*p == st->codec->pix_fmt)
667 if(st->codec->pix_fmt != PIX_FMT_NONE)
668 av_log(NULL, AV_LOG_WARNING,
669 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
670 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
672 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
673 st->codec->pix_fmt = codec->pix_fmts[0];
679 get_sync_ipts(const OutputStream *ost)
681 const InputStream *ist = ost->sync_ist;
682 OutputFile *of = &output_files[ost->file_index];
683 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
686 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
690 AVPacket new_pkt= *pkt;
691 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
692 &new_pkt.data, &new_pkt.size,
693 pkt->data, pkt->size,
694 pkt->flags & AV_PKT_FLAG_KEY);
697 new_pkt.destruct= av_destruct_packet;
699 fprintf(stderr, "%s failed for stream %d, codec %s",
700 bsfc->filter->name, pkt->stream_index,
701 avctx->codec ? avctx->codec->name : "copy");
711 ret= av_interleaved_write_frame(s, pkt);
713 print_error("av_interleaved_write_frame()", ret);
718 static void do_audio_out(AVFormatContext *s,
721 unsigned char *buf, int size)
724 int64_t audio_out_size, audio_buf_size;
725 int64_t allocated_for_size= size;
727 int size_out, frame_bytes, ret, resample_changed;
728 AVCodecContext *enc= ost->st->codec;
729 AVCodecContext *dec= ist->st->codec;
730 int osize = av_get_bytes_per_sample(enc->sample_fmt);
731 int isize = av_get_bytes_per_sample(dec->sample_fmt);
732 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
735 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
736 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
737 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
738 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
739 audio_buf_size*= osize*enc->channels;
741 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
742 if(coded_bps > 8*osize)
743 audio_out_size= audio_out_size * coded_bps / (8*osize);
744 audio_out_size += FF_MIN_BUFFER_SIZE;
746 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
747 fprintf(stderr, "Buffer sizes too large\n");
751 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
752 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
753 if (!audio_buf || !audio_out){
754 fprintf(stderr, "Out of memory in do_audio_out\n");
758 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
759 ost->audio_resample = 1;
761 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
762 ost->resample_channels != dec->channels ||
763 ost->resample_sample_rate != dec->sample_rate;
765 if ((ost->audio_resample && !ost->resample) || resample_changed) {
766 if (resample_changed) {
767 av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
768 ist->file_index, ist->st->index,
769 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
770 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
771 ost->resample_sample_fmt = dec->sample_fmt;
772 ost->resample_channels = dec->channels;
773 ost->resample_sample_rate = dec->sample_rate;
775 audio_resample_close(ost->resample);
777 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
778 if (audio_sync_method <= 1 &&
779 ost->resample_sample_fmt == enc->sample_fmt &&
780 ost->resample_channels == enc->channels &&
781 ost->resample_sample_rate == enc->sample_rate) {
782 ost->resample = NULL;
783 ost->audio_resample = 0;
784 } else if (ost->audio_resample) {
785 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
786 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
787 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
788 enc->sample_rate, dec->sample_rate,
789 enc->sample_fmt, dec->sample_fmt,
791 if (!ost->resample) {
792 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
793 dec->channels, dec->sample_rate,
794 enc->channels, enc->sample_rate);
800 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
801 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
802 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
803 if (ost->reformat_ctx)
804 av_audio_convert_free(ost->reformat_ctx);
805 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
806 dec->sample_fmt, 1, NULL, 0);
807 if (!ost->reformat_ctx) {
808 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
809 av_get_sample_fmt_name(dec->sample_fmt),
810 av_get_sample_fmt_name(enc->sample_fmt));
813 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
816 if(audio_sync_method){
817 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
818 - av_fifo_size(ost->fifo)/(enc->channels * 2);
819 double idelta= delta*dec->sample_rate / enc->sample_rate;
820 int byte_delta= ((int)idelta)*2*dec->channels;
822 //FIXME resample delay
823 if(fabs(delta) > 50){
824 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
826 byte_delta= FFMAX(byte_delta, -size);
830 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
835 static uint8_t *input_tmp= NULL;
836 input_tmp= av_realloc(input_tmp, byte_delta + size);
838 if(byte_delta > allocated_for_size - size){
839 allocated_for_size= byte_delta + (int64_t)size;
844 memset(input_tmp, 0, byte_delta);
845 memcpy(input_tmp + byte_delta, buf, size);
849 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
851 }else if(audio_sync_method>1){
852 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
853 av_assert0(ost->audio_resample);
855 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
856 // fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
857 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
861 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
862 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
864 if (ost->audio_resample) {
866 size_out = audio_resample(ost->resample,
867 (short *)buftmp, (short *)buf,
868 size / (dec->channels * isize));
869 size_out = size_out * enc->channels * osize;
875 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
876 const void *ibuf[6]= {buftmp};
877 void *obuf[6]= {audio_buf};
878 int istride[6]= {isize};
879 int ostride[6]= {osize};
880 int len= size_out/istride[0];
881 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
882 printf("av_audio_convert() failed\n");
888 size_out = len*osize;
891 /* now encode as many frames as possible */
892 if (enc->frame_size > 1) {
893 /* output resampled raw samples */
894 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
895 fprintf(stderr, "av_fifo_realloc2() failed\n");
898 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
900 frame_bytes = enc->frame_size * osize * enc->channels;
902 while (av_fifo_size(ost->fifo) >= frame_bytes) {
904 av_init_packet(&pkt);
906 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
908 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
910 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
913 fprintf(stderr, "Audio encoding failed\n");
917 pkt.stream_index= ost->index;
920 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
921 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
922 pkt.flags |= AV_PKT_FLAG_KEY;
923 write_frame(s, &pkt, enc, ost->bitstream_filters);
925 ost->sync_opts += enc->frame_size;
929 av_init_packet(&pkt);
931 ost->sync_opts += size_out / (osize * enc->channels);
933 /* output a pcm frame */
934 /* determine the size of the coded buffer */
937 size_out = size_out*coded_bps/8;
939 if(size_out > audio_out_size){
940 fprintf(stderr, "Internal error, buffer size too small\n");
944 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
945 ret = avcodec_encode_audio(enc, audio_out, size_out,
948 fprintf(stderr, "Audio encoding failed\n");
952 pkt.stream_index= ost->index;
955 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
956 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
957 pkt.flags |= AV_PKT_FLAG_KEY;
958 write_frame(s, &pkt, enc, ost->bitstream_filters);
962 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
966 AVPicture picture_tmp;
969 dec = ist->st->codec;
971 /* deinterlace : must be done before any resize */
972 if (do_deinterlace) {
975 /* create temporary picture */
976 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
977 buf = av_malloc(size);
981 picture2 = &picture_tmp;
982 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
984 if(avpicture_deinterlace(picture2, picture,
985 dec->pix_fmt, dec->width, dec->height) < 0) {
986 /* if error, do not deinterlace */
987 fprintf(stderr, "Deinterlacing failed\n");
996 if (picture != picture2)
997 *picture = *picture2;
1001 static void do_subtitle_out(AVFormatContext *s,
1007 static uint8_t *subtitle_out = NULL;
1008 int subtitle_out_max_size = 1024 * 1024;
1009 int subtitle_out_size, nb, i;
1010 AVCodecContext *enc;
1013 if (pts == AV_NOPTS_VALUE) {
1014 fprintf(stderr, "Subtitle packets must have a pts\n");
1020 enc = ost->st->codec;
1022 if (!subtitle_out) {
1023 subtitle_out = av_malloc(subtitle_out_max_size);
1026 /* Note: DVB subtitle need one packet to draw them and one other
1027 packet to clear them */
1028 /* XXX: signal it in the codec context ? */
1029 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1034 for(i = 0; i < nb; i++) {
1035 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1036 // start_display_time is required to be 0
1037 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1038 sub->end_display_time -= sub->start_display_time;
1039 sub->start_display_time = 0;
1040 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1041 subtitle_out_max_size, sub);
1042 if (subtitle_out_size < 0) {
1043 fprintf(stderr, "Subtitle encoding failed\n");
1047 av_init_packet(&pkt);
1048 pkt.stream_index = ost->index;
1049 pkt.data = subtitle_out;
1050 pkt.size = subtitle_out_size;
1051 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1052 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1053 /* XXX: the pts correction is handled here. Maybe handling
1054 it in the codec would be better */
1056 pkt.pts += 90 * sub->start_display_time;
1058 pkt.pts += 90 * sub->end_display_time;
1060 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1064 static int bit_buffer_size= 1024*256;
1065 static uint8_t *bit_buffer= NULL;
1067 static void do_video_resample(OutputStream *ost,
1069 AVFrame *in_picture,
1070 AVFrame **out_picture)
1072 int resample_changed = 0;
1073 AVCodecContext *dec = ist->st->codec;
1074 *out_picture = in_picture;
1076 resample_changed = ost->resample_width != dec->width ||
1077 ost->resample_height != dec->height ||
1078 ost->resample_pix_fmt != dec->pix_fmt;
1080 if (resample_changed) {
1081 av_log(NULL, AV_LOG_INFO,
1082 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1083 ist->file_index, ist->st->index,
1084 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1085 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1086 if(!ost->video_resample)
1087 ost->video_resample = 1;
1090 #if !CONFIG_AVFILTER
1091 if (ost->video_resample) {
1092 *out_picture = &ost->pict_tmp;
1093 if (resample_changed) {
1094 /* initialize a new scaler context */
1095 sws_freeContext(ost->img_resample_ctx);
1096 ost->img_resample_ctx = sws_getContext(
1097 ist->st->codec->width,
1098 ist->st->codec->height,
1099 ist->st->codec->pix_fmt,
1100 ost->st->codec->width,
1101 ost->st->codec->height,
1102 ost->st->codec->pix_fmt,
1103 ost->sws_flags, NULL, NULL, NULL);
1104 if (ost->img_resample_ctx == NULL) {
1105 fprintf(stderr, "Cannot get resampling context\n");
1109 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1110 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1113 if (resample_changed) {
1114 avfilter_graph_free(&ost->graph);
1115 if (configure_video_filters(ist, ost)) {
1116 fprintf(stderr, "Error reinitializing filters!\n");
1121 if (resample_changed) {
1122 ost->resample_width = dec->width;
1123 ost->resample_height = dec->height;
1124 ost->resample_pix_fmt = dec->pix_fmt;
1129 static void do_video_out(AVFormatContext *s,
1132 AVFrame *in_picture,
1133 int *frame_size, float quality)
1135 int nb_frames, i, ret, format_video_sync;
1136 AVFrame *final_picture;
1137 AVCodecContext *enc;
1140 enc = ost->st->codec;
1142 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1144 /* by default, we output a single frame */
1149 format_video_sync = video_sync_method;
1150 if (format_video_sync < 0)
1151 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1153 if (format_video_sync) {
1154 double vdelta = sync_ipts - ost->sync_opts;
1155 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1158 else if (format_video_sync == 2) {
1161 }else if(vdelta>0.6)
1162 ost->sync_opts= lrintf(sync_ipts);
1163 }else if (vdelta > 1.1)
1164 nb_frames = lrintf(vdelta);
1165 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1166 if (nb_frames == 0){
1169 fprintf(stderr, "*** drop!\n");
1170 }else if (nb_frames > 1) {
1171 nb_frames_dup += nb_frames - 1;
1173 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1176 ost->sync_opts= lrintf(sync_ipts);
1178 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1182 do_video_resample(ost, ist, in_picture, &final_picture);
1184 /* duplicates frame if needed */
1185 for(i=0;i<nb_frames;i++) {
1187 av_init_packet(&pkt);
1188 pkt.stream_index= ost->index;
1190 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1191 /* raw pictures are written as AVPicture structure to
1192 avoid any copies. We support temporarily the older
1194 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1195 enc->coded_frame->top_field_first = in_picture->top_field_first;
1196 pkt.data= (uint8_t *)final_picture;
1197 pkt.size= sizeof(AVPicture);
1198 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1199 pkt.flags |= AV_PKT_FLAG_KEY;
1201 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1203 AVFrame big_picture;
1205 big_picture= *final_picture;
1206 /* better than nothing: use input picture interlaced
1208 big_picture.interlaced_frame = in_picture->interlaced_frame;
1209 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1210 if(top_field_first == -1)
1211 big_picture.top_field_first = in_picture->top_field_first;
1213 big_picture.top_field_first = top_field_first;
1216 /* handles same_quant here. This is not correct because it may
1217 not be a global option */
1218 big_picture.quality = quality;
1219 if (!enc->me_threshold)
1220 big_picture.pict_type = 0;
1221 // big_picture.pts = AV_NOPTS_VALUE;
1222 big_picture.pts= ost->sync_opts;
1223 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1224 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1225 if (ost->forced_kf_index < ost->forced_kf_count &&
1226 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1227 big_picture.pict_type = AV_PICTURE_TYPE_I;
1228 ost->forced_kf_index++;
1230 ret = avcodec_encode_video(enc,
1231 bit_buffer, bit_buffer_size,
1234 fprintf(stderr, "Video encoding failed\n");
1239 pkt.data= bit_buffer;
1241 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1242 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1243 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1244 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1245 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1247 if(enc->coded_frame->key_frame)
1248 pkt.flags |= AV_PKT_FLAG_KEY;
1249 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1252 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1253 // enc->frame_number-1, ret, enc->pict_type);
1254 /* if two pass, output log */
1255 if (ost->logfile && enc->stats_out) {
1256 fprintf(ost->logfile, "%s", enc->stats_out);
1261 ost->frame_number++;
1265 static double psnr(double d){
1266 return -10.0*log(d)/log(10.0);
1269 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1272 AVCodecContext *enc;
1274 double ti1, bitrate, avg_bitrate;
1276 /* this is executed just the first time do_video_stats is called */
1278 vstats_file = fopen(vstats_filename, "w");
1285 enc = ost->st->codec;
1286 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1287 frame_number = ost->frame_number;
1288 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1289 if (enc->flags&CODEC_FLAG_PSNR)
1290 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1292 fprintf(vstats_file,"f_size= %6d ", frame_size);
1293 /* compute pts value */
1294 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1298 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1299 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1300 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1301 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1302 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1306 static void print_report(OutputFile *output_files,
1307 OutputStream *ost_table, int nb_ostreams,
1308 int is_last_report, int64_t timer_start)
1312 AVFormatContext *oc;
1314 AVCodecContext *enc;
1315 int frame_number, vid, i;
1316 double bitrate, ti1, pts;
1317 static int64_t last_time = -1;
1318 static int qp_histogram[52];
1320 if (!is_last_report) {
1322 /* display the report every 0.5 seconds */
1323 cur_time = av_gettime();
1324 if (last_time == -1) {
1325 last_time = cur_time;
1328 if ((cur_time - last_time) < 500000)
1330 last_time = cur_time;
1334 oc = output_files[0].ctx;
1336 total_size = avio_size(oc->pb);
1337 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1338 total_size= avio_tell(oc->pb);
1343 for(i=0;i<nb_ostreams;i++) {
1345 ost = &ost_table[i];
1346 enc = ost->st->codec;
1347 if (!ost->st->stream_copy && enc->coded_frame)
1348 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1349 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1350 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1352 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1353 float t = (av_gettime()-timer_start) / 1000000.0;
1355 frame_number = ost->frame_number;
1356 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1357 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1359 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1363 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1366 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1368 if (enc->flags&CODEC_FLAG_PSNR){
1370 double error, error_sum=0;
1371 double scale, scale_sum=0;
1372 char type[3]= {'Y','U','V'};
1373 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1376 error= enc->error[j];
1377 scale= enc->width*enc->height*255.0*255.0*frame_number;
1379 error= enc->coded_frame->error[j];
1380 scale= enc->width*enc->height*255.0*255.0;
1385 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1387 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1391 /* compute min output value */
1392 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1393 if ((pts < ti1) && (pts > 0))
1399 if (verbose > 0 || is_last_report) {
1400 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1402 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1403 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1404 (double)total_size / 1024, ti1, bitrate);
1406 if (nb_frames_dup || nb_frames_drop)
1407 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1408 nb_frames_dup, nb_frames_drop);
1411 fprintf(stderr, "%s \r", buf);
1416 if (is_last_report && verbose >= 0){
1417 int64_t raw= audio_size + video_size + extra_size;
1418 fprintf(stderr, "\n");
1419 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1423 100.0*(total_size - raw)/raw
1428 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1430 int fill_char = 0x00;
1431 if (sample_fmt == AV_SAMPLE_FMT_U8)
1433 memset(buf, fill_char, size);
1436 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1440 for (i = 0; i < nb_ostreams; i++) {
1441 OutputStream *ost = &ost_table[i];
1442 AVCodecContext *enc = ost->st->codec;
1443 AVFormatContext *os = output_files[ost->file_index].ctx;
1445 if (!ost->encoding_needed)
1448 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1450 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1456 av_init_packet(&pkt);
1457 pkt.stream_index= ost->index;
1459 switch (ost->st->codec->codec_type) {
1460 case AVMEDIA_TYPE_AUDIO:
1461 fifo_bytes = av_fifo_size(ost->fifo);
1463 /* encode any samples remaining in fifo */
1464 if (fifo_bytes > 0) {
1465 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1466 int fs_tmp = enc->frame_size;
1468 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1469 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1470 enc->frame_size = fifo_bytes / (osize * enc->channels);
1472 int frame_bytes = enc->frame_size*osize*enc->channels;
1473 if (allocated_audio_buf_size < frame_bytes)
1475 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1478 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1479 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1480 ost->st->time_base.num, enc->sample_rate);
1481 enc->frame_size = fs_tmp;
1484 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1487 fprintf(stderr, "Audio encoding failed\n");
1491 pkt.flags |= AV_PKT_FLAG_KEY;
1493 case AVMEDIA_TYPE_VIDEO:
1494 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1496 fprintf(stderr, "Video encoding failed\n");
1500 if(enc->coded_frame && enc->coded_frame->key_frame)
1501 pkt.flags |= AV_PKT_FLAG_KEY;
1502 if (ost->logfile && enc->stats_out) {
1503 fprintf(ost->logfile, "%s", enc->stats_out);
1512 pkt.data = bit_buffer;
1514 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1515 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1516 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1521 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1522 static int output_packet(InputStream *ist, int ist_index,
1523 OutputStream *ost_table, int nb_ostreams,
1524 const AVPacket *pkt)
1526 AVFormatContext *os;
1531 void *buffer_to_free = NULL;
1532 static unsigned int samples_size= 0;
1533 AVSubtitle subtitle, *subtitle_to_free;
1534 int64_t pkt_pts = AV_NOPTS_VALUE;
1536 int frame_available;
1541 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1543 if(ist->next_pts == AV_NOPTS_VALUE)
1544 ist->next_pts= ist->pts;
1548 av_init_packet(&avpkt);
1556 if(pkt->dts != AV_NOPTS_VALUE)
1557 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1558 if(pkt->pts != AV_NOPTS_VALUE)
1559 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1561 //while we have more to decode or while the decoder did output something on EOF
1562 while (avpkt.size > 0 || (!pkt && got_output)) {
1563 uint8_t *data_buf, *decoded_data_buf;
1564 int data_size, decoded_data_size;
1566 ist->pts= ist->next_pts;
1568 if(avpkt.size && avpkt.size != pkt->size &&
1569 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1570 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1571 ist->showed_multi_packet_warning=1;
1574 /* decode the packet if needed */
1575 decoded_data_buf = NULL; /* fail safe */
1576 decoded_data_size= 0;
1577 data_buf = avpkt.data;
1578 data_size = avpkt.size;
1579 subtitle_to_free = NULL;
1580 if (ist->decoding_needed) {
1581 switch(ist->st->codec->codec_type) {
1582 case AVMEDIA_TYPE_AUDIO:{
1583 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1584 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1586 samples= av_malloc(samples_size);
1588 decoded_data_size= samples_size;
1589 /* XXX: could avoid copy if PCM 16 bits with same
1590 endianness as CPU */
1591 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1598 got_output = decoded_data_size > 0;
1599 /* Some bug in mpeg audio decoder gives */
1600 /* decoded_data_size < 0, it seems they are overflows */
1602 /* no audio frame */
1605 decoded_data_buf = (uint8_t *)samples;
1606 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1607 (ist->st->codec->sample_rate * ist->st->codec->channels);
1609 case AVMEDIA_TYPE_VIDEO:
1610 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1611 /* XXX: allocate picture correctly */
1612 avcodec_get_frame_defaults(&picture);
1613 avpkt.pts = pkt_pts;
1614 avpkt.dts = ist->pts;
1615 pkt_pts = AV_NOPTS_VALUE;
1617 ret = avcodec_decode_video2(ist->st->codec,
1618 &picture, &got_output, &avpkt);
1619 quality = same_quant ? picture.quality : 0;
1623 /* no picture yet */
1624 goto discard_packet;
1626 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1627 if (ist->st->codec->time_base.num != 0) {
1628 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1629 ist->next_pts += ((int64_t)AV_TIME_BASE *
1630 ist->st->codec->time_base.num * ticks) /
1631 ist->st->codec->time_base.den;
1634 buffer_to_free = NULL;
1635 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1637 case AVMEDIA_TYPE_SUBTITLE:
1638 ret = avcodec_decode_subtitle2(ist->st->codec,
1639 &subtitle, &got_output, &avpkt);
1643 goto discard_packet;
1645 subtitle_to_free = &subtitle;
1652 switch(ist->st->codec->codec_type) {
1653 case AVMEDIA_TYPE_AUDIO:
1654 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1655 ist->st->codec->sample_rate;
1657 case AVMEDIA_TYPE_VIDEO:
1658 if (ist->st->codec->time_base.num != 0) {
1659 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1660 ist->next_pts += ((int64_t)AV_TIME_BASE *
1661 ist->st->codec->time_base.num * ticks) /
1662 ist->st->codec->time_base.den;
1669 // preprocess audio (volume)
1670 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1671 if (audio_volume != 256) {
1674 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1675 int v = ((*volp) * audio_volume + 128) >> 8;
1676 *volp++ = av_clip_int16(v);
1681 /* frame rate emulation */
1682 if (input_files[ist->file_index].rate_emu) {
1683 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1684 int64_t now = av_gettime() - ist->start;
1688 /* if output time reached then transcode raw format,
1689 encode packets and output them */
1690 for (i = 0; i < nb_ostreams; i++) {
1691 OutputFile *of = &output_files[ost_table[i].file_index];
1694 ost = &ost_table[i];
1695 if (ost->source_index != ist_index)
1698 if (of->start_time && ist->pts < of->start_time)
1701 if (of->recording_time != INT64_MAX &&
1702 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1703 (AVRational){1, 1000000}) >= 0) {
1704 ost->is_past_recording_time = 1;
1709 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1710 ost->input_video_filter) {
1712 if (ist->st->sample_aspect_ratio.num)
1713 sar = ist->st->sample_aspect_ratio;
1715 sar = ist->st->codec->sample_aspect_ratio;
1716 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, ist->pts, sar);
1718 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1719 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1720 while (frame_available) {
1721 AVRational ist_pts_tb;
1722 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1723 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1725 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1727 os = output_files[ost->file_index].ctx;
1729 /* set the input output pts pairs */
1730 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1732 if (ost->encoding_needed) {
1733 av_assert0(ist->decoding_needed);
1734 switch(ost->st->codec->codec_type) {
1735 case AVMEDIA_TYPE_AUDIO:
1736 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1738 case AVMEDIA_TYPE_VIDEO:
1740 if (ost->picref->video && !ost->frame_aspect_ratio)
1741 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1743 do_video_out(os, ost, ist, &picture, &frame_size,
1744 same_quant ? quality : ost->st->codec->global_quality);
1745 if (vstats_filename && frame_size)
1746 do_video_stats(os, ost, frame_size);
1748 case AVMEDIA_TYPE_SUBTITLE:
1749 do_subtitle_out(os, ost, ist, &subtitle,
1756 AVFrame avframe; //FIXME/XXX remove this
1758 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1760 av_init_packet(&opkt);
1762 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1763 #if !CONFIG_AVFILTER
1769 /* no reencoding needed : output the packet directly */
1770 /* force the input stream PTS */
1772 avcodec_get_frame_defaults(&avframe);
1773 ost->st->codec->coded_frame= &avframe;
1774 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1776 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1777 audio_size += data_size;
1778 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1779 video_size += data_size;
1783 opkt.stream_index= ost->index;
1784 if(pkt->pts != AV_NOPTS_VALUE)
1785 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1787 opkt.pts= AV_NOPTS_VALUE;
1789 if (pkt->dts == AV_NOPTS_VALUE)
1790 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1792 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1793 opkt.dts -= ost_tb_start_time;
1795 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1796 opkt.flags= pkt->flags;
1798 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1799 if( ost->st->codec->codec_id != CODEC_ID_H264
1800 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1801 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1803 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1804 opkt.destruct= av_destruct_packet;
1806 opkt.data = data_buf;
1807 opkt.size = data_size;
1810 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1811 ost->st->codec->frame_number++;
1812 ost->frame_number++;
1813 av_free_packet(&opkt);
1817 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1818 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1820 avfilter_unref_buffer(ost->picref);
1825 av_free(buffer_to_free);
1826 /* XXX: allocate the subtitles in the codec ? */
1827 if (subtitle_to_free) {
1828 avsubtitle_free(subtitle_to_free);
1829 subtitle_to_free = NULL;
1837 static void print_sdp(OutputFile *output_files, int n)
1841 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1845 for (i = 0; i < n; i++)
1846 avc[i] = output_files[i].ctx;
1848 av_sdp_create(avc, n, sdp, sizeof(sdp));
1849 printf("SDP:\n%s\n", sdp);
1854 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1855 char *error, int error_len)
1858 InputStream *ist = &input_streams[ist_index];
1859 if (ist->decoding_needed) {
1860 AVCodec *codec = ist->dec;
1862 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1863 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1864 return AVERROR(EINVAL);
1867 /* update requested sample format for the decoder based on the
1868 corresponding encoder sample format */
1869 for (i = 0; i < nb_output_streams; i++) {
1870 OutputStream *ost = &output_streams[i];
1871 if (ost->source_index == ist_index) {
1872 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1877 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1878 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1879 ist->file_index, ist->st->index);
1880 return AVERROR(EINVAL);
1882 assert_codec_experimental(ist->st->codec, 0);
1883 assert_avoptions(ist->opts);
1886 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;
1887 ist->next_pts = AV_NOPTS_VALUE;
1888 init_pts_correction(&ist->pts_ctx);
1894 static int transcode_init(OutputFile *output_files,
1895 int nb_output_files,
1896 InputFile *input_files,
1899 int ret = 0, i, j, k;
1900 AVFormatContext *os;
1901 AVCodecContext *codec, *icodec;
1907 /* init framerate emulation */
1908 for (i = 0; i < nb_input_files; i++) {
1909 InputFile *ifile = &input_files[i];
1910 if (ifile->rate_emu)
1911 for (j = 0; j < ifile->nb_streams; j++)
1912 input_streams[j + ifile->ist_index].start = av_gettime();
1915 /* output stream init */
1916 for(i=0;i<nb_output_files;i++) {
1917 os = output_files[i].ctx;
1918 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1919 av_dump_format(os, i, os->filename, 1);
1920 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1921 return AVERROR(EINVAL);
1925 /* for each output stream, we compute the right encoding parameters */
1926 for (i = 0; i < nb_output_streams; i++) {
1927 ost = &output_streams[i];
1928 os = output_files[ost->file_index].ctx;
1929 ist = &input_streams[ost->source_index];
1931 codec = ost->st->codec;
1932 icodec = ist->st->codec;
1934 ost->st->disposition = ist->st->disposition;
1935 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1936 codec->chroma_sample_location = icodec->chroma_sample_location;
1938 if (ost->st->stream_copy) {
1939 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1941 if (extra_size > INT_MAX) {
1942 return AVERROR(EINVAL);
1945 /* if stream_copy is selected, no need to decode or encode */
1946 codec->codec_id = icodec->codec_id;
1947 codec->codec_type = icodec->codec_type;
1949 if(!codec->codec_tag){
1950 if( !os->oformat->codec_tag
1951 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1952 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1953 codec->codec_tag = icodec->codec_tag;
1956 codec->bit_rate = icodec->bit_rate;
1957 codec->rc_max_rate = icodec->rc_max_rate;
1958 codec->rc_buffer_size = icodec->rc_buffer_size;
1959 codec->extradata= av_mallocz(extra_size);
1960 if (!codec->extradata) {
1961 return AVERROR(ENOMEM);
1963 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1964 codec->extradata_size= icodec->extradata_size;
1965 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
1966 codec->time_base = icodec->time_base;
1967 codec->time_base.num *= icodec->ticks_per_frame;
1968 av_reduce(&codec->time_base.num, &codec->time_base.den,
1969 codec->time_base.num, codec->time_base.den, INT_MAX);
1971 codec->time_base = ist->st->time_base;
1972 switch(codec->codec_type) {
1973 case AVMEDIA_TYPE_AUDIO:
1974 if(audio_volume != 256) {
1975 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1978 codec->channel_layout = icodec->channel_layout;
1979 codec->sample_rate = icodec->sample_rate;
1980 codec->channels = icodec->channels;
1981 codec->frame_size = icodec->frame_size;
1982 codec->audio_service_type = icodec->audio_service_type;
1983 codec->block_align= icodec->block_align;
1984 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1985 codec->block_align= 0;
1986 if(codec->codec_id == CODEC_ID_AC3)
1987 codec->block_align= 0;
1989 case AVMEDIA_TYPE_VIDEO:
1990 codec->pix_fmt = icodec->pix_fmt;
1991 codec->width = icodec->width;
1992 codec->height = icodec->height;
1993 codec->has_b_frames = icodec->has_b_frames;
1994 if (!codec->sample_aspect_ratio.num) {
1995 codec->sample_aspect_ratio =
1996 ost->st->sample_aspect_ratio =
1997 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1998 ist->st->codec->sample_aspect_ratio.num ?
1999 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2002 case AVMEDIA_TYPE_SUBTITLE:
2003 codec->width = icodec->width;
2004 codec->height = icodec->height;
2006 case AVMEDIA_TYPE_DATA:
2013 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2014 switch(codec->codec_type) {
2015 case AVMEDIA_TYPE_AUDIO:
2016 ost->fifo= av_fifo_alloc(1024);
2018 return AVERROR(ENOMEM);
2020 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2021 if (!codec->sample_rate) {
2022 codec->sample_rate = icodec->sample_rate;
2024 codec->sample_rate >>= icodec->lowres;
2026 choose_sample_rate(ost->st, ost->enc);
2027 codec->time_base = (AVRational){1, codec->sample_rate};
2028 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2029 codec->sample_fmt = icodec->sample_fmt;
2030 choose_sample_fmt(ost->st, ost->enc);
2031 if (!codec->channels)
2032 codec->channels = icodec->channels;
2033 codec->channel_layout = icodec->channel_layout;
2034 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2035 codec->channel_layout = 0;
2036 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2037 icodec->request_channels = codec->channels;
2038 ist->decoding_needed = 1;
2039 ost->encoding_needed = 1;
2040 ost->resample_sample_fmt = icodec->sample_fmt;
2041 ost->resample_sample_rate = icodec->sample_rate;
2042 ost->resample_channels = icodec->channels;
2044 case AVMEDIA_TYPE_VIDEO:
2045 if (codec->pix_fmt == PIX_FMT_NONE)
2046 codec->pix_fmt = icodec->pix_fmt;
2047 choose_pixel_fmt(ost->st, ost->enc);
2049 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2050 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2054 if (!codec->width || !codec->height) {
2055 codec->width = icodec->width;
2056 codec->height = icodec->height;
2059 ost->video_resample = codec->width != icodec->width ||
2060 codec->height != icodec->height ||
2061 codec->pix_fmt != icodec->pix_fmt;
2062 if (ost->video_resample) {
2063 #if !CONFIG_AVFILTER
2064 avcodec_get_frame_defaults(&ost->pict_tmp);
2065 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2066 codec->width, codec->height)) {
2067 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2070 ost->img_resample_ctx = sws_getContext(
2077 ost->sws_flags, NULL, NULL, NULL);
2078 if (ost->img_resample_ctx == NULL) {
2079 fprintf(stderr, "Cannot get resampling context\n");
2083 codec->bits_per_raw_sample= 0;
2086 ost->resample_height = icodec->height;
2087 ost->resample_width = icodec->width;
2088 ost->resample_pix_fmt= icodec->pix_fmt;
2089 ost->encoding_needed = 1;
2090 ist->decoding_needed = 1;
2092 if (!ost->frame_rate.num)
2093 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2094 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2095 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2096 ost->frame_rate = ost->enc->supported_framerates[idx];
2098 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2101 if (configure_video_filters(ist, ost)) {
2102 fprintf(stderr, "Error opening filters!\n");
2107 case AVMEDIA_TYPE_SUBTITLE:
2108 ost->encoding_needed = 1;
2109 ist->decoding_needed = 1;
2116 if (ost->encoding_needed &&
2117 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2118 char logfilename[1024];
2121 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2122 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2124 if (codec->flags & CODEC_FLAG_PASS1) {
2125 f = fopen(logfilename, "wb");
2127 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2133 size_t logbuffer_size;
2134 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2135 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2138 codec->stats_in = logbuffer;
2142 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2143 int size= codec->width * codec->height;
2144 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2149 bit_buffer = av_malloc(bit_buffer_size);
2151 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2153 return AVERROR(ENOMEM);
2156 /* open each encoder */
2157 for (i = 0; i < nb_output_streams; i++) {
2158 ost = &output_streams[i];
2159 if (ost->encoding_needed) {
2160 AVCodec *codec = ost->enc;
2161 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2163 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2164 ost->st->codec->codec_id, ost->file_index, ost->index);
2165 ret = AVERROR(EINVAL);
2168 if (dec->subtitle_header) {
2169 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2170 if (!ost->st->codec->subtitle_header) {
2171 ret = AVERROR(ENOMEM);
2174 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2175 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2177 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2178 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2179 ost->file_index, ost->index);
2180 ret = AVERROR(EINVAL);
2183 assert_codec_experimental(ost->st->codec, 1);
2184 assert_avoptions(ost->opts);
2185 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2186 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2187 "It takes bits/s as argument, not kbits/s\n");
2188 extra_size += ost->st->codec->extradata_size;
2190 if (ost->st->codec->me_threshold)
2191 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2195 /* init input streams */
2196 for (i = 0; i < nb_input_streams; i++)
2197 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2200 /* discard unused programs */
2201 for (i = 0; i < nb_input_files; i++) {
2202 InputFile *ifile = &input_files[i];
2203 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2204 AVProgram *p = ifile->ctx->programs[j];
2205 int discard = AVDISCARD_ALL;
2207 for (k = 0; k < p->nb_stream_indexes; k++)
2208 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2209 discard = AVDISCARD_DEFAULT;
2212 p->discard = discard;
2216 /* open files and write file headers */
2217 for (i = 0; i < nb_output_files; i++) {
2218 os = output_files[i].ctx;
2219 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2220 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2221 ret = AVERROR(EINVAL);
2224 assert_avoptions(output_files[i].opts);
2225 if (strcmp(os->oformat->name, "rtp")) {
2231 /* dump the file output parameters - cannot be done before in case
2233 for(i=0;i<nb_output_files;i++) {
2234 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2237 /* dump the stream mapping */
2239 fprintf(stderr, "Stream mapping:\n");
2240 for (i = 0; i < nb_output_streams;i ++) {
2241 ost = &output_streams[i];
2242 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2243 input_streams[ost->source_index].file_index,
2244 input_streams[ost->source_index].st->index,
2247 if (ost->sync_ist != &input_streams[ost->source_index])
2248 fprintf(stderr, " [sync #%d.%d]",
2249 ost->sync_ist->file_index,
2250 ost->sync_ist->st->index);
2251 if (ost->st->stream_copy)
2252 fprintf(stderr, " (copy)");
2254 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2255 input_streams[ost->source_index].dec->name : "?",
2256 ost->enc ? ost->enc->name : "?");
2257 fprintf(stderr, "\n");
2262 fprintf(stderr, "%s\n", error);
2267 print_sdp(output_files, nb_output_files);
2274 * The following code is the main loop of the file converter
2276 static int transcode(OutputFile *output_files,
2277 int nb_output_files,
2278 InputFile *input_files,
2282 AVFormatContext *is, *os;
2286 int no_packet_count=0;
2287 int64_t timer_start;
2289 if (!(no_packet = av_mallocz(nb_input_files)))
2292 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2297 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2300 timer_start = av_gettime();
2302 for(; received_sigterm == 0;) {
2303 int file_index, ist_index;
2308 ipts_min = INT64_MAX;
2311 /* select the stream that we must read now by looking at the
2312 smallest output pts */
2314 for (i = 0; i < nb_output_streams; i++) {
2318 ost = &output_streams[i];
2319 of = &output_files[ost->file_index];
2320 os = output_files[ost->file_index].ctx;
2321 ist = &input_streams[ost->source_index];
2322 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2323 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2325 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2327 if (!input_files[ist->file_index].eof_reached){
2328 if(ipts < ipts_min) {
2330 if(input_sync ) file_index = ist->file_index;
2332 if(opts < opts_min) {
2334 if(!input_sync) file_index = ist->file_index;
2337 if (ost->frame_number >= ost->max_frames) {
2339 for (j = of->ost_index; j < of->ctx->nb_streams; j++)
2340 output_streams[j].is_past_recording_time = 1;
2344 /* if none, if is finished */
2345 if (file_index < 0) {
2346 if(no_packet_count){
2348 memset(no_packet, 0, nb_input_files);
2355 /* read a frame from it and output it in the fifo */
2356 is = input_files[file_index].ctx;
2357 ret= av_read_frame(is, &pkt);
2358 if(ret == AVERROR(EAGAIN)){
2359 no_packet[file_index]=1;
2364 input_files[file_index].eof_reached = 1;
2372 memset(no_packet, 0, nb_input_files);
2375 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2376 is->streams[pkt.stream_index]);
2378 /* the following test is needed in case new streams appear
2379 dynamically in stream : we ignore them */
2380 if (pkt.stream_index >= input_files[file_index].nb_streams)
2381 goto discard_packet;
2382 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2383 ist = &input_streams[ist_index];
2385 goto discard_packet;
2387 if (pkt.dts != AV_NOPTS_VALUE)
2388 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2389 if (pkt.pts != AV_NOPTS_VALUE)
2390 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2392 if(pkt.pts != AV_NOPTS_VALUE)
2393 pkt.pts *= ist->ts_scale;
2394 if(pkt.dts != AV_NOPTS_VALUE)
2395 pkt.dts *= ist->ts_scale;
2397 // 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);
2398 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2399 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2400 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2401 int64_t delta= pkt_dts - ist->next_pts;
2402 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2403 input_files[ist->file_index].ts_offset -= delta;
2405 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2406 delta, input_files[ist->file_index].ts_offset);
2407 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2408 if(pkt.pts != AV_NOPTS_VALUE)
2409 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2413 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2414 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2417 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2418 ist->file_index, ist->st->index);
2421 av_free_packet(&pkt);
2426 av_free_packet(&pkt);
2428 /* dump report by using the output first video and audio streams */
2429 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2432 /* at the end of stream, we must flush the decoder buffers */
2433 for (i = 0; i < nb_input_streams; i++) {
2434 ist = &input_streams[i];
2435 if (ist->decoding_needed) {
2436 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2439 flush_encoders(output_streams, nb_output_streams);
2443 /* write the trailer if needed and close file */
2444 for(i=0;i<nb_output_files;i++) {
2445 os = output_files[i].ctx;
2446 av_write_trailer(os);
2449 /* dump report by using the first video and audio streams */
2450 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2452 /* close each encoder */
2453 for (i = 0; i < nb_output_streams; i++) {
2454 ost = &output_streams[i];
2455 if (ost->encoding_needed) {
2456 av_freep(&ost->st->codec->stats_in);
2457 avcodec_close(ost->st->codec);
2460 avfilter_graph_free(&ost->graph);
2464 /* close each decoder */
2465 for (i = 0; i < nb_input_streams; i++) {
2466 ist = &input_streams[i];
2467 if (ist->decoding_needed) {
2468 avcodec_close(ist->st->codec);
2476 av_freep(&bit_buffer);
2477 av_freep(&no_packet);
2479 if (output_streams) {
2480 for (i = 0; i < nb_output_streams; i++) {
2481 ost = &output_streams[i];
2483 if (ost->st->stream_copy)
2484 av_freep(&ost->st->codec->extradata);
2486 fclose(ost->logfile);
2487 ost->logfile = NULL;
2489 av_fifo_free(ost->fifo); /* works even if fifo is not
2490 initialized but set to zero */
2491 av_freep(&ost->st->codec->subtitle_header);
2492 av_free(ost->pict_tmp.data[0]);
2493 av_free(ost->forced_kf_pts);
2494 if (ost->video_resample)
2495 sws_freeContext(ost->img_resample_ctx);
2497 audio_resample_close(ost->resample);
2498 if (ost->reformat_ctx)
2499 av_audio_convert_free(ost->reformat_ctx);
2500 av_dict_free(&ost->opts);
2507 static int opt_verbose(const char *opt, const char *arg)
2509 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2513 static double parse_frame_aspect_ratio(const char *arg)
2520 p = strchr(arg, ':');
2522 x = strtol(arg, &end, 10);
2524 y = strtol(end+1, &end, 10);
2526 ar = (double)x / (double)y;
2528 ar = strtod(arg, NULL);
2531 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2537 static int opt_top_field_first(const char *opt, const char *arg)
2539 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2543 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2545 return parse_option(o, "codec:a", arg, options);
2548 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2550 return parse_option(o, "codec:v", arg, options);
2553 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2555 return parse_option(o, "codec:s", arg, options);
2558 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2560 return parse_option(o, "codec:d", arg, options);
2563 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2565 StreamMap *m = NULL;
2566 int i, negative = 0, file_idx;
2567 int sync_file_idx = -1, sync_stream_idx;
2575 map = av_strdup(arg);
2577 /* parse sync stream first, just pick first matching stream */
2578 if (sync = strchr(map, ',')) {
2580 sync_file_idx = strtol(sync + 1, &sync, 0);
2581 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2582 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2587 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2588 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2589 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2590 sync_stream_idx = i;
2593 if (i == input_files[sync_file_idx].nb_streams) {
2594 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2595 "match any streams.\n", arg);
2601 file_idx = strtol(map, &p, 0);
2602 if (file_idx >= nb_input_files || file_idx < 0) {
2603 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2607 /* disable some already defined maps */
2608 for (i = 0; i < o->nb_stream_maps; i++) {
2609 m = &o->stream_maps[i];
2610 if (check_stream_specifier(input_files[m->file_index].ctx,
2611 input_files[m->file_index].ctx->streams[m->stream_index],
2612 *p == ':' ? p + 1 : p) > 0)
2616 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2617 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2618 *p == ':' ? p + 1 : p) <= 0)
2620 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2621 &o->nb_stream_maps, o->nb_stream_maps + 1);
2622 m = &o->stream_maps[o->nb_stream_maps - 1];
2624 m->file_index = file_idx;
2625 m->stream_index = i;
2627 if (sync_file_idx >= 0) {
2628 m->sync_file_index = sync_file_idx;
2629 m->sync_stream_index = sync_stream_idx;
2631 m->sync_file_index = file_idx;
2632 m->sync_stream_index = i;
2637 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2645 static void parse_meta_type(char *arg, char *type, int *index)
2655 if (*(++arg) == ':')
2656 *index = strtol(++arg, NULL, 0);
2659 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2666 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2668 MetadataMap *m, *m1;
2671 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2672 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2674 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2675 m->file = strtol(arg, &p, 0);
2676 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2678 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2679 if (p = strchr(opt, ':'))
2680 parse_meta_type(p + 1, &m1->type, &m1->index);
2684 if (m->type == 'g' || m1->type == 'g')
2685 o->metadata_global_manual = 1;
2686 if (m->type == 's' || m1->type == 's')
2687 o->metadata_streams_manual = 1;
2688 if (m->type == 'c' || m1->type == 'c')
2689 o->metadata_chapters_manual = 1;
2694 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2696 const char *codec_string = encoder ? "encoder" : "decoder";
2700 return CODEC_ID_NONE;
2702 avcodec_find_encoder_by_name(name) :
2703 avcodec_find_decoder_by_name(name);
2705 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2708 if(codec->type != type) {
2709 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2715 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2717 char *codec_name = NULL;
2719 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2723 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2724 return avcodec_find_encoder(st->codec->codec_id);
2726 } else if (!strcmp(codec_name, "copy"))
2727 st->stream_copy = 1;
2729 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2730 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2731 avcodec_find_decoder_by_name(codec_name);
2738 * Add all the streams from the given input file to the global
2739 * list of input streams.
2741 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2743 int i, rfps, rfps_base;
2745 for (i = 0; i < ic->nb_streams; i++) {
2746 AVStream *st = ic->streams[i];
2747 AVCodecContext *dec = st->codec;
2751 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2752 ist = &input_streams[nb_input_streams - 1];
2754 ist->file_index = nb_input_files;
2756 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2758 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2759 ist->ts_scale = scale;
2761 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2763 ist->dec = avcodec_find_decoder(dec->codec_id);
2765 switch (dec->codec_type) {
2766 case AVMEDIA_TYPE_AUDIO:
2767 if (o->audio_disable)
2768 st->discard= AVDISCARD_ALL;
2770 case AVMEDIA_TYPE_VIDEO:
2771 rfps = ic->streams[i]->r_frame_rate.num;
2772 rfps_base = ic->streams[i]->r_frame_rate.den;
2774 dec->flags |= CODEC_FLAG_EMU_EDGE;
2775 dec->height >>= dec->lowres;
2776 dec->width >>= dec->lowres;
2779 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2782 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2783 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2785 (float)rfps / rfps_base, rfps, rfps_base);
2788 if (o->video_disable)
2789 st->discard= AVDISCARD_ALL;
2790 else if(video_discard)
2791 st->discard= video_discard;
2793 case AVMEDIA_TYPE_DATA:
2795 case AVMEDIA_TYPE_SUBTITLE:
2796 if (o->subtitle_disable)
2797 st->discard = AVDISCARD_ALL;
2799 case AVMEDIA_TYPE_ATTACHMENT:
2800 case AVMEDIA_TYPE_UNKNOWN:
2808 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2810 AVFormatContext *ic;
2811 AVInputFormat *file_iformat = NULL;
2815 AVDictionary **opts;
2816 int orig_nb_streams; // number of streams before avformat_find_stream_info
2819 if (!(file_iformat = av_find_input_format(o->format))) {
2820 fprintf(stderr, "Unknown input format: '%s'\n", o->format);
2825 if (!strcmp(filename, "-"))
2828 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2829 !strcmp(filename, "/dev/stdin");
2831 /* get default parameters from command line */
2832 ic = avformat_alloc_context();
2834 print_error(filename, AVERROR(ENOMEM));
2837 if (o->nb_audio_sample_rate) {
2838 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2839 av_dict_set(&format_opts, "sample_rate", buf, 0);
2841 if (o->nb_audio_channels) {
2842 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2843 av_dict_set(&format_opts, "channels", buf, 0);
2845 if (o->nb_frame_rates) {
2846 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2848 if (o->nb_frame_sizes) {
2849 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2851 if (o->nb_frame_pix_fmts)
2852 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
2854 ic->flags |= AVFMT_FLAG_NONBLOCK;
2856 /* open the input file with generic libav function */
2857 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2859 print_error(filename, err);
2862 assert_avoptions(format_opts);
2864 /* apply forced codec ids */
2865 for (i = 0; i < ic->nb_streams; i++)
2866 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
2868 /* Set AVCodecContext options for avformat_find_stream_info */
2869 opts = setup_find_stream_info_opts(ic, codec_opts);
2870 orig_nb_streams = ic->nb_streams;
2872 /* If not enough info to get the stream parameters, we decode the
2873 first frames to get it. (used in mpeg case for example) */
2874 ret = avformat_find_stream_info(ic, opts);
2875 if (ret < 0 && verbose >= 0) {
2876 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2877 av_close_input_file(ic);
2881 timestamp = o->start_time;
2882 /* add the stream start time */
2883 if (ic->start_time != AV_NOPTS_VALUE)
2884 timestamp += ic->start_time;
2886 /* if seeking requested, we execute it */
2887 if (o->start_time != 0) {
2888 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2890 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2891 filename, (double)timestamp / AV_TIME_BASE);
2895 /* update the current parameters so that they match the one of the input stream */
2896 add_input_streams(o, ic);
2898 /* dump the file content */
2900 av_dump_format(ic, nb_input_files, filename, 0);
2902 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
2903 input_files[nb_input_files - 1].ctx = ic;
2904 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
2905 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
2906 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
2908 for (i = 0; i < orig_nb_streams; i++)
2909 av_dict_free(&opts[i]);
2916 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2917 AVCodecContext *avctx)
2923 for (p = kf; *p; p++)
2926 ost->forced_kf_count = n;
2927 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2928 if (!ost->forced_kf_pts) {
2929 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2932 for (i = 0; i < n; i++) {
2933 p = i ? strchr(p, ',') + 1 : kf;
2934 t = parse_time_or_die("force_key_frames", p, 1);
2935 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2939 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
2942 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
2943 int idx = oc->nb_streams - 1;
2944 int64_t max_frames = INT64_MAX;
2945 char *bsf = NULL, *next, *codec_tag = NULL;
2946 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
2950 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
2954 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
2955 nb_output_streams + 1);
2956 ost = &output_streams[nb_output_streams - 1];
2957 ost->file_index = nb_output_files;
2960 st->codec->codec_type = type;
2961 ost->enc = choose_codec(o, oc, st, type);
2963 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
2966 avcodec_get_context_defaults3(st->codec, ost->enc);
2967 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
2969 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
2970 ost->max_frames = max_frames;
2972 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
2974 if (next = strchr(bsf, ','))
2976 if (!(bsfc = av_bitstream_filter_init(bsf))) {
2977 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter %s\n", bsf);
2981 bsfc_prev->next = bsfc;
2983 ost->bitstream_filters = bsfc;
2989 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
2991 uint32_t tag = strtol(codec_tag, &next, 0);
2993 tag = AV_RL32(codec_tag);
2994 st->codec->codec_tag = tag;
2997 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
2998 if (qscale >= 0 || same_quant) {
2999 st->codec->flags |= CODEC_FLAG_QSCALE;
3000 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3003 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3007 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3011 AVCodecContext *video_enc;
3013 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3015 if (!st->stream_copy) {
3017 ost->avfilter= vfilters;
3022 video_enc = st->codec;
3024 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3025 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3028 if (!st->stream_copy) {
3029 const char *p = NULL;
3030 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3031 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3032 int i, force_fps = 0;
3034 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3035 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3036 av_log(NULL, AV_LOG_ERROR, "Invalid framerate value: %s\n", frame_rate);
3040 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3041 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3042 av_log(NULL, AV_LOG_ERROR, "Invalid frame size: %s.\n", frame_size);
3046 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3047 if (frame_aspect_ratio)
3048 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3050 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3051 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3052 av_log(NULL, AV_LOG_ERROR, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3055 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3058 video_enc->intra_matrix = intra_matrix;
3060 video_enc->inter_matrix = inter_matrix;
3062 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3065 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3067 fprintf(stderr, "error parsing rc_override\n");
3070 video_enc->rc_override=
3071 av_realloc(video_enc->rc_override,
3072 sizeof(RcOverride)*(i+1));
3073 video_enc->rc_override[i].start_frame= start;
3074 video_enc->rc_override[i].end_frame = end;
3076 video_enc->rc_override[i].qscale= q;
3077 video_enc->rc_override[i].quality_factor= 1.0;
3080 video_enc->rc_override[i].qscale= 0;
3081 video_enc->rc_override[i].quality_factor= -q/100.0;
3086 video_enc->rc_override_count=i;
3087 if (!video_enc->rc_initial_buffer_occupancy)
3088 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3089 video_enc->intra_dc_precision= intra_dc_precision - 8;
3092 video_enc->flags|= CODEC_FLAG_PSNR;
3097 video_enc->flags |= CODEC_FLAG_PASS1;
3099 video_enc->flags |= CODEC_FLAG_PASS2;
3103 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3104 if (forced_key_frames)
3105 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3107 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3108 ost->force_fps = force_fps;
3114 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3118 AVCodecContext *audio_enc;
3120 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3123 audio_enc = st->codec;
3124 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3126 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3127 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3129 if (!st->stream_copy) {
3130 char *sample_fmt = NULL;
3132 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3134 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3136 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3137 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", sample_fmt);
3141 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3147 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3151 AVCodecContext *data_enc;
3153 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3155 data_enc = st->codec;
3156 if (!st->stream_copy) {
3157 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3161 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3162 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3168 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3172 AVCodecContext *subtitle_enc;
3174 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3176 subtitle_enc = st->codec;
3178 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3180 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3181 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3187 /* arg format is "output-stream-index:streamid-value". */
3188 static int opt_streamid(const char *opt, const char *arg)
3194 av_strlcpy(idx_str, arg, sizeof(idx_str));
3195 p = strchr(idx_str, ':');
3198 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3203 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3204 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3205 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3209 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3211 AVFormatContext *is = ifile->ctx;
3212 AVFormatContext *os = ofile->ctx;
3215 for (i = 0; i < is->nb_chapters; i++) {
3216 AVChapter *in_ch = is->chapters[i], *out_ch;
3217 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3218 AV_TIME_BASE_Q, in_ch->time_base);
3219 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3220 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3223 if (in_ch->end < ts_off)
3225 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3228 out_ch = av_mallocz(sizeof(AVChapter));
3230 return AVERROR(ENOMEM);
3232 out_ch->id = in_ch->id;
3233 out_ch->time_base = in_ch->time_base;
3234 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3235 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3238 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3241 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3243 return AVERROR(ENOMEM);
3244 os->chapters[os->nb_chapters - 1] = out_ch;
3249 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3252 AVFormatContext *ic = NULL;
3254 err = avformat_open_input(&ic, filename, NULL, NULL);
3257 /* copy stream format */
3258 for(i=0;i<ic->nb_streams;i++) {
3263 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3264 ost = new_output_stream(o, s, codec->type);
3267 // FIXME: a more elegant solution is needed
3268 memcpy(st, ic->streams[i], sizeof(AVStream));
3270 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3272 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3273 choose_sample_fmt(st, codec);
3274 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3275 choose_pixel_fmt(st, codec);
3278 av_close_input_file(ic);
3282 static void opt_output_file(void *optctx, const char *filename)
3284 OptionsContext *o = optctx;
3285 AVFormatContext *oc;
3287 AVOutputFormat *file_oformat;
3291 if (!strcmp(filename, "-"))
3294 oc = avformat_alloc_context();
3296 print_error(filename, AVERROR(ENOMEM));
3301 file_oformat = av_guess_format(o->format, NULL, NULL);
3302 if (!file_oformat) {
3303 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", o->format);
3307 file_oformat = av_guess_format(NULL, filename, NULL);
3308 if (!file_oformat) {
3309 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3315 oc->oformat = file_oformat;
3316 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3318 if (!strcmp(file_oformat->name, "ffm") &&
3319 av_strstart(filename, "http:", NULL)) {
3320 /* special case for files sent to avserver: we get the stream
3321 parameters from avserver */
3322 int err = read_avserver_streams(o, oc, filename);
3324 print_error(filename, err);
3327 } else if (!o->nb_stream_maps) {
3328 /* pick the "best" stream of each type */
3329 #define NEW_STREAM(type, index)\
3331 ost = new_ ## type ## _stream(o, oc);\
3332 ost->source_index = index;\
3333 ost->sync_ist = &input_streams[index];\
3334 input_streams[index].discard = 0;\
3337 /* video: highest resolution */
3338 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3339 int area = 0, idx = -1;
3340 for (i = 0; i < nb_input_streams; i++) {
3341 ist = &input_streams[i];
3342 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3343 ist->st->codec->width * ist->st->codec->height > area) {
3344 area = ist->st->codec->width * ist->st->codec->height;
3348 NEW_STREAM(video, idx);
3351 /* audio: most channels */
3352 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3353 int channels = 0, idx = -1;
3354 for (i = 0; i < nb_input_streams; i++) {
3355 ist = &input_streams[i];
3356 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3357 ist->st->codec->channels > channels) {
3358 channels = ist->st->codec->channels;
3362 NEW_STREAM(audio, idx);
3365 /* subtitles: pick first */
3366 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3367 for (i = 0; i < nb_input_streams; i++)
3368 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3369 NEW_STREAM(subtitle, i);
3373 /* do something with data? */
3375 for (i = 0; i < o->nb_stream_maps; i++) {
3376 StreamMap *map = &o->stream_maps[i];
3381 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3382 switch (ist->st->codec->codec_type) {
3383 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3384 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3385 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3386 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3388 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3389 map->file_index, map->stream_index);
3393 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3394 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3395 map->sync_stream_index];
3400 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3401 output_files[nb_output_files - 1].ctx = oc;
3402 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3403 output_files[nb_output_files - 1].recording_time = o->recording_time;
3404 output_files[nb_output_files - 1].start_time = o->start_time;
3405 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3406 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3408 /* check filename in case of an image number is expected */
3409 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3410 if (!av_filename_number_test(oc->filename)) {
3411 print_error(oc->filename, AVERROR(EINVAL));
3416 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3417 /* test if it already exists to avoid loosing precious files */
3418 if (!file_overwrite &&
3419 (strchr(filename, ':') == NULL ||
3420 filename[1] == ':' ||
3421 av_strstart(filename, "file:", NULL))) {
3422 if (avio_check(filename, 0) == 0) {
3424 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3426 if (!read_yesno()) {
3427 fprintf(stderr, "Not overwriting - exiting\n");
3432 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3439 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3440 print_error(filename, err);
3445 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3446 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3447 oc->flags |= AVFMT_FLAG_NONBLOCK;
3450 if (o->chapters_input_file >= nb_input_files) {
3451 if (o->chapters_input_file == INT_MAX) {
3452 /* copy chapters from the first input file that has them*/
3453 o->chapters_input_file = -1;
3454 for (i = 0; i < nb_input_files; i++)
3455 if (input_files[i].ctx->nb_chapters) {
3456 o->chapters_input_file = i;
3460 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3461 o->chapters_input_file);
3465 if (o->chapters_input_file >= 0)
3466 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3467 o->metadata_chapters_manual);
3470 for (i = 0; i < o->nb_meta_data_maps; i++) {
3471 AVFormatContext *files[2];
3472 AVDictionary **meta[2];
3475 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3476 if ((index) < 0 || (index) >= (nb_elems)) {\
3477 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3482 int in_file_index = o->meta_data_maps[i][1].file;
3483 if (in_file_index < 0)
3485 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3488 files[1] = input_files[in_file_index].ctx;
3490 for (j = 0; j < 2; j++) {
3491 MetadataMap *map = &o->meta_data_maps[i][j];
3493 switch (map->type) {
3495 meta[j] = &files[j]->metadata;
3498 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3499 meta[j] = &files[j]->streams[map->index]->metadata;
3502 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3503 meta[j] = &files[j]->chapters[map->index]->metadata;
3506 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3507 meta[j] = &files[j]->programs[map->index]->metadata;
3512 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3515 /* copy global metadata by default */
3516 if (!o->metadata_global_manual && nb_input_files)
3517 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3518 AV_DICT_DONT_OVERWRITE);
3519 if (!o->metadata_streams_manual)
3520 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3521 InputStream *ist = &input_streams[output_streams[i].source_index];
3522 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3525 /* process manually set metadata */
3526 for (i = 0; i < o->nb_metadata; i++) {
3531 val = strchr(o->metadata[i].u.str, '=');
3533 av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3534 o->metadata[i].u.str);
3539 parse_meta_type(o->metadata[i].specifier, &type, &index);
3545 if (index < 0 || index >= oc->nb_streams) {
3546 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3549 m = &oc->streams[i]->metadata;
3552 if (index < 0 || index >= oc->nb_chapters) {
3553 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3556 m = &oc->chapters[i]->metadata;
3559 av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3563 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3566 av_freep(&streamid_map);
3567 nb_streamid_map = 0;
3572 /* same option as mencoder */
3573 static int opt_pass(const char *opt, const char *arg)
3575 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3579 static int64_t getutime(void)
3582 struct rusage rusage;
3584 getrusage(RUSAGE_SELF, &rusage);
3585 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3586 #elif HAVE_GETPROCESSTIMES
3588 FILETIME c, e, k, u;
3589 proc = GetCurrentProcess();
3590 GetProcessTimes(proc, &c, &e, &k, &u);
3591 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3593 return av_gettime();
3597 static int64_t getmaxrss(void)
3599 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3600 struct rusage rusage;
3601 getrusage(RUSAGE_SELF, &rusage);
3602 return (int64_t)rusage.ru_maxrss * 1024;
3603 #elif HAVE_GETPROCESSMEMORYINFO
3605 PROCESS_MEMORY_COUNTERS memcounters;
3606 proc = GetCurrentProcess();
3607 memcounters.cb = sizeof(memcounters);
3608 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3609 return memcounters.PeakPagefileUsage;
3615 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3618 const char *p = str;
3625 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3632 static void opt_inter_matrix(const char *arg)
3634 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3635 parse_matrix_coeffs(inter_matrix, arg);
3638 static void opt_intra_matrix(const char *arg)
3640 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3641 parse_matrix_coeffs(intra_matrix, arg);
3644 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3646 return parse_option(o, "q:a", arg, options);
3649 static void show_usage(void)
3651 printf("Hyper fast Audio and Video encoder\n");
3652 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3656 static void show_help(void)
3659 AVOutputFormat *oformat = NULL;
3660 AVInputFormat *iformat = NULL;
3661 const AVClass *class;
3663 av_log_set_callback(log_callback_help);
3665 show_help_options(options, "Main options:\n",
3666 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3667 show_help_options(options, "\nAdvanced options:\n",
3668 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3670 show_help_options(options, "\nVideo options:\n",
3671 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3673 show_help_options(options, "\nAdvanced Video options:\n",
3674 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3675 OPT_VIDEO | OPT_EXPERT);
3676 show_help_options(options, "\nAudio options:\n",
3677 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3679 show_help_options(options, "\nAdvanced Audio options:\n",
3680 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3681 OPT_AUDIO | OPT_EXPERT);
3682 show_help_options(options, "\nSubtitle options:\n",
3683 OPT_SUBTITLE | OPT_GRAB,
3685 show_help_options(options, "\nAudio/Video grab options:\n",
3689 class = avcodec_get_class();
3690 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3693 /* individual codec options */
3695 while ((c = av_codec_next(c))) {
3696 if (c->priv_class) {
3697 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3702 class = avformat_get_class();
3703 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3706 /* individual muxer options */
3707 while ((oformat = av_oformat_next(oformat))) {
3708 if (oformat->priv_class) {
3709 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3714 /* individual demuxer options */
3715 while ((iformat = av_iformat_next(iformat))) {
3716 if (iformat->priv_class) {
3717 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3722 class = sws_get_class();
3723 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3726 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3728 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3729 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3731 if(!strncmp(arg, "pal-", 4)) {
3734 } else if(!strncmp(arg, "ntsc-", 5)) {
3737 } else if(!strncmp(arg, "film-", 5)) {
3741 /* Try to determine PAL/NTSC by peeking in the input files */
3742 if(nb_input_files) {
3744 for (j = 0; j < nb_input_files; j++) {
3745 for (i = 0; i < input_files[j].nb_streams; i++) {
3746 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3747 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3749 fr = c->time_base.den * 1000 / c->time_base.num;
3753 } else if((fr == 29970) || (fr == 23976)) {
3762 if(verbose > 0 && norm != UNKNOWN)
3763 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3766 if(norm == UNKNOWN) {
3767 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3768 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3769 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3773 if(!strcmp(arg, "vcd")) {
3774 opt_video_codec(o, "c:v", "mpeg1video");
3775 opt_audio_codec(o, "c:a", "mp2");
3776 parse_option(o, "f", "vcd", options);
3778 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3779 parse_option(o, "r", frame_rates[norm], options);
3780 opt_default("g", norm == PAL ? "15" : "18");
3782 opt_default("b", "1150000");
3783 opt_default("maxrate", "1150000");
3784 opt_default("minrate", "1150000");
3785 opt_default("bufsize", "327680"); // 40*1024*8;
3787 opt_default("b:a", "224000");
3788 parse_option(o, "ar", "44100", options);
3789 parse_option(o, "ac", "2", options);
3791 opt_default("packetsize", "2324");
3792 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3794 /* We have to offset the PTS, so that it is consistent with the SCR.
3795 SCR starts at 36000, but the first two packs contain only padding
3796 and the first pack from the other stream, respectively, may also have
3797 been written before.
3798 So the real data starts at SCR 36000+3*1200. */
3799 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3800 } else if(!strcmp(arg, "svcd")) {
3802 opt_video_codec(o, "c:v", "mpeg2video");
3803 opt_audio_codec(o, "c:a", "mp2");
3804 parse_option(o, "f", "svcd", options);
3806 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3807 parse_option(o, "r", frame_rates[norm], options);
3808 opt_default("g", norm == PAL ? "15" : "18");
3810 opt_default("b", "2040000");
3811 opt_default("maxrate", "2516000");
3812 opt_default("minrate", "0"); //1145000;
3813 opt_default("bufsize", "1835008"); //224*1024*8;
3814 opt_default("flags", "+scan_offset");
3817 opt_default("b:a", "224000");
3818 parse_option(o, "ar", "44100", options);
3820 opt_default("packetsize", "2324");
3822 } else if(!strcmp(arg, "dvd")) {
3824 opt_video_codec(o, "c:v", "mpeg2video");
3825 opt_audio_codec(o, "c:a", "ac3");
3826 parse_option(o, "f", "dvd", options);
3828 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3829 parse_option(o, "r", frame_rates[norm], options);
3830 opt_default("g", norm == PAL ? "15" : "18");
3832 opt_default("b", "6000000");
3833 opt_default("maxrate", "9000000");
3834 opt_default("minrate", "0"); //1500000;
3835 opt_default("bufsize", "1835008"); //224*1024*8;
3837 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3838 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3840 opt_default("b:a", "448000");
3841 parse_option(o, "ar", "48000", options);
3843 } else if(!strncmp(arg, "dv", 2)) {
3845 parse_option(o, "f", "dv", options);
3847 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3848 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3849 norm == PAL ? "yuv420p" : "yuv411p", options);
3850 parse_option(o, "r", frame_rates[norm], options);
3852 parse_option(o, "ar", "48000", options);
3853 parse_option(o, "ac", "2", options);
3856 fprintf(stderr, "Unknown target: %s\n", arg);
3857 return AVERROR(EINVAL);
3862 static int opt_vstats_file(const char *opt, const char *arg)
3864 av_free (vstats_filename);
3865 vstats_filename=av_strdup (arg);
3869 static int opt_vstats(const char *opt, const char *arg)
3872 time_t today2 = time(NULL);
3873 struct tm *today = localtime(&today2);
3875 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3877 return opt_vstats_file(opt, filename);
3880 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
3882 return parse_option(o, "frames:v", arg, options);
3885 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
3887 return parse_option(o, "frames:a", arg, options);
3890 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
3892 return parse_option(o, "frames:d", arg, options);
3895 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
3897 return parse_option(o, "tag:v", arg, options);
3900 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
3902 return parse_option(o, "tag:a", arg, options);
3905 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
3907 return parse_option(o, "tag:s", arg, options);
3910 #define OFFSET(x) offsetof(OptionsContext, x)
3911 static const OptionDef options[] = {
3913 #include "cmdutils_common_opts.h"
3914 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
3915 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
3916 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3917 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3918 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3919 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
3920 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
3921 "outfile[,metadata]:infile[,metadata]" },
3922 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
3923 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3924 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
3925 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
3926 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
3927 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
3928 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
3929 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
3930 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3931 "add timings for benchmarking" },
3932 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3933 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3934 "dump each input packet" },
3935 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3936 "when dumping packets, also dump the payload" },
3937 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
3938 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
3939 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3940 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3941 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3942 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3943 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3944 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
3945 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3946 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3947 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3948 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3949 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
3950 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
3951 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
3952 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
3955 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
3956 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3957 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
3958 { "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" },
3959 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
3960 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
3961 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3962 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
3963 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3964 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
3965 "use same quantizer as source (implies VBR)" },
3966 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
3967 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3968 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3969 "deinterlace pictures" },
3970 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
3971 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3972 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3974 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
3976 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
3977 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
3978 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
3979 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3980 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3981 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3982 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
3983 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
3984 { "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" },
3987 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
3988 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
3989 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
3990 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
3991 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
3992 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3993 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3994 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3995 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
3997 /* subtitle options */
3998 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
3999 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4000 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4003 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4006 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4007 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4009 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4011 /* data codec support */
4012 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4014 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4018 int main(int argc, char **argv)
4020 OptionsContext o = { 0 };
4025 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4027 avcodec_register_all();
4029 avdevice_register_all();
4032 avfilter_register_all();
4036 avio_set_interrupt_cb(decode_interrupt_cb);
4041 parse_options(&o, argc, argv, options, opt_output_file);
4043 if(nb_output_files <= 0 && nb_input_files == 0) {
4045 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4049 /* file converter / grab */
4050 if (nb_output_files <= 0) {
4051 fprintf(stderr, "At least one output file must be specified\n");
4055 if (nb_input_files == 0) {
4056 fprintf(stderr, "At least one input file must be specified\n");
4061 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4063 ti = getutime() - ti;
4065 int maxrss = getmaxrss() / 1024;
4066 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);