3 * Copyright (c) 2000-2011 The libav developers.
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "avconv";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
82 int disabled; /** 1 is this mapping is disabled by a negative map */
86 int sync_stream_index;
90 * select an input file for an output file
92 typedef struct MetadataMap {
93 int file; ///< file index
94 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
95 int index; ///< stream/chapter/program number
98 static const OptionDef options[];
100 static int video_discard = 0;
101 static int same_quant = 0;
102 static int do_deinterlace = 0;
103 static int intra_dc_precision = 8;
104 static int qp_hist = 0;
106 static int file_overwrite = 0;
107 static int do_benchmark = 0;
108 static int do_hex_dump = 0;
109 static int do_pkt_dump = 0;
110 static int do_pass = 0;
111 static char *pass_logfilename_prefix = NULL;
112 static int video_sync_method= -1;
113 static int audio_sync_method= 0;
114 static float audio_drift_threshold= 0.1;
115 static int copy_ts= 0;
117 static int opt_shortest = 0;
118 static char *vstats_filename;
119 static FILE *vstats_file;
120 static int copy_initial_nonkeyframes = 0;
122 static int audio_volume = 256;
124 static int exit_on_error = 0;
125 static int using_stdin = 0;
126 static int64_t video_size = 0;
127 static int64_t audio_size = 0;
128 static int64_t extra_size = 0;
129 static int nb_frames_dup = 0;
130 static int nb_frames_drop = 0;
131 static int input_sync;
133 static float dts_delta_threshold = 10;
135 static uint8_t *audio_buf;
136 static uint8_t *audio_out;
137 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
139 static short *samples;
141 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
143 typedef struct InputStream {
146 int discard; /* true if stream data should be discarded */
147 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
150 int64_t start; /* time when read started */
151 int64_t next_pts; /* synthetic pts for cases where pkt.pts
153 int64_t pts; /* current pts */
154 PtsCorrectionContext pts_ctx;
156 int is_start; /* is 1 at the start and after a discontinuity */
157 int showed_multi_packet_warning;
161 typedef struct InputFile {
162 AVFormatContext *ctx;
163 int eof_reached; /* true if eof reached */
164 int ist_index; /* index of first stream in ist_table */
165 int buffer_size; /* current total buffer size */
167 int nb_streams; /* number of stream that avconv is aware of; may be different
168 from ctx.nb_streams if new streams appear during av_read_frame() */
172 typedef struct OutputStream {
173 int file_index; /* file index */
174 int index; /* stream index in the output file */
175 int source_index; /* InputStream index */
176 AVStream *st; /* stream in the output file */
177 int encoding_needed; /* true if encoding needed for this stream */
179 /* input pts and corresponding output pts
181 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
182 struct InputStream *sync_ist; /* input stream to sync against */
183 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
184 AVBitStreamFilterContext *bitstream_filters;
190 AVFrame pict_tmp; /* temporary image for resampling */
191 struct SwsContext *img_resample_ctx; /* for image resampling */
194 int resample_pix_fmt;
195 AVRational frame_rate;
199 float frame_aspect_ratio;
201 /* forced key frames */
202 int64_t *forced_kf_pts;
208 ReSampleContext *resample; /* for audio resampling */
209 int resample_sample_fmt;
210 int resample_channels;
211 int resample_sample_rate;
213 AVAudioConvert *reformat_ctx;
214 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
218 AVFilterContext *output_video_filter;
219 AVFilterContext *input_video_filter;
220 AVFilterBufferRef *picref;
222 AVFilterGraph *graph;
227 int is_past_recording_time;
231 typedef struct OutputFile {
232 AVFormatContext *ctx;
234 int ost_index; /* index of the first stream in output_streams */
235 int64_t recording_time; /* desired length of the resulting file in microseconds */
236 int64_t start_time; /* start time in microseconds */
237 uint64_t limit_filesize;
240 static InputStream *input_streams = NULL;
241 static int nb_input_streams = 0;
242 static InputFile *input_files = NULL;
243 static int nb_input_files = 0;
245 static OutputStream *output_streams = NULL;
246 static int nb_output_streams = 0;
247 static OutputFile *output_files = NULL;
248 static int nb_output_files = 0;
250 typedef struct OptionsContext {
251 /* input/output options */
255 SpecifierOpt *codec_names;
257 SpecifierOpt *audio_channels;
258 int nb_audio_channels;
259 SpecifierOpt *audio_sample_rate;
260 int nb_audio_sample_rate;
261 SpecifierOpt *frame_rates;
263 SpecifierOpt *frame_sizes;
265 SpecifierOpt *frame_pix_fmts;
266 int nb_frame_pix_fmts;
269 int64_t input_ts_offset;
272 SpecifierOpt *ts_scale;
276 StreamMap *stream_maps;
278 /* first item specifies output metadata, second is input */
279 MetadataMap (*meta_data_maps)[2];
280 int nb_meta_data_maps;
281 int metadata_global_manual;
282 int metadata_streams_manual;
283 int metadata_chapters_manual;
285 int chapters_input_file;
287 int64_t recording_time;
288 uint64_t limit_filesize;
294 int subtitle_disable;
297 /* indexed by output file stream index */
301 SpecifierOpt *metadata;
303 SpecifierOpt *max_frames;
305 SpecifierOpt *bitstream_filters;
306 int nb_bitstream_filters;
307 SpecifierOpt *codec_tags;
309 SpecifierOpt *sample_fmts;
311 SpecifierOpt *qscale;
313 SpecifierOpt *forced_key_frames;
314 int nb_forced_key_frames;
315 SpecifierOpt *force_fps;
317 SpecifierOpt *frame_aspect_ratios;
318 int nb_frame_aspect_ratios;
319 SpecifierOpt *rc_overrides;
321 SpecifierOpt *intra_matrices;
322 int nb_intra_matrices;
323 SpecifierOpt *inter_matrices;
324 int nb_inter_matrices;
325 SpecifierOpt *top_field_first;
326 int nb_top_field_first;
328 SpecifierOpt *filters;
333 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
336 for (i = 0; i < o->nb_ ## name; i++) {\
337 char *spec = o->name[i].specifier;\
338 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
339 outvar = o->name[i].u.type;\
345 static void reset_options(OptionsContext *o)
347 const OptionDef *po = options;
349 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
351 void *dst = (uint8_t*)o + po->u.off;
353 if (po->flags & OPT_SPEC) {
354 SpecifierOpt **so = dst;
355 int i, *count = (int*)(so + 1);
356 for (i = 0; i < *count; i++) {
357 av_freep(&(*so)[i].specifier);
358 if (po->flags & OPT_STRING)
359 av_freep(&(*so)[i].u.str);
363 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
368 av_freep(&o->stream_maps);
369 av_freep(&o->meta_data_maps);
370 av_freep(&o->streamid_map);
372 memset(o, 0, sizeof(*o));
374 o->mux_preload = 0.5;
375 o->mux_max_delay = 0.7;
376 o->recording_time = INT64_MAX;
377 o->limit_filesize = UINT64_MAX;
378 o->chapters_input_file = INT_MAX;
386 static int configure_video_filters(InputStream *ist, OutputStream *ost)
388 AVFilterContext *last_filter, *filter;
389 /** filter graph containing all filters including input & output */
390 AVCodecContext *codec = ost->st->codec;
391 AVCodecContext *icodec = ist->st->codec;
392 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
393 AVRational sample_aspect_ratio;
397 ost->graph = avfilter_graph_alloc();
399 if (ist->st->sample_aspect_ratio.num){
400 sample_aspect_ratio = ist->st->sample_aspect_ratio;
402 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
404 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
405 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
406 sample_aspect_ratio.num, sample_aspect_ratio.den);
408 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
409 "src", args, NULL, ost->graph);
412 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
413 "out", NULL, &ffsink_ctx, ost->graph);
416 last_filter = ost->input_video_filter;
418 if (codec->width != icodec->width || codec->height != icodec->height) {
419 snprintf(args, 255, "%d:%d:flags=0x%X",
423 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
424 NULL, args, NULL, ost->graph)) < 0)
426 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
428 last_filter = filter;
431 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
432 ost->graph->scale_sws_opts = av_strdup(args);
435 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
436 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
438 outputs->name = av_strdup("in");
439 outputs->filter_ctx = last_filter;
440 outputs->pad_idx = 0;
441 outputs->next = NULL;
443 inputs->name = av_strdup("out");
444 inputs->filter_ctx = ost->output_video_filter;
448 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
450 av_freep(&ost->avfilter);
452 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
456 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
459 codec->width = ost->output_video_filter->inputs[0]->w;
460 codec->height = ost->output_video_filter->inputs[0]->h;
461 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
462 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
463 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
464 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
468 #endif /* CONFIG_AVFILTER */
470 static void term_exit(void)
472 av_log(NULL, AV_LOG_QUIET, "");
475 static volatile int received_sigterm = 0;
476 static volatile int received_nb_signals = 0;
479 sigterm_handler(int sig)
481 received_sigterm = sig;
482 received_nb_signals++;
486 static void term_init(void)
488 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
489 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
491 signal(SIGXCPU, sigterm_handler);
495 static int decode_interrupt_cb(void)
497 return received_nb_signals > 1;
500 void exit_program(int ret)
505 for(i=0;i<nb_output_files;i++) {
506 AVFormatContext *s = output_files[i].ctx;
507 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
509 avformat_free_context(s);
510 av_dict_free(&output_files[i].opts);
512 for(i=0;i<nb_input_files;i++) {
513 av_close_input_file(input_files[i].ctx);
515 for (i = 0; i < nb_input_streams; i++)
516 av_dict_free(&input_streams[i].opts);
520 av_free(vstats_filename);
522 av_freep(&input_streams);
523 av_freep(&input_files);
524 av_freep(&output_streams);
525 av_freep(&output_files);
530 allocated_audio_buf_size= allocated_audio_out_size= 0;
537 if (received_sigterm) {
538 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
539 (int) received_sigterm);
543 exit(ret); /* not all OS-es handle main() return value */
546 static void assert_avoptions(AVDictionary *m)
548 AVDictionaryEntry *t;
549 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
550 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
555 static void assert_codec_experimental(AVCodecContext *c, int encoder)
557 const char *codec_string = encoder ? "encoder" : "decoder";
559 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
560 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
561 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
562 "results.\nAdd '-strict experimental' if you want to use it.\n",
563 codec_string, c->codec->name);
564 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
565 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
566 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
567 codec_string, codec->name);
572 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
574 if(codec && codec->sample_fmts){
575 const enum AVSampleFormat *p= codec->sample_fmts;
577 if(*p == st->codec->sample_fmt)
581 av_log(NULL, AV_LOG_WARNING,
582 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
583 av_get_sample_fmt_name(st->codec->sample_fmt),
585 av_get_sample_fmt_name(codec->sample_fmts[0]));
586 st->codec->sample_fmt = codec->sample_fmts[0];
592 * Update the requested input sample format based on the output sample format.
593 * This is currently only used to request float output from decoders which
594 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
595 * Ideally this will be removed in the future when decoders do not do format
596 * conversion and only output in their native format.
598 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
601 /* if sample formats match or a decoder sample format has already been
602 requested, just return */
603 if (enc->sample_fmt == dec->sample_fmt ||
604 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
607 /* if decoder supports more than one output format */
608 if (dec_codec && dec_codec->sample_fmts &&
609 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
610 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
611 const enum AVSampleFormat *p;
612 int min_dec = -1, min_inc = -1;
614 /* find a matching sample format in the encoder */
615 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
616 if (*p == enc->sample_fmt) {
617 dec->request_sample_fmt = *p;
619 } else if (*p > enc->sample_fmt) {
620 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
622 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
625 /* if none match, provide the one that matches quality closest */
626 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
627 enc->sample_fmt - min_dec;
631 static void choose_sample_rate(AVStream *st, AVCodec *codec)
633 if(codec && codec->supported_samplerates){
634 const int *p= codec->supported_samplerates;
636 int best_dist=INT_MAX;
638 int dist= abs(st->codec->sample_rate - *p);
639 if(dist < best_dist){
645 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
647 st->codec->sample_rate= best;
651 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
653 if(codec && codec->pix_fmts){
654 const enum PixelFormat *p= codec->pix_fmts;
655 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
656 if(st->codec->codec_id==CODEC_ID_MJPEG){
657 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
658 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
659 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
663 if(*p == st->codec->pix_fmt)
667 if(st->codec->pix_fmt != PIX_FMT_NONE)
668 av_log(NULL, AV_LOG_WARNING,
669 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
670 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
672 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
673 st->codec->pix_fmt = codec->pix_fmts[0];
679 get_sync_ipts(const OutputStream *ost)
681 const InputStream *ist = ost->sync_ist;
682 OutputFile *of = &output_files[ost->file_index];
683 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
686 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
690 AVPacket new_pkt= *pkt;
691 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
692 &new_pkt.data, &new_pkt.size,
693 pkt->data, pkt->size,
694 pkt->flags & AV_PKT_FLAG_KEY);
697 new_pkt.destruct= av_destruct_packet;
699 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
700 bsfc->filter->name, pkt->stream_index,
701 avctx->codec ? avctx->codec->name : "copy");
711 ret= av_interleaved_write_frame(s, pkt);
713 print_error("av_interleaved_write_frame()", ret);
718 static void do_audio_out(AVFormatContext *s,
721 unsigned char *buf, int size)
724 int64_t audio_out_size, audio_buf_size;
725 int64_t allocated_for_size= size;
727 int size_out, frame_bytes, ret, resample_changed;
728 AVCodecContext *enc= ost->st->codec;
729 AVCodecContext *dec= ist->st->codec;
730 int osize = av_get_bytes_per_sample(enc->sample_fmt);
731 int isize = av_get_bytes_per_sample(dec->sample_fmt);
732 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
735 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
736 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
737 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
738 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
739 audio_buf_size*= osize*enc->channels;
741 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
742 if(coded_bps > 8*osize)
743 audio_out_size= audio_out_size * coded_bps / (8*osize);
744 audio_out_size += FF_MIN_BUFFER_SIZE;
746 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
747 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
751 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
752 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
753 if (!audio_buf || !audio_out){
754 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
758 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
759 ost->audio_resample = 1;
761 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
762 ost->resample_channels != dec->channels ||
763 ost->resample_sample_rate != dec->sample_rate;
765 if ((ost->audio_resample && !ost->resample) || resample_changed) {
766 if (resample_changed) {
767 av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
768 ist->file_index, ist->st->index,
769 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
770 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
771 ost->resample_sample_fmt = dec->sample_fmt;
772 ost->resample_channels = dec->channels;
773 ost->resample_sample_rate = dec->sample_rate;
775 audio_resample_close(ost->resample);
777 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
778 if (audio_sync_method <= 1 &&
779 ost->resample_sample_fmt == enc->sample_fmt &&
780 ost->resample_channels == enc->channels &&
781 ost->resample_sample_rate == enc->sample_rate) {
782 ost->resample = NULL;
783 ost->audio_resample = 0;
784 } else if (ost->audio_resample) {
785 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
786 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
787 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
788 enc->sample_rate, dec->sample_rate,
789 enc->sample_fmt, dec->sample_fmt,
791 if (!ost->resample) {
792 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
793 dec->channels, dec->sample_rate,
794 enc->channels, enc->sample_rate);
800 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
801 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
802 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
803 if (ost->reformat_ctx)
804 av_audio_convert_free(ost->reformat_ctx);
805 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
806 dec->sample_fmt, 1, NULL, 0);
807 if (!ost->reformat_ctx) {
808 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
809 av_get_sample_fmt_name(dec->sample_fmt),
810 av_get_sample_fmt_name(enc->sample_fmt));
813 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
816 if(audio_sync_method){
817 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
818 - av_fifo_size(ost->fifo)/(enc->channels * 2);
819 double idelta= delta*dec->sample_rate / enc->sample_rate;
820 int byte_delta= ((int)idelta)*2*dec->channels;
822 //FIXME resample delay
823 if(fabs(delta) > 50){
824 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
826 byte_delta= FFMAX(byte_delta, -size);
829 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
834 static uint8_t *input_tmp= NULL;
835 input_tmp= av_realloc(input_tmp, byte_delta + size);
837 if(byte_delta > allocated_for_size - size){
838 allocated_for_size= byte_delta + (int64_t)size;
843 memset(input_tmp, 0, byte_delta);
844 memcpy(input_tmp + byte_delta, buf, size);
847 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
849 }else if(audio_sync_method>1){
850 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
851 av_assert0(ost->audio_resample);
852 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
853 delta, comp, enc->sample_rate);
854 // fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
855 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
859 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
860 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
862 if (ost->audio_resample) {
864 size_out = audio_resample(ost->resample,
865 (short *)buftmp, (short *)buf,
866 size / (dec->channels * isize));
867 size_out = size_out * enc->channels * osize;
873 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
874 const void *ibuf[6]= {buftmp};
875 void *obuf[6]= {audio_buf};
876 int istride[6]= {isize};
877 int ostride[6]= {osize};
878 int len= size_out/istride[0];
879 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
880 printf("av_audio_convert() failed\n");
886 size_out = len*osize;
889 /* now encode as many frames as possible */
890 if (enc->frame_size > 1) {
891 /* output resampled raw samples */
892 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
893 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
896 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
898 frame_bytes = enc->frame_size * osize * enc->channels;
900 while (av_fifo_size(ost->fifo) >= frame_bytes) {
902 av_init_packet(&pkt);
904 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
906 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
908 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
911 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
915 pkt.stream_index= ost->index;
918 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
919 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
920 pkt.flags |= AV_PKT_FLAG_KEY;
921 write_frame(s, &pkt, enc, ost->bitstream_filters);
923 ost->sync_opts += enc->frame_size;
927 av_init_packet(&pkt);
929 ost->sync_opts += size_out / (osize * enc->channels);
931 /* output a pcm frame */
932 /* determine the size of the coded buffer */
935 size_out = size_out*coded_bps/8;
937 if(size_out > audio_out_size){
938 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
942 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
943 ret = avcodec_encode_audio(enc, audio_out, size_out,
946 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
950 pkt.stream_index= ost->index;
953 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
954 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
955 pkt.flags |= AV_PKT_FLAG_KEY;
956 write_frame(s, &pkt, enc, ost->bitstream_filters);
960 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
964 AVPicture picture_tmp;
967 dec = ist->st->codec;
969 /* deinterlace : must be done before any resize */
970 if (do_deinterlace) {
973 /* create temporary picture */
974 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
975 buf = av_malloc(size);
979 picture2 = &picture_tmp;
980 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
982 if(avpicture_deinterlace(picture2, picture,
983 dec->pix_fmt, dec->width, dec->height) < 0) {
984 /* if error, do not deinterlace */
985 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
994 if (picture != picture2)
995 *picture = *picture2;
999 static void do_subtitle_out(AVFormatContext *s,
1005 static uint8_t *subtitle_out = NULL;
1006 int subtitle_out_max_size = 1024 * 1024;
1007 int subtitle_out_size, nb, i;
1008 AVCodecContext *enc;
1011 if (pts == AV_NOPTS_VALUE) {
1012 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1018 enc = ost->st->codec;
1020 if (!subtitle_out) {
1021 subtitle_out = av_malloc(subtitle_out_max_size);
1024 /* Note: DVB subtitle need one packet to draw them and one other
1025 packet to clear them */
1026 /* XXX: signal it in the codec context ? */
1027 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1032 for(i = 0; i < nb; i++) {
1033 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1034 // start_display_time is required to be 0
1035 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1036 sub->end_display_time -= sub->start_display_time;
1037 sub->start_display_time = 0;
1038 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1039 subtitle_out_max_size, sub);
1040 if (subtitle_out_size < 0) {
1041 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1045 av_init_packet(&pkt);
1046 pkt.stream_index = ost->index;
1047 pkt.data = subtitle_out;
1048 pkt.size = subtitle_out_size;
1049 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1050 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1051 /* XXX: the pts correction is handled here. Maybe handling
1052 it in the codec would be better */
1054 pkt.pts += 90 * sub->start_display_time;
1056 pkt.pts += 90 * sub->end_display_time;
1058 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1062 static int bit_buffer_size= 1024*256;
1063 static uint8_t *bit_buffer= NULL;
1065 static void do_video_resample(OutputStream *ost,
1067 AVFrame *in_picture,
1068 AVFrame **out_picture)
1070 int resample_changed = 0;
1071 AVCodecContext *dec = ist->st->codec;
1072 *out_picture = in_picture;
1074 resample_changed = ost->resample_width != dec->width ||
1075 ost->resample_height != dec->height ||
1076 ost->resample_pix_fmt != dec->pix_fmt;
1078 if (resample_changed) {
1079 av_log(NULL, AV_LOG_INFO,
1080 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1081 ist->file_index, ist->st->index,
1082 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1083 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1084 if(!ost->video_resample)
1085 ost->video_resample = 1;
1088 #if !CONFIG_AVFILTER
1089 if (ost->video_resample) {
1090 *out_picture = &ost->pict_tmp;
1091 if (resample_changed) {
1092 /* initialize a new scaler context */
1093 sws_freeContext(ost->img_resample_ctx);
1094 ost->img_resample_ctx = sws_getContext(
1095 ist->st->codec->width,
1096 ist->st->codec->height,
1097 ist->st->codec->pix_fmt,
1098 ost->st->codec->width,
1099 ost->st->codec->height,
1100 ost->st->codec->pix_fmt,
1101 ost->sws_flags, NULL, NULL, NULL);
1102 if (ost->img_resample_ctx == NULL) {
1103 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1107 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1108 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1111 if (resample_changed) {
1112 avfilter_graph_free(&ost->graph);
1113 if (configure_video_filters(ist, ost)) {
1114 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1119 if (resample_changed) {
1120 ost->resample_width = dec->width;
1121 ost->resample_height = dec->height;
1122 ost->resample_pix_fmt = dec->pix_fmt;
1127 static void do_video_out(AVFormatContext *s,
1130 AVFrame *in_picture,
1131 int *frame_size, float quality)
1133 int nb_frames, i, ret, format_video_sync;
1134 AVFrame *final_picture;
1135 AVCodecContext *enc;
1138 enc = ost->st->codec;
1140 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1142 /* by default, we output a single frame */
1147 format_video_sync = video_sync_method;
1148 if (format_video_sync < 0)
1149 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1151 if (format_video_sync) {
1152 double vdelta = sync_ipts - ost->sync_opts;
1153 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1156 else if (format_video_sync == 2) {
1159 }else if(vdelta>0.6)
1160 ost->sync_opts= lrintf(sync_ipts);
1161 }else if (vdelta > 1.1)
1162 nb_frames = lrintf(vdelta);
1163 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1164 if (nb_frames == 0){
1166 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1167 }else if (nb_frames > 1) {
1168 nb_frames_dup += nb_frames - 1;
1169 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1172 ost->sync_opts= lrintf(sync_ipts);
1174 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1178 do_video_resample(ost, ist, in_picture, &final_picture);
1180 /* duplicates frame if needed */
1181 for(i=0;i<nb_frames;i++) {
1183 av_init_packet(&pkt);
1184 pkt.stream_index= ost->index;
1186 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1187 /* raw pictures are written as AVPicture structure to
1188 avoid any copies. We support temporarily the older
1190 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1191 enc->coded_frame->top_field_first = in_picture->top_field_first;
1192 pkt.data= (uint8_t *)final_picture;
1193 pkt.size= sizeof(AVPicture);
1194 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1195 pkt.flags |= AV_PKT_FLAG_KEY;
1197 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1199 AVFrame big_picture;
1201 big_picture= *final_picture;
1202 /* better than nothing: use input picture interlaced
1204 big_picture.interlaced_frame = in_picture->interlaced_frame;
1205 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1206 if (ost->top_field_first == -1)
1207 big_picture.top_field_first = in_picture->top_field_first;
1209 big_picture.top_field_first = !!ost->top_field_first;
1212 /* handles same_quant here. This is not correct because it may
1213 not be a global option */
1214 big_picture.quality = quality;
1215 if (!enc->me_threshold)
1216 big_picture.pict_type = 0;
1217 // big_picture.pts = AV_NOPTS_VALUE;
1218 big_picture.pts= ost->sync_opts;
1219 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1220 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1221 if (ost->forced_kf_index < ost->forced_kf_count &&
1222 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1223 big_picture.pict_type = AV_PICTURE_TYPE_I;
1224 ost->forced_kf_index++;
1226 ret = avcodec_encode_video(enc,
1227 bit_buffer, bit_buffer_size,
1230 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1235 pkt.data= bit_buffer;
1237 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1238 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1239 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1240 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1241 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1243 if(enc->coded_frame->key_frame)
1244 pkt.flags |= AV_PKT_FLAG_KEY;
1245 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1248 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1249 // enc->frame_number-1, ret, enc->pict_type);
1250 /* if two pass, output log */
1251 if (ost->logfile && enc->stats_out) {
1252 fprintf(ost->logfile, "%s", enc->stats_out);
1257 ost->frame_number++;
1261 static double psnr(double d){
1262 return -10.0*log(d)/log(10.0);
1265 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1268 AVCodecContext *enc;
1270 double ti1, bitrate, avg_bitrate;
1272 /* this is executed just the first time do_video_stats is called */
1274 vstats_file = fopen(vstats_filename, "w");
1281 enc = ost->st->codec;
1282 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1283 frame_number = ost->frame_number;
1284 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1285 if (enc->flags&CODEC_FLAG_PSNR)
1286 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1288 fprintf(vstats_file,"f_size= %6d ", frame_size);
1289 /* compute pts value */
1290 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1294 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1295 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1296 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1297 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1298 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1302 static void print_report(OutputFile *output_files,
1303 OutputStream *ost_table, int nb_ostreams,
1304 int is_last_report, int64_t timer_start)
1308 AVFormatContext *oc;
1310 AVCodecContext *enc;
1311 int frame_number, vid, i;
1312 double bitrate, ti1, pts;
1313 static int64_t last_time = -1;
1314 static int qp_histogram[52];
1316 if (!is_last_report) {
1318 /* display the report every 0.5 seconds */
1319 cur_time = av_gettime();
1320 if (last_time == -1) {
1321 last_time = cur_time;
1324 if ((cur_time - last_time) < 500000)
1326 last_time = cur_time;
1330 oc = output_files[0].ctx;
1332 total_size = avio_size(oc->pb);
1333 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1334 total_size= avio_tell(oc->pb);
1339 for(i=0;i<nb_ostreams;i++) {
1341 ost = &ost_table[i];
1342 enc = ost->st->codec;
1343 if (!ost->st->stream_copy && enc->coded_frame)
1344 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1345 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1346 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1348 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1349 float t = (av_gettime()-timer_start) / 1000000.0;
1351 frame_number = ost->frame_number;
1352 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1353 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1355 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1359 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1362 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1364 if (enc->flags&CODEC_FLAG_PSNR){
1366 double error, error_sum=0;
1367 double scale, scale_sum=0;
1368 char type[3]= {'Y','U','V'};
1369 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1372 error= enc->error[j];
1373 scale= enc->width*enc->height*255.0*255.0*frame_number;
1375 error= enc->coded_frame->error[j];
1376 scale= enc->width*enc->height*255.0*255.0;
1381 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1383 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1387 /* compute min output value */
1388 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1389 if ((pts < ti1) && (pts > 0))
1395 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1397 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1398 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1399 (double)total_size / 1024, ti1, bitrate);
1401 if (nb_frames_dup || nb_frames_drop)
1402 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1403 nb_frames_dup, nb_frames_drop);
1405 av_log(NULL, is_last_report ? AV_LOG_WARNING : AV_LOG_INFO, "%s \r", buf);
1409 if (is_last_report) {
1410 int64_t raw= audio_size + video_size + extra_size;
1411 av_log(NULL, AV_LOG_INFO, "\n");
1412 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1416 100.0*(total_size - raw)/raw
1421 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1423 int fill_char = 0x00;
1424 if (sample_fmt == AV_SAMPLE_FMT_U8)
1426 memset(buf, fill_char, size);
1429 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1433 for (i = 0; i < nb_ostreams; i++) {
1434 OutputStream *ost = &ost_table[i];
1435 AVCodecContext *enc = ost->st->codec;
1436 AVFormatContext *os = output_files[ost->file_index].ctx;
1438 if (!ost->encoding_needed)
1441 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1443 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1449 av_init_packet(&pkt);
1450 pkt.stream_index= ost->index;
1452 switch (ost->st->codec->codec_type) {
1453 case AVMEDIA_TYPE_AUDIO:
1454 fifo_bytes = av_fifo_size(ost->fifo);
1456 /* encode any samples remaining in fifo */
1457 if (fifo_bytes > 0) {
1458 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1459 int fs_tmp = enc->frame_size;
1461 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1462 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1463 enc->frame_size = fifo_bytes / (osize * enc->channels);
1465 int frame_bytes = enc->frame_size*osize*enc->channels;
1466 if (allocated_audio_buf_size < frame_bytes)
1468 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1471 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1472 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1473 ost->st->time_base.num, enc->sample_rate);
1474 enc->frame_size = fs_tmp;
1477 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1480 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1484 pkt.flags |= AV_PKT_FLAG_KEY;
1486 case AVMEDIA_TYPE_VIDEO:
1487 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1489 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1493 if(enc->coded_frame && enc->coded_frame->key_frame)
1494 pkt.flags |= AV_PKT_FLAG_KEY;
1495 if (ost->logfile && enc->stats_out) {
1496 fprintf(ost->logfile, "%s", enc->stats_out);
1505 pkt.data = bit_buffer;
1507 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1508 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1509 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1514 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1515 static int output_packet(InputStream *ist, int ist_index,
1516 OutputStream *ost_table, int nb_ostreams,
1517 const AVPacket *pkt)
1519 AVFormatContext *os;
1524 void *buffer_to_free = NULL;
1525 static unsigned int samples_size= 0;
1526 AVSubtitle subtitle, *subtitle_to_free;
1527 int64_t pkt_pts = AV_NOPTS_VALUE;
1529 int frame_available;
1534 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1536 if(ist->next_pts == AV_NOPTS_VALUE)
1537 ist->next_pts= ist->pts;
1541 av_init_packet(&avpkt);
1549 if(pkt->dts != AV_NOPTS_VALUE)
1550 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1551 if(pkt->pts != AV_NOPTS_VALUE)
1552 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1554 //while we have more to decode or while the decoder did output something on EOF
1555 while (avpkt.size > 0 || (!pkt && got_output)) {
1556 uint8_t *data_buf, *decoded_data_buf;
1557 int data_size, decoded_data_size;
1559 ist->pts= ist->next_pts;
1561 if(avpkt.size && avpkt.size != pkt->size)
1562 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1563 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1564 ist->showed_multi_packet_warning=1;
1566 /* decode the packet if needed */
1567 decoded_data_buf = NULL; /* fail safe */
1568 decoded_data_size= 0;
1569 data_buf = avpkt.data;
1570 data_size = avpkt.size;
1571 subtitle_to_free = NULL;
1572 if (ist->decoding_needed) {
1573 switch(ist->st->codec->codec_type) {
1574 case AVMEDIA_TYPE_AUDIO:{
1575 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1576 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1578 samples= av_malloc(samples_size);
1580 decoded_data_size= samples_size;
1581 /* XXX: could avoid copy if PCM 16 bits with same
1582 endianness as CPU */
1583 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1590 got_output = decoded_data_size > 0;
1591 /* Some bug in mpeg audio decoder gives */
1592 /* decoded_data_size < 0, it seems they are overflows */
1594 /* no audio frame */
1597 decoded_data_buf = (uint8_t *)samples;
1598 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1599 (ist->st->codec->sample_rate * ist->st->codec->channels);
1601 case AVMEDIA_TYPE_VIDEO:
1602 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1603 /* XXX: allocate picture correctly */
1604 avcodec_get_frame_defaults(&picture);
1605 avpkt.pts = pkt_pts;
1606 avpkt.dts = ist->pts;
1607 pkt_pts = AV_NOPTS_VALUE;
1609 ret = avcodec_decode_video2(ist->st->codec,
1610 &picture, &got_output, &avpkt);
1611 quality = same_quant ? picture.quality : 0;
1615 /* no picture yet */
1616 goto discard_packet;
1618 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1619 if (ist->st->codec->time_base.num != 0) {
1620 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1621 ist->next_pts += ((int64_t)AV_TIME_BASE *
1622 ist->st->codec->time_base.num * ticks) /
1623 ist->st->codec->time_base.den;
1626 buffer_to_free = NULL;
1627 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1629 case AVMEDIA_TYPE_SUBTITLE:
1630 ret = avcodec_decode_subtitle2(ist->st->codec,
1631 &subtitle, &got_output, &avpkt);
1635 goto discard_packet;
1637 subtitle_to_free = &subtitle;
1644 switch(ist->st->codec->codec_type) {
1645 case AVMEDIA_TYPE_AUDIO:
1646 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1647 ist->st->codec->sample_rate;
1649 case AVMEDIA_TYPE_VIDEO:
1650 if (ist->st->codec->time_base.num != 0) {
1651 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1652 ist->next_pts += ((int64_t)AV_TIME_BASE *
1653 ist->st->codec->time_base.num * ticks) /
1654 ist->st->codec->time_base.den;
1661 // preprocess audio (volume)
1662 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1663 if (audio_volume != 256) {
1666 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1667 int v = ((*volp) * audio_volume + 128) >> 8;
1668 *volp++ = av_clip_int16(v);
1673 /* frame rate emulation */
1674 if (input_files[ist->file_index].rate_emu) {
1675 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1676 int64_t now = av_gettime() - ist->start;
1680 /* if output time reached then transcode raw format,
1681 encode packets and output them */
1682 for (i = 0; i < nb_ostreams; i++) {
1683 OutputFile *of = &output_files[ost_table[i].file_index];
1686 ost = &ost_table[i];
1687 if (ost->source_index != ist_index)
1690 if (of->start_time && ist->pts < of->start_time)
1693 if (of->recording_time != INT64_MAX &&
1694 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1695 (AVRational){1, 1000000}) >= 0) {
1696 ost->is_past_recording_time = 1;
1701 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1702 ost->input_video_filter) {
1704 if (ist->st->sample_aspect_ratio.num)
1705 sar = ist->st->sample_aspect_ratio;
1707 sar = ist->st->codec->sample_aspect_ratio;
1708 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, ist->pts, sar);
1710 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1711 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1712 while (frame_available) {
1713 AVRational ist_pts_tb;
1714 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1715 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1717 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1719 os = output_files[ost->file_index].ctx;
1721 /* set the input output pts pairs */
1722 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1724 if (ost->encoding_needed) {
1725 av_assert0(ist->decoding_needed);
1726 switch(ost->st->codec->codec_type) {
1727 case AVMEDIA_TYPE_AUDIO:
1728 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1730 case AVMEDIA_TYPE_VIDEO:
1732 if (ost->picref->video && !ost->frame_aspect_ratio)
1733 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1735 do_video_out(os, ost, ist, &picture, &frame_size,
1736 same_quant ? quality : ost->st->codec->global_quality);
1737 if (vstats_filename && frame_size)
1738 do_video_stats(os, ost, frame_size);
1740 case AVMEDIA_TYPE_SUBTITLE:
1741 do_subtitle_out(os, ost, ist, &subtitle,
1749 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1751 av_init_packet(&opkt);
1753 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1754 #if !CONFIG_AVFILTER
1760 /* no reencoding needed : output the packet directly */
1761 /* force the input stream PTS */
1763 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1764 audio_size += data_size;
1765 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1766 video_size += data_size;
1770 opkt.stream_index= ost->index;
1771 if(pkt->pts != AV_NOPTS_VALUE)
1772 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1774 opkt.pts= AV_NOPTS_VALUE;
1776 if (pkt->dts == AV_NOPTS_VALUE)
1777 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1779 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1780 opkt.dts -= ost_tb_start_time;
1782 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1783 opkt.flags= pkt->flags;
1785 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1786 if( ost->st->codec->codec_id != CODEC_ID_H264
1787 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1788 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1790 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1791 opkt.destruct= av_destruct_packet;
1793 opkt.data = data_buf;
1794 opkt.size = data_size;
1797 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1798 ost->st->codec->frame_number++;
1799 ost->frame_number++;
1800 av_free_packet(&opkt);
1804 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1805 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1807 avfilter_unref_buffer(ost->picref);
1812 av_free(buffer_to_free);
1813 /* XXX: allocate the subtitles in the codec ? */
1814 if (subtitle_to_free) {
1815 avsubtitle_free(subtitle_to_free);
1816 subtitle_to_free = NULL;
1824 static void print_sdp(OutputFile *output_files, int n)
1828 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1832 for (i = 0; i < n; i++)
1833 avc[i] = output_files[i].ctx;
1835 av_sdp_create(avc, n, sdp, sizeof(sdp));
1836 printf("SDP:\n%s\n", sdp);
1841 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1842 char *error, int error_len)
1845 InputStream *ist = &input_streams[ist_index];
1846 if (ist->decoding_needed) {
1847 AVCodec *codec = ist->dec;
1849 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1850 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1851 return AVERROR(EINVAL);
1854 /* update requested sample format for the decoder based on the
1855 corresponding encoder sample format */
1856 for (i = 0; i < nb_output_streams; i++) {
1857 OutputStream *ost = &output_streams[i];
1858 if (ost->source_index == ist_index) {
1859 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1864 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1865 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1866 ist->file_index, ist->st->index);
1867 return AVERROR(EINVAL);
1869 assert_codec_experimental(ist->st->codec, 0);
1870 assert_avoptions(ist->opts);
1873 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;
1874 ist->next_pts = AV_NOPTS_VALUE;
1875 init_pts_correction(&ist->pts_ctx);
1881 static int transcode_init(OutputFile *output_files,
1882 int nb_output_files,
1883 InputFile *input_files,
1886 int ret = 0, i, j, k;
1887 AVFormatContext *os;
1888 AVCodecContext *codec, *icodec;
1894 /* init framerate emulation */
1895 for (i = 0; i < nb_input_files; i++) {
1896 InputFile *ifile = &input_files[i];
1897 if (ifile->rate_emu)
1898 for (j = 0; j < ifile->nb_streams; j++)
1899 input_streams[j + ifile->ist_index].start = av_gettime();
1902 /* output stream init */
1903 for(i=0;i<nb_output_files;i++) {
1904 os = output_files[i].ctx;
1905 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1906 av_dump_format(os, i, os->filename, 1);
1907 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
1908 return AVERROR(EINVAL);
1912 /* for each output stream, we compute the right encoding parameters */
1913 for (i = 0; i < nb_output_streams; i++) {
1914 ost = &output_streams[i];
1915 os = output_files[ost->file_index].ctx;
1916 ist = &input_streams[ost->source_index];
1918 codec = ost->st->codec;
1919 icodec = ist->st->codec;
1921 ost->st->disposition = ist->st->disposition;
1922 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1923 codec->chroma_sample_location = icodec->chroma_sample_location;
1925 if (ost->st->stream_copy) {
1926 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1928 if (extra_size > INT_MAX) {
1929 return AVERROR(EINVAL);
1932 /* if stream_copy is selected, no need to decode or encode */
1933 codec->codec_id = icodec->codec_id;
1934 codec->codec_type = icodec->codec_type;
1936 if(!codec->codec_tag){
1937 if( !os->oformat->codec_tag
1938 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1939 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1940 codec->codec_tag = icodec->codec_tag;
1943 codec->bit_rate = icodec->bit_rate;
1944 codec->rc_max_rate = icodec->rc_max_rate;
1945 codec->rc_buffer_size = icodec->rc_buffer_size;
1946 codec->extradata= av_mallocz(extra_size);
1947 if (!codec->extradata) {
1948 return AVERROR(ENOMEM);
1950 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1951 codec->extradata_size= icodec->extradata_size;
1952 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){
1953 codec->time_base = icodec->time_base;
1954 codec->time_base.num *= icodec->ticks_per_frame;
1955 av_reduce(&codec->time_base.num, &codec->time_base.den,
1956 codec->time_base.num, codec->time_base.den, INT_MAX);
1958 codec->time_base = ist->st->time_base;
1959 switch(codec->codec_type) {
1960 case AVMEDIA_TYPE_AUDIO:
1961 if(audio_volume != 256) {
1962 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
1965 codec->channel_layout = icodec->channel_layout;
1966 codec->sample_rate = icodec->sample_rate;
1967 codec->channels = icodec->channels;
1968 codec->frame_size = icodec->frame_size;
1969 codec->audio_service_type = icodec->audio_service_type;
1970 codec->block_align= icodec->block_align;
1971 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1972 codec->block_align= 0;
1973 if(codec->codec_id == CODEC_ID_AC3)
1974 codec->block_align= 0;
1976 case AVMEDIA_TYPE_VIDEO:
1977 codec->pix_fmt = icodec->pix_fmt;
1978 codec->width = icodec->width;
1979 codec->height = icodec->height;
1980 codec->has_b_frames = icodec->has_b_frames;
1981 if (!codec->sample_aspect_ratio.num) {
1982 codec->sample_aspect_ratio =
1983 ost->st->sample_aspect_ratio =
1984 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1985 ist->st->codec->sample_aspect_ratio.num ?
1986 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
1989 case AVMEDIA_TYPE_SUBTITLE:
1990 codec->width = icodec->width;
1991 codec->height = icodec->height;
1993 case AVMEDIA_TYPE_DATA:
2000 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2001 switch(codec->codec_type) {
2002 case AVMEDIA_TYPE_AUDIO:
2003 ost->fifo= av_fifo_alloc(1024);
2005 return AVERROR(ENOMEM);
2007 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2008 if (!codec->sample_rate) {
2009 codec->sample_rate = icodec->sample_rate;
2011 codec->sample_rate >>= icodec->lowres;
2013 choose_sample_rate(ost->st, ost->enc);
2014 codec->time_base = (AVRational){1, codec->sample_rate};
2015 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2016 codec->sample_fmt = icodec->sample_fmt;
2017 choose_sample_fmt(ost->st, ost->enc);
2018 if (!codec->channels)
2019 codec->channels = icodec->channels;
2020 codec->channel_layout = icodec->channel_layout;
2021 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2022 codec->channel_layout = 0;
2023 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2024 icodec->request_channels = codec->channels;
2025 ist->decoding_needed = 1;
2026 ost->encoding_needed = 1;
2027 ost->resample_sample_fmt = icodec->sample_fmt;
2028 ost->resample_sample_rate = icodec->sample_rate;
2029 ost->resample_channels = icodec->channels;
2031 case AVMEDIA_TYPE_VIDEO:
2032 if (codec->pix_fmt == PIX_FMT_NONE)
2033 codec->pix_fmt = icodec->pix_fmt;
2034 choose_pixel_fmt(ost->st, ost->enc);
2036 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2037 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2041 if (!codec->width || !codec->height) {
2042 codec->width = icodec->width;
2043 codec->height = icodec->height;
2046 ost->video_resample = codec->width != icodec->width ||
2047 codec->height != icodec->height ||
2048 codec->pix_fmt != icodec->pix_fmt;
2049 if (ost->video_resample) {
2050 #if !CONFIG_AVFILTER
2051 avcodec_get_frame_defaults(&ost->pict_tmp);
2052 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2053 codec->width, codec->height)) {
2054 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2057 ost->img_resample_ctx = sws_getContext(
2064 ost->sws_flags, NULL, NULL, NULL);
2065 if (ost->img_resample_ctx == NULL) {
2066 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2070 codec->bits_per_raw_sample= 0;
2073 ost->resample_height = icodec->height;
2074 ost->resample_width = icodec->width;
2075 ost->resample_pix_fmt= icodec->pix_fmt;
2076 ost->encoding_needed = 1;
2077 ist->decoding_needed = 1;
2079 if (!ost->frame_rate.num)
2080 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2081 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2082 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2083 ost->frame_rate = ost->enc->supported_framerates[idx];
2085 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2088 if (configure_video_filters(ist, ost)) {
2089 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2094 case AVMEDIA_TYPE_SUBTITLE:
2095 ost->encoding_needed = 1;
2096 ist->decoding_needed = 1;
2103 if (ost->encoding_needed &&
2104 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2105 char logfilename[1024];
2108 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2109 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2111 if (codec->flags & CODEC_FLAG_PASS1) {
2112 f = fopen(logfilename, "wb");
2114 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2115 logfilename, strerror(errno));
2121 size_t logbuffer_size;
2122 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2123 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2127 codec->stats_in = logbuffer;
2131 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2132 int size= codec->width * codec->height;
2133 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2138 bit_buffer = av_malloc(bit_buffer_size);
2140 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2142 return AVERROR(ENOMEM);
2145 /* open each encoder */
2146 for (i = 0; i < nb_output_streams; i++) {
2147 ost = &output_streams[i];
2148 if (ost->encoding_needed) {
2149 AVCodec *codec = ost->enc;
2150 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2152 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2153 ost->st->codec->codec_id, ost->file_index, ost->index);
2154 ret = AVERROR(EINVAL);
2157 if (dec->subtitle_header) {
2158 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2159 if (!ost->st->codec->subtitle_header) {
2160 ret = AVERROR(ENOMEM);
2163 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2164 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2166 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2167 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2168 ost->file_index, ost->index);
2169 ret = AVERROR(EINVAL);
2172 assert_codec_experimental(ost->st->codec, 1);
2173 assert_avoptions(ost->opts);
2174 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2175 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2176 "It takes bits/s as argument, not kbits/s\n");
2177 extra_size += ost->st->codec->extradata_size;
2179 if (ost->st->codec->me_threshold)
2180 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2184 /* init input streams */
2185 for (i = 0; i < nb_input_streams; i++)
2186 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2189 /* discard unused programs */
2190 for (i = 0; i < nb_input_files; i++) {
2191 InputFile *ifile = &input_files[i];
2192 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2193 AVProgram *p = ifile->ctx->programs[j];
2194 int discard = AVDISCARD_ALL;
2196 for (k = 0; k < p->nb_stream_indexes; k++)
2197 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2198 discard = AVDISCARD_DEFAULT;
2201 p->discard = discard;
2205 /* open files and write file headers */
2206 for (i = 0; i < nb_output_files; i++) {
2207 os = output_files[i].ctx;
2208 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2209 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2210 ret = AVERROR(EINVAL);
2213 assert_avoptions(output_files[i].opts);
2214 if (strcmp(os->oformat->name, "rtp")) {
2220 /* dump the file output parameters - cannot be done before in case
2222 for(i=0;i<nb_output_files;i++) {
2223 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2226 /* dump the stream mapping */
2227 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2228 for (i = 0; i < nb_output_streams; i++) {
2229 ost = &output_streams[i];
2230 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d -> #%d.%d",
2231 input_streams[ost->source_index].file_index,
2232 input_streams[ost->source_index].st->index,
2235 if (ost->sync_ist != &input_streams[ost->source_index])
2236 av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
2237 ost->sync_ist->file_index,
2238 ost->sync_ist->st->index);
2239 if (ost->st->stream_copy)
2240 av_log(NULL, AV_LOG_INFO, " (copy)");
2242 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2243 input_streams[ost->source_index].dec->name : "?",
2244 ost->enc ? ost->enc->name : "?");
2245 av_log(NULL, AV_LOG_INFO, "\n");
2249 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2254 print_sdp(output_files, nb_output_files);
2261 * The following code is the main loop of the file converter
2263 static int transcode(OutputFile *output_files,
2264 int nb_output_files,
2265 InputFile *input_files,
2269 AVFormatContext *is, *os;
2273 int no_packet_count=0;
2274 int64_t timer_start;
2276 if (!(no_packet = av_mallocz(nb_input_files)))
2279 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2283 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2286 timer_start = av_gettime();
2288 for(; received_sigterm == 0;) {
2289 int file_index, ist_index;
2294 ipts_min = INT64_MAX;
2297 /* select the stream that we must read now by looking at the
2298 smallest output pts */
2300 for (i = 0; i < nb_output_streams; i++) {
2304 ost = &output_streams[i];
2305 of = &output_files[ost->file_index];
2306 os = output_files[ost->file_index].ctx;
2307 ist = &input_streams[ost->source_index];
2308 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2309 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2311 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2313 if (!input_files[ist->file_index].eof_reached){
2314 if(ipts < ipts_min) {
2316 if(input_sync ) file_index = ist->file_index;
2318 if(opts < opts_min) {
2320 if(!input_sync) file_index = ist->file_index;
2323 if (ost->frame_number >= ost->max_frames) {
2325 for (j = 0; j < of->ctx->nb_streams; j++)
2326 output_streams[of->ost_index + j].is_past_recording_time = 1;
2330 /* if none, if is finished */
2331 if (file_index < 0) {
2332 if(no_packet_count){
2334 memset(no_packet, 0, nb_input_files);
2341 /* read a frame from it and output it in the fifo */
2342 is = input_files[file_index].ctx;
2343 ret= av_read_frame(is, &pkt);
2344 if(ret == AVERROR(EAGAIN)){
2345 no_packet[file_index]=1;
2350 input_files[file_index].eof_reached = 1;
2358 memset(no_packet, 0, nb_input_files);
2361 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2362 is->streams[pkt.stream_index]);
2364 /* the following test is needed in case new streams appear
2365 dynamically in stream : we ignore them */
2366 if (pkt.stream_index >= input_files[file_index].nb_streams)
2367 goto discard_packet;
2368 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2369 ist = &input_streams[ist_index];
2371 goto discard_packet;
2373 if (pkt.dts != AV_NOPTS_VALUE)
2374 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2375 if (pkt.pts != AV_NOPTS_VALUE)
2376 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2378 if(pkt.pts != AV_NOPTS_VALUE)
2379 pkt.pts *= ist->ts_scale;
2380 if(pkt.dts != AV_NOPTS_VALUE)
2381 pkt.dts *= ist->ts_scale;
2383 // 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);
2384 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2385 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2386 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2387 int64_t delta= pkt_dts - ist->next_pts;
2388 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2389 input_files[ist->file_index].ts_offset -= delta;
2390 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2391 delta, input_files[ist->file_index].ts_offset);
2392 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2393 if(pkt.pts != AV_NOPTS_VALUE)
2394 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2398 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2399 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2401 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d.%d\n",
2402 ist->file_index, ist->st->index);
2405 av_free_packet(&pkt);
2410 av_free_packet(&pkt);
2412 /* dump report by using the output first video and audio streams */
2413 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2416 /* at the end of stream, we must flush the decoder buffers */
2417 for (i = 0; i < nb_input_streams; i++) {
2418 ist = &input_streams[i];
2419 if (ist->decoding_needed) {
2420 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2423 flush_encoders(output_streams, nb_output_streams);
2427 /* write the trailer if needed and close file */
2428 for(i=0;i<nb_output_files;i++) {
2429 os = output_files[i].ctx;
2430 av_write_trailer(os);
2433 /* dump report by using the first video and audio streams */
2434 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2436 /* close each encoder */
2437 for (i = 0; i < nb_output_streams; i++) {
2438 ost = &output_streams[i];
2439 if (ost->encoding_needed) {
2440 av_freep(&ost->st->codec->stats_in);
2441 avcodec_close(ost->st->codec);
2444 avfilter_graph_free(&ost->graph);
2448 /* close each decoder */
2449 for (i = 0; i < nb_input_streams; i++) {
2450 ist = &input_streams[i];
2451 if (ist->decoding_needed) {
2452 avcodec_close(ist->st->codec);
2460 av_freep(&bit_buffer);
2461 av_freep(&no_packet);
2463 if (output_streams) {
2464 for (i = 0; i < nb_output_streams; i++) {
2465 ost = &output_streams[i];
2467 if (ost->st->stream_copy)
2468 av_freep(&ost->st->codec->extradata);
2470 fclose(ost->logfile);
2471 ost->logfile = NULL;
2473 av_fifo_free(ost->fifo); /* works even if fifo is not
2474 initialized but set to zero */
2475 av_freep(&ost->st->codec->subtitle_header);
2476 av_free(ost->pict_tmp.data[0]);
2477 av_free(ost->forced_kf_pts);
2478 if (ost->video_resample)
2479 sws_freeContext(ost->img_resample_ctx);
2481 audio_resample_close(ost->resample);
2482 if (ost->reformat_ctx)
2483 av_audio_convert_free(ost->reformat_ctx);
2484 av_dict_free(&ost->opts);
2491 static int opt_verbose(const char *opt, const char *arg)
2493 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -loglevel\n", opt);
2497 static double parse_frame_aspect_ratio(const char *arg)
2504 p = strchr(arg, ':');
2506 x = strtol(arg, &end, 10);
2508 y = strtol(end+1, &end, 10);
2510 ar = (double)x / (double)y;
2512 ar = strtod(arg, NULL);
2515 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2521 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2523 return parse_option(o, "codec:a", arg, options);
2526 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2528 return parse_option(o, "codec:v", arg, options);
2531 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2533 return parse_option(o, "codec:s", arg, options);
2536 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2538 return parse_option(o, "codec:d", arg, options);
2541 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2543 StreamMap *m = NULL;
2544 int i, negative = 0, file_idx;
2545 int sync_file_idx = -1, sync_stream_idx;
2553 map = av_strdup(arg);
2555 /* parse sync stream first, just pick first matching stream */
2556 if (sync = strchr(map, ',')) {
2558 sync_file_idx = strtol(sync + 1, &sync, 0);
2559 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2560 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2565 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2566 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2567 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2568 sync_stream_idx = i;
2571 if (i == input_files[sync_file_idx].nb_streams) {
2572 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2573 "match any streams.\n", arg);
2579 file_idx = strtol(map, &p, 0);
2580 if (file_idx >= nb_input_files || file_idx < 0) {
2581 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2585 /* disable some already defined maps */
2586 for (i = 0; i < o->nb_stream_maps; i++) {
2587 m = &o->stream_maps[i];
2588 if (check_stream_specifier(input_files[m->file_index].ctx,
2589 input_files[m->file_index].ctx->streams[m->stream_index],
2590 *p == ':' ? p + 1 : p) > 0)
2594 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2595 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2596 *p == ':' ? p + 1 : p) <= 0)
2598 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2599 &o->nb_stream_maps, o->nb_stream_maps + 1);
2600 m = &o->stream_maps[o->nb_stream_maps - 1];
2602 m->file_index = file_idx;
2603 m->stream_index = i;
2605 if (sync_file_idx >= 0) {
2606 m->sync_file_index = sync_file_idx;
2607 m->sync_stream_index = sync_stream_idx;
2609 m->sync_file_index = file_idx;
2610 m->sync_stream_index = i;
2615 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2623 static void parse_meta_type(char *arg, char *type, int *index)
2633 if (*(++arg) == ':')
2634 *index = strtol(++arg, NULL, 0);
2637 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2644 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2646 MetadataMap *m, *m1;
2649 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2650 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2652 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2653 m->file = strtol(arg, &p, 0);
2654 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2656 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2657 if (p = strchr(opt, ':'))
2658 parse_meta_type(p + 1, &m1->type, &m1->index);
2662 if (m->type == 'g' || m1->type == 'g')
2663 o->metadata_global_manual = 1;
2664 if (m->type == 's' || m1->type == 's')
2665 o->metadata_streams_manual = 1;
2666 if (m->type == 'c' || m1->type == 'c')
2667 o->metadata_chapters_manual = 1;
2672 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2674 const char *codec_string = encoder ? "encoder" : "decoder";
2678 return CODEC_ID_NONE;
2680 avcodec_find_encoder_by_name(name) :
2681 avcodec_find_decoder_by_name(name);
2683 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2686 if(codec->type != type) {
2687 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2693 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2695 char *codec_name = NULL;
2697 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2701 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2702 return avcodec_find_encoder(st->codec->codec_id);
2704 } else if (!strcmp(codec_name, "copy"))
2705 st->stream_copy = 1;
2707 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2708 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2709 avcodec_find_decoder_by_name(codec_name);
2716 * Add all the streams from the given input file to the global
2717 * list of input streams.
2719 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2721 int i, rfps, rfps_base;
2723 for (i = 0; i < ic->nb_streams; i++) {
2724 AVStream *st = ic->streams[i];
2725 AVCodecContext *dec = st->codec;
2729 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2730 ist = &input_streams[nb_input_streams - 1];
2732 ist->file_index = nb_input_files;
2734 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2736 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2737 ist->ts_scale = scale;
2739 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2741 ist->dec = avcodec_find_decoder(dec->codec_id);
2743 switch (dec->codec_type) {
2744 case AVMEDIA_TYPE_AUDIO:
2745 if (o->audio_disable)
2746 st->discard= AVDISCARD_ALL;
2748 case AVMEDIA_TYPE_VIDEO:
2749 rfps = ic->streams[i]->r_frame_rate.num;
2750 rfps_base = ic->streams[i]->r_frame_rate.den;
2752 dec->flags |= CODEC_FLAG_EMU_EDGE;
2753 dec->height >>= dec->lowres;
2754 dec->width >>= dec->lowres;
2757 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2759 av_log(NULL, AV_LOG_INFO,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2760 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2761 (float)rfps / rfps_base, rfps, rfps_base);
2764 if (o->video_disable)
2765 st->discard= AVDISCARD_ALL;
2766 else if(video_discard)
2767 st->discard= video_discard;
2769 case AVMEDIA_TYPE_DATA:
2771 case AVMEDIA_TYPE_SUBTITLE:
2772 if (o->subtitle_disable)
2773 st->discard = AVDISCARD_ALL;
2775 case AVMEDIA_TYPE_ATTACHMENT:
2776 case AVMEDIA_TYPE_UNKNOWN:
2784 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2786 AVFormatContext *ic;
2787 AVInputFormat *file_iformat = NULL;
2791 AVDictionary **opts;
2792 int orig_nb_streams; // number of streams before avformat_find_stream_info
2795 if (!(file_iformat = av_find_input_format(o->format))) {
2796 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
2801 if (!strcmp(filename, "-"))
2804 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2805 !strcmp(filename, "/dev/stdin");
2807 /* get default parameters from command line */
2808 ic = avformat_alloc_context();
2810 print_error(filename, AVERROR(ENOMEM));
2813 if (o->nb_audio_sample_rate) {
2814 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2815 av_dict_set(&format_opts, "sample_rate", buf, 0);
2817 if (o->nb_audio_channels) {
2818 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2819 av_dict_set(&format_opts, "channels", buf, 0);
2821 if (o->nb_frame_rates) {
2822 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2824 if (o->nb_frame_sizes) {
2825 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2827 if (o->nb_frame_pix_fmts)
2828 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
2830 ic->flags |= AVFMT_FLAG_NONBLOCK;
2832 /* open the input file with generic libav function */
2833 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2835 print_error(filename, err);
2838 assert_avoptions(format_opts);
2840 /* apply forced codec ids */
2841 for (i = 0; i < ic->nb_streams; i++)
2842 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
2844 /* Set AVCodecContext options for avformat_find_stream_info */
2845 opts = setup_find_stream_info_opts(ic, codec_opts);
2846 orig_nb_streams = ic->nb_streams;
2848 /* If not enough info to get the stream parameters, we decode the
2849 first frames to get it. (used in mpeg case for example) */
2850 ret = avformat_find_stream_info(ic, opts);
2852 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
2853 av_close_input_file(ic);
2857 timestamp = o->start_time;
2858 /* add the stream start time */
2859 if (ic->start_time != AV_NOPTS_VALUE)
2860 timestamp += ic->start_time;
2862 /* if seeking requested, we execute it */
2863 if (o->start_time != 0) {
2864 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2866 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2867 filename, (double)timestamp / AV_TIME_BASE);
2871 /* update the current parameters so that they match the one of the input stream */
2872 add_input_streams(o, ic);
2874 /* dump the file content */
2875 av_dump_format(ic, nb_input_files, filename, 0);
2877 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
2878 input_files[nb_input_files - 1].ctx = ic;
2879 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
2880 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
2881 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
2882 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
2884 for (i = 0; i < orig_nb_streams; i++)
2885 av_dict_free(&opts[i]);
2892 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2893 AVCodecContext *avctx)
2899 for (p = kf; *p; p++)
2902 ost->forced_kf_count = n;
2903 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2904 if (!ost->forced_kf_pts) {
2905 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2908 for (i = 0; i < n; i++) {
2909 p = i ? strchr(p, ',') + 1 : kf;
2910 t = parse_time_or_die("force_key_frames", p, 1);
2911 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2915 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
2918 AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
2919 int idx = oc->nb_streams - 1;
2920 int64_t max_frames = INT64_MAX;
2921 char *bsf = NULL, *next, *codec_tag = NULL;
2922 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
2926 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
2930 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
2931 nb_output_streams + 1);
2932 ost = &output_streams[nb_output_streams - 1];
2933 ost->file_index = nb_output_files;
2936 st->codec->codec_type = type;
2937 ost->enc = choose_codec(o, oc, st, type);
2939 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
2942 avcodec_get_context_defaults3(st->codec, ost->enc);
2943 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
2945 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
2946 ost->max_frames = max_frames;
2948 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
2950 if (next = strchr(bsf, ','))
2952 if (!(bsfc = av_bitstream_filter_init(bsf))) {
2953 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
2957 bsfc_prev->next = bsfc;
2959 ost->bitstream_filters = bsfc;
2965 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
2967 uint32_t tag = strtol(codec_tag, &next, 0);
2969 tag = AV_RL32(codec_tag);
2970 st->codec->codec_tag = tag;
2973 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
2974 if (qscale >= 0 || same_quant) {
2975 st->codec->flags |= CODEC_FLAG_QSCALE;
2976 st->codec->global_quality = FF_QP2LAMBDA * qscale;
2979 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
2983 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
2986 const char *p = str;
2993 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3000 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3004 AVCodecContext *video_enc;
3006 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3008 video_enc = st->codec;
3010 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3011 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3014 if (!st->stream_copy) {
3015 const char *p = NULL;
3016 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3017 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3018 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3019 int i, force_fps = 0, top_field_first = -1;
3021 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3022 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3023 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3027 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3028 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3029 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3033 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3034 if (frame_aspect_ratio)
3035 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3037 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3038 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3039 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3042 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3044 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3046 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3047 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3050 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3052 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3054 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3055 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3058 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3061 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3064 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3066 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3069 video_enc->rc_override=
3070 av_realloc(video_enc->rc_override,
3071 sizeof(RcOverride)*(i+1));
3072 video_enc->rc_override[i].start_frame= start;
3073 video_enc->rc_override[i].end_frame = end;
3075 video_enc->rc_override[i].qscale= q;
3076 video_enc->rc_override[i].quality_factor= 1.0;
3079 video_enc->rc_override[i].qscale= 0;
3080 video_enc->rc_override[i].quality_factor= -q/100.0;
3085 video_enc->rc_override_count=i;
3086 if (!video_enc->rc_initial_buffer_occupancy)
3087 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3088 video_enc->intra_dc_precision= intra_dc_precision - 8;
3093 video_enc->flags |= CODEC_FLAG_PASS1;
3095 video_enc->flags |= CODEC_FLAG_PASS2;
3099 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3100 if (forced_key_frames)
3101 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3103 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3104 ost->force_fps = force_fps;
3106 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3107 ost->top_field_first = top_field_first;
3110 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3112 ost->avfilter = av_strdup(filters);
3119 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3123 AVCodecContext *audio_enc;
3125 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3128 audio_enc = st->codec;
3129 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3131 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3132 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3134 if (!st->stream_copy) {
3135 char *sample_fmt = NULL;
3137 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3139 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3141 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3142 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3146 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3152 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3156 AVCodecContext *data_enc;
3158 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3160 data_enc = st->codec;
3161 if (!st->stream_copy) {
3162 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3166 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3167 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3173 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3177 AVCodecContext *subtitle_enc;
3179 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3181 subtitle_enc = st->codec;
3183 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3185 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3186 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3192 /* arg format is "output-stream-index:streamid-value". */
3193 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3199 av_strlcpy(idx_str, arg, sizeof(idx_str));
3200 p = strchr(idx_str, ':');
3202 av_log(NULL, AV_LOG_FATAL,
3203 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3208 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3209 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3210 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3214 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3216 AVFormatContext *is = ifile->ctx;
3217 AVFormatContext *os = ofile->ctx;
3220 for (i = 0; i < is->nb_chapters; i++) {
3221 AVChapter *in_ch = is->chapters[i], *out_ch;
3222 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3223 AV_TIME_BASE_Q, in_ch->time_base);
3224 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3225 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3228 if (in_ch->end < ts_off)
3230 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3233 out_ch = av_mallocz(sizeof(AVChapter));
3235 return AVERROR(ENOMEM);
3237 out_ch->id = in_ch->id;
3238 out_ch->time_base = in_ch->time_base;
3239 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3240 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3243 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3246 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3248 return AVERROR(ENOMEM);
3249 os->chapters[os->nb_chapters - 1] = out_ch;
3254 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3257 AVFormatContext *ic = NULL;
3259 err = avformat_open_input(&ic, filename, NULL, NULL);
3262 /* copy stream format */
3263 for(i=0;i<ic->nb_streams;i++) {
3268 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3269 ost = new_output_stream(o, s, codec->type);
3272 // FIXME: a more elegant solution is needed
3273 memcpy(st, ic->streams[i], sizeof(AVStream));
3275 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3277 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3278 choose_sample_fmt(st, codec);
3279 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3280 choose_pixel_fmt(st, codec);
3283 av_close_input_file(ic);
3287 static void opt_output_file(void *optctx, const char *filename)
3289 OptionsContext *o = optctx;
3290 AVFormatContext *oc;
3292 AVOutputFormat *file_oformat;
3296 if (!strcmp(filename, "-"))
3299 oc = avformat_alloc_context();
3301 print_error(filename, AVERROR(ENOMEM));
3306 file_oformat = av_guess_format(o->format, NULL, NULL);
3307 if (!file_oformat) {
3308 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3312 file_oformat = av_guess_format(NULL, filename, NULL);
3313 if (!file_oformat) {
3314 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3320 oc->oformat = file_oformat;
3321 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3323 if (!strcmp(file_oformat->name, "ffm") &&
3324 av_strstart(filename, "http:", NULL)) {
3325 /* special case for files sent to avserver: we get the stream
3326 parameters from avserver */
3327 int err = read_avserver_streams(o, oc, filename);
3329 print_error(filename, err);
3332 } else if (!o->nb_stream_maps) {
3333 /* pick the "best" stream of each type */
3334 #define NEW_STREAM(type, index)\
3336 ost = new_ ## type ## _stream(o, oc);\
3337 ost->source_index = index;\
3338 ost->sync_ist = &input_streams[index];\
3339 input_streams[index].discard = 0;\
3342 /* video: highest resolution */
3343 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3344 int area = 0, idx = -1;
3345 for (i = 0; i < nb_input_streams; i++) {
3346 ist = &input_streams[i];
3347 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3348 ist->st->codec->width * ist->st->codec->height > area) {
3349 area = ist->st->codec->width * ist->st->codec->height;
3353 NEW_STREAM(video, idx);
3356 /* audio: most channels */
3357 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3358 int channels = 0, idx = -1;
3359 for (i = 0; i < nb_input_streams; i++) {
3360 ist = &input_streams[i];
3361 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3362 ist->st->codec->channels > channels) {
3363 channels = ist->st->codec->channels;
3367 NEW_STREAM(audio, idx);
3370 /* subtitles: pick first */
3371 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3372 for (i = 0; i < nb_input_streams; i++)
3373 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3374 NEW_STREAM(subtitle, i);
3378 /* do something with data? */
3380 for (i = 0; i < o->nb_stream_maps; i++) {
3381 StreamMap *map = &o->stream_maps[i];
3386 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3387 switch (ist->st->codec->codec_type) {
3388 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3389 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3390 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3391 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3393 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3394 map->file_index, map->stream_index);
3398 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3399 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3400 map->sync_stream_index];
3405 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3406 output_files[nb_output_files - 1].ctx = oc;
3407 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3408 output_files[nb_output_files - 1].recording_time = o->recording_time;
3409 output_files[nb_output_files - 1].start_time = o->start_time;
3410 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3411 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3413 /* check filename in case of an image number is expected */
3414 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3415 if (!av_filename_number_test(oc->filename)) {
3416 print_error(oc->filename, AVERROR(EINVAL));
3421 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3422 /* test if it already exists to avoid loosing precious files */
3423 if (!file_overwrite &&
3424 (strchr(filename, ':') == NULL ||
3425 filename[1] == ':' ||
3426 av_strstart(filename, "file:", NULL))) {
3427 if (avio_check(filename, 0) == 0) {
3429 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3431 if (!read_yesno()) {
3432 fprintf(stderr, "Not overwriting - exiting\n");
3437 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3444 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3445 print_error(filename, err);
3450 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3451 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3452 oc->flags |= AVFMT_FLAG_NONBLOCK;
3455 if (o->chapters_input_file >= nb_input_files) {
3456 if (o->chapters_input_file == INT_MAX) {
3457 /* copy chapters from the first input file that has them*/
3458 o->chapters_input_file = -1;
3459 for (i = 0; i < nb_input_files; i++)
3460 if (input_files[i].ctx->nb_chapters) {
3461 o->chapters_input_file = i;
3465 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3466 o->chapters_input_file);
3470 if (o->chapters_input_file >= 0)
3471 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3472 !o->metadata_chapters_manual);
3475 for (i = 0; i < o->nb_meta_data_maps; i++) {
3476 AVFormatContext *files[2];
3477 AVDictionary **meta[2];
3480 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3481 if ((index) < 0 || (index) >= (nb_elems)) {\
3482 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3487 int in_file_index = o->meta_data_maps[i][1].file;
3488 if (in_file_index < 0)
3490 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3493 files[1] = input_files[in_file_index].ctx;
3495 for (j = 0; j < 2; j++) {
3496 MetadataMap *map = &o->meta_data_maps[i][j];
3498 switch (map->type) {
3500 meta[j] = &files[j]->metadata;
3503 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3504 meta[j] = &files[j]->streams[map->index]->metadata;
3507 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3508 meta[j] = &files[j]->chapters[map->index]->metadata;
3511 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3512 meta[j] = &files[j]->programs[map->index]->metadata;
3517 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3520 /* copy global metadata by default */
3521 if (!o->metadata_global_manual && nb_input_files)
3522 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3523 AV_DICT_DONT_OVERWRITE);
3524 if (!o->metadata_streams_manual)
3525 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3526 InputStream *ist = &input_streams[output_streams[i].source_index];
3527 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3530 /* process manually set metadata */
3531 for (i = 0; i < o->nb_metadata; i++) {
3536 val = strchr(o->metadata[i].u.str, '=');
3538 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3539 o->metadata[i].u.str);
3544 parse_meta_type(o->metadata[i].specifier, &type, &index);
3550 if (index < 0 || index >= oc->nb_streams) {
3551 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3554 m = &oc->streams[index]->metadata;
3557 if (index < 0 || index >= oc->nb_chapters) {
3558 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3561 m = &oc->chapters[index]->metadata;
3564 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3568 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3574 /* same option as mencoder */
3575 static int opt_pass(const char *opt, const char *arg)
3577 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3581 static int64_t getutime(void)
3584 struct rusage rusage;
3586 getrusage(RUSAGE_SELF, &rusage);
3587 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3588 #elif HAVE_GETPROCESSTIMES
3590 FILETIME c, e, k, u;
3591 proc = GetCurrentProcess();
3592 GetProcessTimes(proc, &c, &e, &k, &u);
3593 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3595 return av_gettime();
3599 static int64_t getmaxrss(void)
3601 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3602 struct rusage rusage;
3603 getrusage(RUSAGE_SELF, &rusage);
3604 return (int64_t)rusage.ru_maxrss * 1024;
3605 #elif HAVE_GETPROCESSMEMORYINFO
3607 PROCESS_MEMORY_COUNTERS memcounters;
3608 proc = GetCurrentProcess();
3609 memcounters.cb = sizeof(memcounters);
3610 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3611 return memcounters.PeakPagefileUsage;
3617 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3619 return parse_option(o, "q:a", arg, options);
3622 static void show_usage(void)
3624 printf("Hyper fast Audio and Video encoder\n");
3625 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3629 static void show_help(void)
3632 AVOutputFormat *oformat = NULL;
3633 AVInputFormat *iformat = NULL;
3634 const AVClass *class;
3636 av_log_set_callback(log_callback_help);
3638 show_help_options(options, "Main options:\n",
3639 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3640 show_help_options(options, "\nAdvanced options:\n",
3641 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3643 show_help_options(options, "\nVideo options:\n",
3644 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3646 show_help_options(options, "\nAdvanced Video options:\n",
3647 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3648 OPT_VIDEO | OPT_EXPERT);
3649 show_help_options(options, "\nAudio options:\n",
3650 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3652 show_help_options(options, "\nAdvanced Audio options:\n",
3653 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3654 OPT_AUDIO | OPT_EXPERT);
3655 show_help_options(options, "\nSubtitle options:\n",
3656 OPT_SUBTITLE | OPT_GRAB,
3658 show_help_options(options, "\nAudio/Video grab options:\n",
3662 class = avcodec_get_class();
3663 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3666 /* individual codec options */
3668 while ((c = av_codec_next(c))) {
3669 if (c->priv_class) {
3670 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3675 class = avformat_get_class();
3676 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3679 /* individual muxer options */
3680 while ((oformat = av_oformat_next(oformat))) {
3681 if (oformat->priv_class) {
3682 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3687 /* individual demuxer options */
3688 while ((iformat = av_iformat_next(iformat))) {
3689 if (iformat->priv_class) {
3690 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3695 class = sws_get_class();
3696 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3699 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3701 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3702 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3704 if(!strncmp(arg, "pal-", 4)) {
3707 } else if(!strncmp(arg, "ntsc-", 5)) {
3710 } else if(!strncmp(arg, "film-", 5)) {
3714 /* Try to determine PAL/NTSC by peeking in the input files */
3715 if(nb_input_files) {
3717 for (j = 0; j < nb_input_files; j++) {
3718 for (i = 0; i < input_files[j].nb_streams; i++) {
3719 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3720 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3722 fr = c->time_base.den * 1000 / c->time_base.num;
3726 } else if((fr == 29970) || (fr == 23976)) {
3735 if (norm != UNKNOWN)
3736 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3739 if(norm == UNKNOWN) {
3740 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3741 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3742 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3746 if(!strcmp(arg, "vcd")) {
3747 opt_video_codec(o, "c:v", "mpeg1video");
3748 opt_audio_codec(o, "c:a", "mp2");
3749 parse_option(o, "f", "vcd", options);
3751 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3752 parse_option(o, "r", frame_rates[norm], options);
3753 opt_default("g", norm == PAL ? "15" : "18");
3755 opt_default("b", "1150000");
3756 opt_default("maxrate", "1150000");
3757 opt_default("minrate", "1150000");
3758 opt_default("bufsize", "327680"); // 40*1024*8;
3760 opt_default("b:a", "224000");
3761 parse_option(o, "ar", "44100", options);
3762 parse_option(o, "ac", "2", options);
3764 opt_default("packetsize", "2324");
3765 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3767 /* We have to offset the PTS, so that it is consistent with the SCR.
3768 SCR starts at 36000, but the first two packs contain only padding
3769 and the first pack from the other stream, respectively, may also have
3770 been written before.
3771 So the real data starts at SCR 36000+3*1200. */
3772 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3773 } else if(!strcmp(arg, "svcd")) {
3775 opt_video_codec(o, "c:v", "mpeg2video");
3776 opt_audio_codec(o, "c:a", "mp2");
3777 parse_option(o, "f", "svcd", options);
3779 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3780 parse_option(o, "r", frame_rates[norm], options);
3781 opt_default("g", norm == PAL ? "15" : "18");
3783 opt_default("b", "2040000");
3784 opt_default("maxrate", "2516000");
3785 opt_default("minrate", "0"); //1145000;
3786 opt_default("bufsize", "1835008"); //224*1024*8;
3787 opt_default("flags", "+scan_offset");
3790 opt_default("b:a", "224000");
3791 parse_option(o, "ar", "44100", options);
3793 opt_default("packetsize", "2324");
3795 } else if(!strcmp(arg, "dvd")) {
3797 opt_video_codec(o, "c:v", "mpeg2video");
3798 opt_audio_codec(o, "c:a", "ac3");
3799 parse_option(o, "f", "dvd", options);
3801 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3802 parse_option(o, "r", frame_rates[norm], options);
3803 opt_default("g", norm == PAL ? "15" : "18");
3805 opt_default("b", "6000000");
3806 opt_default("maxrate", "9000000");
3807 opt_default("minrate", "0"); //1500000;
3808 opt_default("bufsize", "1835008"); //224*1024*8;
3810 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3811 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3813 opt_default("b:a", "448000");
3814 parse_option(o, "ar", "48000", options);
3816 } else if(!strncmp(arg, "dv", 2)) {
3818 parse_option(o, "f", "dv", options);
3820 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3821 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3822 norm == PAL ? "yuv420p" : "yuv411p", options);
3823 parse_option(o, "r", frame_rates[norm], options);
3825 parse_option(o, "ar", "48000", options);
3826 parse_option(o, "ac", "2", options);
3829 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
3830 return AVERROR(EINVAL);
3835 static int opt_vstats_file(const char *opt, const char *arg)
3837 av_free (vstats_filename);
3838 vstats_filename=av_strdup (arg);
3842 static int opt_vstats(const char *opt, const char *arg)
3845 time_t today2 = time(NULL);
3846 struct tm *today = localtime(&today2);
3848 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3850 return opt_vstats_file(opt, filename);
3853 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
3855 return parse_option(o, "frames:v", arg, options);
3858 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
3860 return parse_option(o, "frames:a", arg, options);
3863 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
3865 return parse_option(o, "frames:d", arg, options);
3868 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
3870 return parse_option(o, "tag:v", arg, options);
3873 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
3875 return parse_option(o, "tag:a", arg, options);
3878 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
3880 return parse_option(o, "tag:s", arg, options);
3883 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
3885 return parse_option(o, "filter:v", arg, options);
3888 #define OFFSET(x) offsetof(OptionsContext, x)
3889 static const OptionDef options[] = {
3891 #include "cmdutils_common_opts.h"
3892 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
3893 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
3894 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3895 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3896 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3897 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
3898 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
3899 "outfile[,metadata]:infile[,metadata]" },
3900 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
3901 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3902 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
3903 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
3904 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
3905 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
3906 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
3907 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
3908 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3909 "add timings for benchmarking" },
3910 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3911 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3912 "dump each input packet" },
3913 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3914 "when dumping packets, also dump the payload" },
3915 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
3916 { "v", HAS_ARG, {(void*)opt_verbose}, "deprecated, use -loglevel instead", "number" },
3917 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3918 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3919 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3920 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3921 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3922 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
3923 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3924 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3925 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3926 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3927 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
3928 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
3929 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
3930 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
3932 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
3936 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
3937 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3938 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
3939 { "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" },
3940 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
3941 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
3942 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3943 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
3944 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3945 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
3946 "use same quantizer as source (implies VBR)" },
3947 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
3948 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3949 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3950 "deinterlace pictures" },
3951 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3952 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3954 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
3956 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
3957 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
3958 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
3959 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3960 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3961 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3962 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
3963 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
3964 { "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" },
3967 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
3968 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
3969 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
3970 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
3971 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
3972 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3973 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3974 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3975 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
3977 /* subtitle options */
3978 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
3979 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3980 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3983 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3986 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
3987 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
3989 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
3991 /* data codec support */
3992 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
3994 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
3998 int main(int argc, char **argv)
4000 OptionsContext o = { 0 };
4005 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4006 parse_loglevel(argc, argv, options);
4008 avcodec_register_all();
4010 avdevice_register_all();
4013 avfilter_register_all();
4017 avio_set_interrupt_cb(decode_interrupt_cb);
4022 parse_options(&o, argc, argv, options, opt_output_file);
4024 if(nb_output_files <= 0 && nb_input_files == 0) {
4026 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4030 /* file converter / grab */
4031 if (nb_output_files <= 0) {
4032 fprintf(stderr, "At least one output file must be specified\n");
4036 if (nb_input_files == 0) {
4037 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4042 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4044 ti = getutime() - ti;
4046 int maxrss = getmaxrss() / 1024;
4047 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);