3 * Copyright (c) 2000-2011 The libav developers.
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "avconv";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
82 int disabled; /** 1 is this mapping is disabled by a negative map */
86 int sync_stream_index;
90 * select an input file for an output file
92 typedef struct MetadataMap {
93 int file; ///< file index
94 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
95 int index; ///< stream/chapter/program number
98 static const OptionDef options[];
100 /* indexed by output file stream index */
101 static int *streamid_map = NULL;
102 static int nb_streamid_map = 0;
104 static int frame_width = 0;
105 static int frame_height = 0;
106 static float frame_aspect_ratio = 0;
107 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
108 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
109 static AVRational frame_rate;
110 static float video_qscale = 0;
111 static uint16_t *intra_matrix = NULL;
112 static uint16_t *inter_matrix = NULL;
113 static const char *video_rc_override_string=NULL;
114 static int video_disable = 0;
115 static int video_discard = 0;
116 static unsigned int video_codec_tag = 0;
117 static char *video_language = NULL;
118 static int same_quant = 0;
119 static int do_deinterlace = 0;
120 static int top_field_first = -1;
121 static int me_threshold = 0;
122 static int intra_dc_precision = 8;
123 static int qp_hist = 0;
125 static char *vfilters = NULL;
128 static int audio_sample_rate = 0;
129 #define QSCALE_NONE -99999
130 static float audio_qscale = QSCALE_NONE;
131 static int audio_disable = 0;
132 static int audio_channels = 0;
133 static unsigned int audio_codec_tag = 0;
134 static char *audio_language = NULL;
136 static int subtitle_disable = 0;
137 static char *subtitle_language = NULL;
138 static unsigned int subtitle_codec_tag = 0;
140 static int data_disable = 0;
141 static unsigned int data_codec_tag = 0;
143 static float mux_preload= 0.5;
144 static float mux_max_delay= 0.7;
146 static int file_overwrite = 0;
147 static int do_benchmark = 0;
148 static int do_hex_dump = 0;
149 static int do_pkt_dump = 0;
150 static int do_psnr = 0;
151 static int do_pass = 0;
152 static char *pass_logfilename_prefix = NULL;
153 static int video_sync_method= -1;
154 static int audio_sync_method= 0;
155 static float audio_drift_threshold= 0.1;
156 static int copy_ts= 0;
158 static int opt_shortest = 0;
159 static char *vstats_filename;
160 static FILE *vstats_file;
161 static int opt_programid = 0;
162 static int copy_initial_nonkeyframes = 0;
164 static int rate_emu = 0;
166 static int audio_volume = 256;
168 static int exit_on_error = 0;
169 static int using_stdin = 0;
170 static int verbose = 1;
171 static int64_t video_size = 0;
172 static int64_t audio_size = 0;
173 static int64_t extra_size = 0;
174 static int nb_frames_dup = 0;
175 static int nb_frames_drop = 0;
176 static int input_sync;
177 static int force_fps = 0;
178 static char *forced_key_frames = NULL;
180 static float dts_delta_threshold = 10;
182 static uint8_t *audio_buf;
183 static uint8_t *audio_out;
184 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
186 static short *samples;
188 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
189 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
190 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
192 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
194 typedef struct InputStream {
197 int discard; /* true if stream data should be discarded */
198 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
201 int64_t start; /* time when read started */
202 int64_t next_pts; /* synthetic pts for cases where pkt.pts
204 int64_t pts; /* current pts */
205 PtsCorrectionContext pts_ctx;
207 int is_start; /* is 1 at the start and after a discontinuity */
208 int showed_multi_packet_warning;
212 typedef struct InputFile {
213 AVFormatContext *ctx;
214 int eof_reached; /* true if eof reached */
215 int ist_index; /* index of first stream in ist_table */
216 int buffer_size; /* current total buffer size */
218 int nb_streams; /* number of stream that avconv is aware of; may be different
219 from ctx.nb_streams if new streams appear during av_read_frame() */
222 typedef struct OutputStream {
223 int file_index; /* file index */
224 int index; /* stream index in the output file */
225 int source_index; /* InputStream index */
226 AVStream *st; /* stream in the output file */
227 int encoding_needed; /* true if encoding needed for this stream */
229 /* input pts and corresponding output pts
231 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
232 struct InputStream *sync_ist; /* input stream to sync against */
233 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
234 AVBitStreamFilterContext *bitstream_filters;
240 AVFrame pict_tmp; /* temporary image for resampling */
241 struct SwsContext *img_resample_ctx; /* for image resampling */
244 int resample_pix_fmt;
245 AVRational frame_rate;
247 float frame_aspect_ratio;
249 /* forced key frames */
250 int64_t *forced_kf_pts;
256 ReSampleContext *resample; /* for audio resampling */
257 int resample_sample_fmt;
258 int resample_channels;
259 int resample_sample_rate;
261 AVAudioConvert *reformat_ctx;
262 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
266 AVFilterContext *output_video_filter;
267 AVFilterContext *input_video_filter;
268 AVFilterBufferRef *picref;
270 AVFilterGraph *graph;
275 int is_past_recording_time;
279 typedef struct OutputFile {
280 AVFormatContext *ctx;
282 int ost_index; /* index of the first stream in output_streams */
283 int64_t recording_time; /* desired length of the resulting file in microseconds */
284 int64_t start_time; /* start time in microseconds */
285 uint64_t limit_filesize;
288 static InputStream *input_streams = NULL;
289 static int nb_input_streams = 0;
290 static InputFile *input_files = NULL;
291 static int nb_input_files = 0;
293 static OutputStream *output_streams = NULL;
294 static int nb_output_streams = 0;
295 static OutputFile *output_files = NULL;
296 static int nb_output_files = 0;
298 typedef struct OptionsContext {
299 /* input/output options */
303 SpecifierOpt *codec_names;
307 int64_t input_ts_offset;
309 SpecifierOpt *ts_scale;
313 StreamMap *stream_maps;
315 /* first item specifies output metadata, second is input */
316 MetadataMap (*meta_data_maps)[2];
317 int nb_meta_data_maps;
318 int metadata_global_manual;
319 int metadata_streams_manual;
320 int metadata_chapters_manual;
322 int chapters_input_file;
324 int64_t recording_time;
325 uint64_t limit_filesize;
327 SpecifierOpt *metadata;
329 SpecifierOpt *max_frames;
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);
371 memset(o, 0, sizeof(*o));
373 o->recording_time = INT64_MAX;
374 o->limit_filesize = UINT64_MAX;
375 o->chapters_input_file = INT_MAX;
383 static int configure_video_filters(InputStream *ist, OutputStream *ost)
385 AVFilterContext *last_filter, *filter;
386 /** filter graph containing all filters including input & output */
387 AVCodecContext *codec = ost->st->codec;
388 AVCodecContext *icodec = ist->st->codec;
389 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
390 AVRational sample_aspect_ratio;
394 ost->graph = avfilter_graph_alloc();
396 if (ist->st->sample_aspect_ratio.num){
397 sample_aspect_ratio = ist->st->sample_aspect_ratio;
399 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
401 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
402 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
403 sample_aspect_ratio.num, sample_aspect_ratio.den);
405 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
406 "src", args, NULL, ost->graph);
409 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
410 "out", NULL, &ffsink_ctx, ost->graph);
413 last_filter = ost->input_video_filter;
415 if (codec->width != icodec->width || codec->height != icodec->height) {
416 snprintf(args, 255, "%d:%d:flags=0x%X",
420 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
421 NULL, args, NULL, ost->graph)) < 0)
423 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
425 last_filter = filter;
428 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
429 ost->graph->scale_sws_opts = av_strdup(args);
432 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
433 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
435 outputs->name = av_strdup("in");
436 outputs->filter_ctx = last_filter;
437 outputs->pad_idx = 0;
438 outputs->next = NULL;
440 inputs->name = av_strdup("out");
441 inputs->filter_ctx = ost->output_video_filter;
445 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
447 av_freep(&ost->avfilter);
449 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
453 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
456 codec->width = ost->output_video_filter->inputs[0]->w;
457 codec->height = ost->output_video_filter->inputs[0]->h;
458 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
459 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
460 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
461 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
465 #endif /* CONFIG_AVFILTER */
467 static void term_exit(void)
469 av_log(NULL, AV_LOG_QUIET, "");
472 static volatile int received_sigterm = 0;
473 static volatile int received_nb_signals = 0;
476 sigterm_handler(int sig)
478 received_sigterm = sig;
479 received_nb_signals++;
483 static void term_init(void)
485 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
486 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
488 signal(SIGXCPU, sigterm_handler);
492 static int decode_interrupt_cb(void)
494 return received_nb_signals > 1;
497 void exit_program(int ret)
502 for(i=0;i<nb_output_files;i++) {
503 AVFormatContext *s = output_files[i].ctx;
504 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
506 avformat_free_context(s);
507 av_dict_free(&output_files[i].opts);
509 for(i=0;i<nb_input_files;i++) {
510 av_close_input_file(input_files[i].ctx);
512 for (i = 0; i < nb_input_streams; i++)
513 av_dict_free(&input_streams[i].opts);
515 av_free(intra_matrix);
516 av_free(inter_matrix);
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) {
539 "Received signal %d: terminating.\n",
540 (int) received_sigterm);
544 exit(ret); /* not all OS-es handle main() return value */
547 static void assert_avoptions(AVDictionary *m)
549 AVDictionaryEntry *t;
550 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
551 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
556 static void assert_codec_experimental(AVCodecContext *c, int encoder)
558 const char *codec_string = encoder ? "encoder" : "decoder";
560 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
561 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
562 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
563 "results.\nAdd '-strict experimental' if you want to use it.\n",
564 codec_string, c->codec->name);
565 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
566 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
567 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
568 codec_string, codec->name);
573 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
575 if(codec && codec->sample_fmts){
576 const enum AVSampleFormat *p= codec->sample_fmts;
578 if(*p == st->codec->sample_fmt)
582 av_log(NULL, AV_LOG_WARNING,
583 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
584 av_get_sample_fmt_name(st->codec->sample_fmt),
586 av_get_sample_fmt_name(codec->sample_fmts[0]));
587 st->codec->sample_fmt = codec->sample_fmts[0];
593 * Update the requested input sample format based on the output sample format.
594 * This is currently only used to request float output from decoders which
595 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
596 * Ideally this will be removed in the future when decoders do not do format
597 * conversion and only output in their native format.
599 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
602 /* if sample formats match or a decoder sample format has already been
603 requested, just return */
604 if (enc->sample_fmt == dec->sample_fmt ||
605 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
608 /* if decoder supports more than one output format */
609 if (dec_codec && dec_codec->sample_fmts &&
610 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
611 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
612 const enum AVSampleFormat *p;
613 int min_dec = -1, min_inc = -1;
615 /* find a matching sample format in the encoder */
616 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
617 if (*p == enc->sample_fmt) {
618 dec->request_sample_fmt = *p;
620 } else if (*p > enc->sample_fmt) {
621 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
623 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
626 /* if none match, provide the one that matches quality closest */
627 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
628 enc->sample_fmt - min_dec;
632 static void choose_sample_rate(AVStream *st, AVCodec *codec)
634 if(codec && codec->supported_samplerates){
635 const int *p= codec->supported_samplerates;
637 int best_dist=INT_MAX;
639 int dist= abs(st->codec->sample_rate - *p);
640 if(dist < best_dist){
646 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
648 st->codec->sample_rate= best;
652 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
654 if(codec && codec->pix_fmts){
655 const enum PixelFormat *p= codec->pix_fmts;
656 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
657 if(st->codec->codec_id==CODEC_ID_MJPEG){
658 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
659 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
660 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};
664 if(*p == st->codec->pix_fmt)
668 if(st->codec->pix_fmt != PIX_FMT_NONE)
669 av_log(NULL, AV_LOG_WARNING,
670 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
671 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
673 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
674 st->codec->pix_fmt = codec->pix_fmts[0];
680 get_sync_ipts(const OutputStream *ost)
682 const InputStream *ist = ost->sync_ist;
683 OutputFile *of = &output_files[ost->file_index];
684 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
687 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
691 AVPacket new_pkt= *pkt;
692 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
693 &new_pkt.data, &new_pkt.size,
694 pkt->data, pkt->size,
695 pkt->flags & AV_PKT_FLAG_KEY);
698 new_pkt.destruct= av_destruct_packet;
700 fprintf(stderr, "%s failed for stream %d, codec %s",
701 bsfc->filter->name, pkt->stream_index,
702 avctx->codec ? avctx->codec->name : "copy");
712 ret= av_interleaved_write_frame(s, pkt);
714 print_error("av_interleaved_write_frame()", ret);
719 static void do_audio_out(AVFormatContext *s,
722 unsigned char *buf, int size)
725 int64_t audio_out_size, audio_buf_size;
726 int64_t allocated_for_size= size;
728 int size_out, frame_bytes, ret, resample_changed;
729 AVCodecContext *enc= ost->st->codec;
730 AVCodecContext *dec= ist->st->codec;
731 int osize = av_get_bytes_per_sample(enc->sample_fmt);
732 int isize = av_get_bytes_per_sample(dec->sample_fmt);
733 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
736 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
737 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
738 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
739 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
740 audio_buf_size*= osize*enc->channels;
742 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
743 if(coded_bps > 8*osize)
744 audio_out_size= audio_out_size * coded_bps / (8*osize);
745 audio_out_size += FF_MIN_BUFFER_SIZE;
747 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
748 fprintf(stderr, "Buffer sizes too large\n");
752 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
753 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
754 if (!audio_buf || !audio_out){
755 fprintf(stderr, "Out of memory in do_audio_out\n");
759 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
760 ost->audio_resample = 1;
762 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
763 ost->resample_channels != dec->channels ||
764 ost->resample_sample_rate != dec->sample_rate;
766 if ((ost->audio_resample && !ost->resample) || resample_changed) {
767 if (resample_changed) {
768 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",
769 ist->file_index, ist->st->index,
770 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
771 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
772 ost->resample_sample_fmt = dec->sample_fmt;
773 ost->resample_channels = dec->channels;
774 ost->resample_sample_rate = dec->sample_rate;
776 audio_resample_close(ost->resample);
778 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
779 if (audio_sync_method <= 1 &&
780 ost->resample_sample_fmt == enc->sample_fmt &&
781 ost->resample_channels == enc->channels &&
782 ost->resample_sample_rate == enc->sample_rate) {
783 ost->resample = NULL;
784 ost->audio_resample = 0;
785 } else if (ost->audio_resample) {
786 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
787 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
788 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
789 enc->sample_rate, dec->sample_rate,
790 enc->sample_fmt, dec->sample_fmt,
792 if (!ost->resample) {
793 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
794 dec->channels, dec->sample_rate,
795 enc->channels, enc->sample_rate);
801 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
802 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
803 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
804 if (ost->reformat_ctx)
805 av_audio_convert_free(ost->reformat_ctx);
806 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
807 dec->sample_fmt, 1, NULL, 0);
808 if (!ost->reformat_ctx) {
809 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
810 av_get_sample_fmt_name(dec->sample_fmt),
811 av_get_sample_fmt_name(enc->sample_fmt));
814 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
817 if(audio_sync_method){
818 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
819 - av_fifo_size(ost->fifo)/(enc->channels * 2);
820 double idelta= delta*dec->sample_rate / enc->sample_rate;
821 int byte_delta= ((int)idelta)*2*dec->channels;
823 //FIXME resample delay
824 if(fabs(delta) > 50){
825 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
827 byte_delta= FFMAX(byte_delta, -size);
831 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
836 static uint8_t *input_tmp= NULL;
837 input_tmp= av_realloc(input_tmp, byte_delta + size);
839 if(byte_delta > allocated_for_size - size){
840 allocated_for_size= byte_delta + (int64_t)size;
845 memset(input_tmp, 0, byte_delta);
846 memcpy(input_tmp + byte_delta, buf, size);
850 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
852 }else if(audio_sync_method>1){
853 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
854 av_assert0(ost->audio_resample);
856 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
857 // 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));
858 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
862 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
863 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
865 if (ost->audio_resample) {
867 size_out = audio_resample(ost->resample,
868 (short *)buftmp, (short *)buf,
869 size / (dec->channels * isize));
870 size_out = size_out * enc->channels * osize;
876 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
877 const void *ibuf[6]= {buftmp};
878 void *obuf[6]= {audio_buf};
879 int istride[6]= {isize};
880 int ostride[6]= {osize};
881 int len= size_out/istride[0];
882 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
883 printf("av_audio_convert() failed\n");
889 size_out = len*osize;
892 /* now encode as many frames as possible */
893 if (enc->frame_size > 1) {
894 /* output resampled raw samples */
895 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
896 fprintf(stderr, "av_fifo_realloc2() failed\n");
899 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
901 frame_bytes = enc->frame_size * osize * enc->channels;
903 while (av_fifo_size(ost->fifo) >= frame_bytes) {
905 av_init_packet(&pkt);
907 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
909 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
911 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
914 fprintf(stderr, "Audio encoding failed\n");
918 pkt.stream_index= ost->index;
921 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
922 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
923 pkt.flags |= AV_PKT_FLAG_KEY;
924 write_frame(s, &pkt, enc, ost->bitstream_filters);
926 ost->sync_opts += enc->frame_size;
930 av_init_packet(&pkt);
932 ost->sync_opts += size_out / (osize * enc->channels);
934 /* output a pcm frame */
935 /* determine the size of the coded buffer */
938 size_out = size_out*coded_bps/8;
940 if(size_out > audio_out_size){
941 fprintf(stderr, "Internal error, buffer size too small\n");
945 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
946 ret = avcodec_encode_audio(enc, audio_out, size_out,
949 fprintf(stderr, "Audio encoding failed\n");
953 pkt.stream_index= ost->index;
956 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
957 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
958 pkt.flags |= AV_PKT_FLAG_KEY;
959 write_frame(s, &pkt, enc, ost->bitstream_filters);
963 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
967 AVPicture picture_tmp;
970 dec = ist->st->codec;
972 /* deinterlace : must be done before any resize */
973 if (do_deinterlace) {
976 /* create temporary picture */
977 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
978 buf = av_malloc(size);
982 picture2 = &picture_tmp;
983 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
985 if(avpicture_deinterlace(picture2, picture,
986 dec->pix_fmt, dec->width, dec->height) < 0) {
987 /* if error, do not deinterlace */
988 fprintf(stderr, "Deinterlacing failed\n");
997 if (picture != picture2)
998 *picture = *picture2;
1002 static void do_subtitle_out(AVFormatContext *s,
1008 static uint8_t *subtitle_out = NULL;
1009 int subtitle_out_max_size = 1024 * 1024;
1010 int subtitle_out_size, nb, i;
1011 AVCodecContext *enc;
1014 if (pts == AV_NOPTS_VALUE) {
1015 fprintf(stderr, "Subtitle packets must have a pts\n");
1021 enc = ost->st->codec;
1023 if (!subtitle_out) {
1024 subtitle_out = av_malloc(subtitle_out_max_size);
1027 /* Note: DVB subtitle need one packet to draw them and one other
1028 packet to clear them */
1029 /* XXX: signal it in the codec context ? */
1030 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1035 for(i = 0; i < nb; i++) {
1036 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1037 // start_display_time is required to be 0
1038 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1039 sub->end_display_time -= sub->start_display_time;
1040 sub->start_display_time = 0;
1041 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1042 subtitle_out_max_size, sub);
1043 if (subtitle_out_size < 0) {
1044 fprintf(stderr, "Subtitle encoding failed\n");
1048 av_init_packet(&pkt);
1049 pkt.stream_index = ost->index;
1050 pkt.data = subtitle_out;
1051 pkt.size = subtitle_out_size;
1052 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1053 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1054 /* XXX: the pts correction is handled here. Maybe handling
1055 it in the codec would be better */
1057 pkt.pts += 90 * sub->start_display_time;
1059 pkt.pts += 90 * sub->end_display_time;
1061 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1065 static int bit_buffer_size= 1024*256;
1066 static uint8_t *bit_buffer= NULL;
1068 static void do_video_resample(OutputStream *ost,
1070 AVFrame *in_picture,
1071 AVFrame **out_picture)
1073 int resample_changed = 0;
1074 AVCodecContext *dec = ist->st->codec;
1075 *out_picture = in_picture;
1077 resample_changed = ost->resample_width != dec->width ||
1078 ost->resample_height != dec->height ||
1079 ost->resample_pix_fmt != dec->pix_fmt;
1081 if (resample_changed) {
1082 av_log(NULL, AV_LOG_INFO,
1083 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1084 ist->file_index, ist->st->index,
1085 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1086 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1087 if(!ost->video_resample)
1088 ost->video_resample = 1;
1091 #if !CONFIG_AVFILTER
1092 if (ost->video_resample) {
1093 *out_picture = &ost->pict_tmp;
1094 if (resample_changed) {
1095 /* initialize a new scaler context */
1096 sws_freeContext(ost->img_resample_ctx);
1097 ost->img_resample_ctx = sws_getContext(
1098 ist->st->codec->width,
1099 ist->st->codec->height,
1100 ist->st->codec->pix_fmt,
1101 ost->st->codec->width,
1102 ost->st->codec->height,
1103 ost->st->codec->pix_fmt,
1104 ost->sws_flags, NULL, NULL, NULL);
1105 if (ost->img_resample_ctx == NULL) {
1106 fprintf(stderr, "Cannot get resampling context\n");
1110 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1111 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1114 if (resample_changed) {
1115 avfilter_graph_free(&ost->graph);
1116 if (configure_video_filters(ist, ost)) {
1117 fprintf(stderr, "Error reinitializing filters!\n");
1122 if (resample_changed) {
1123 ost->resample_width = dec->width;
1124 ost->resample_height = dec->height;
1125 ost->resample_pix_fmt = dec->pix_fmt;
1130 static void do_video_out(AVFormatContext *s,
1133 AVFrame *in_picture,
1134 int *frame_size, float quality)
1136 int nb_frames, i, ret, format_video_sync;
1137 AVFrame *final_picture;
1138 AVCodecContext *enc;
1141 enc = ost->st->codec;
1143 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1145 /* by default, we output a single frame */
1150 format_video_sync = video_sync_method;
1151 if (format_video_sync < 0)
1152 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1154 if (format_video_sync) {
1155 double vdelta = sync_ipts - ost->sync_opts;
1156 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1159 else if (format_video_sync == 2) {
1162 }else if(vdelta>0.6)
1163 ost->sync_opts= lrintf(sync_ipts);
1164 }else if (vdelta > 1.1)
1165 nb_frames = lrintf(vdelta);
1166 //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);
1167 if (nb_frames == 0){
1170 fprintf(stderr, "*** drop!\n");
1171 }else if (nb_frames > 1) {
1172 nb_frames_dup += nb_frames - 1;
1174 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1177 ost->sync_opts= lrintf(sync_ipts);
1179 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1183 do_video_resample(ost, ist, in_picture, &final_picture);
1185 /* duplicates frame if needed */
1186 for(i=0;i<nb_frames;i++) {
1188 av_init_packet(&pkt);
1189 pkt.stream_index= ost->index;
1191 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1192 /* raw pictures are written as AVPicture structure to
1193 avoid any copies. We support temporarily the older
1195 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1196 enc->coded_frame->top_field_first = in_picture->top_field_first;
1197 pkt.data= (uint8_t *)final_picture;
1198 pkt.size= sizeof(AVPicture);
1199 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1200 pkt.flags |= AV_PKT_FLAG_KEY;
1202 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1204 AVFrame big_picture;
1206 big_picture= *final_picture;
1207 /* better than nothing: use input picture interlaced
1209 big_picture.interlaced_frame = in_picture->interlaced_frame;
1210 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1211 if(top_field_first == -1)
1212 big_picture.top_field_first = in_picture->top_field_first;
1214 big_picture.top_field_first = top_field_first;
1217 /* handles same_quant here. This is not correct because it may
1218 not be a global option */
1219 big_picture.quality = quality;
1221 big_picture.pict_type = 0;
1222 // big_picture.pts = AV_NOPTS_VALUE;
1223 big_picture.pts= ost->sync_opts;
1224 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1225 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1226 if (ost->forced_kf_index < ost->forced_kf_count &&
1227 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1228 big_picture.pict_type = AV_PICTURE_TYPE_I;
1229 ost->forced_kf_index++;
1231 ret = avcodec_encode_video(enc,
1232 bit_buffer, bit_buffer_size,
1235 fprintf(stderr, "Video encoding failed\n");
1240 pkt.data= bit_buffer;
1242 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1243 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1244 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1245 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1246 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1248 if(enc->coded_frame->key_frame)
1249 pkt.flags |= AV_PKT_FLAG_KEY;
1250 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1253 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1254 // enc->frame_number-1, ret, enc->pict_type);
1255 /* if two pass, output log */
1256 if (ost->logfile && enc->stats_out) {
1257 fprintf(ost->logfile, "%s", enc->stats_out);
1262 ost->frame_number++;
1266 static double psnr(double d){
1267 return -10.0*log(d)/log(10.0);
1270 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1273 AVCodecContext *enc;
1275 double ti1, bitrate, avg_bitrate;
1277 /* this is executed just the first time do_video_stats is called */
1279 vstats_file = fopen(vstats_filename, "w");
1286 enc = ost->st->codec;
1287 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1288 frame_number = ost->frame_number;
1289 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1290 if (enc->flags&CODEC_FLAG_PSNR)
1291 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1293 fprintf(vstats_file,"f_size= %6d ", frame_size);
1294 /* compute pts value */
1295 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1299 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1300 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1301 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1302 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1303 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1307 static void print_report(OutputFile *output_files,
1308 OutputStream *ost_table, int nb_ostreams,
1309 int is_last_report, int64_t timer_start)
1313 AVFormatContext *oc;
1315 AVCodecContext *enc;
1316 int frame_number, vid, i;
1317 double bitrate, ti1, pts;
1318 static int64_t last_time = -1;
1319 static int qp_histogram[52];
1321 if (!is_last_report) {
1323 /* display the report every 0.5 seconds */
1324 cur_time = av_gettime();
1325 if (last_time == -1) {
1326 last_time = cur_time;
1329 if ((cur_time - last_time) < 500000)
1331 last_time = cur_time;
1335 oc = output_files[0].ctx;
1337 total_size = avio_size(oc->pb);
1338 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1339 total_size= avio_tell(oc->pb);
1344 for(i=0;i<nb_ostreams;i++) {
1346 ost = &ost_table[i];
1347 enc = ost->st->codec;
1348 if (!ost->st->stream_copy && enc->coded_frame)
1349 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1350 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1351 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1353 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1354 float t = (av_gettime()-timer_start) / 1000000.0;
1356 frame_number = ost->frame_number;
1357 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1358 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1360 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1364 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1367 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1369 if (enc->flags&CODEC_FLAG_PSNR){
1371 double error, error_sum=0;
1372 double scale, scale_sum=0;
1373 char type[3]= {'Y','U','V'};
1374 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1377 error= enc->error[j];
1378 scale= enc->width*enc->height*255.0*255.0*frame_number;
1380 error= enc->coded_frame->error[j];
1381 scale= enc->width*enc->height*255.0*255.0;
1386 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1388 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1392 /* compute min output value */
1393 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1394 if ((pts < ti1) && (pts > 0))
1400 if (verbose > 0 || is_last_report) {
1401 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1403 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1404 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1405 (double)total_size / 1024, ti1, bitrate);
1407 if (nb_frames_dup || nb_frames_drop)
1408 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1409 nb_frames_dup, nb_frames_drop);
1412 fprintf(stderr, "%s \r", buf);
1417 if (is_last_report && verbose >= 0){
1418 int64_t raw= audio_size + video_size + extra_size;
1419 fprintf(stderr, "\n");
1420 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1424 100.0*(total_size - raw)/raw
1429 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1431 int fill_char = 0x00;
1432 if (sample_fmt == AV_SAMPLE_FMT_U8)
1434 memset(buf, fill_char, size);
1437 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1441 for (i = 0; i < nb_ostreams; i++) {
1442 OutputStream *ost = &ost_table[i];
1443 AVCodecContext *enc = ost->st->codec;
1444 AVFormatContext *os = output_files[ost->file_index].ctx;
1446 if (!ost->encoding_needed)
1449 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1451 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1457 av_init_packet(&pkt);
1458 pkt.stream_index= ost->index;
1460 switch (ost->st->codec->codec_type) {
1461 case AVMEDIA_TYPE_AUDIO:
1462 fifo_bytes = av_fifo_size(ost->fifo);
1464 /* encode any samples remaining in fifo */
1465 if (fifo_bytes > 0) {
1466 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1467 int fs_tmp = enc->frame_size;
1469 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1470 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1471 enc->frame_size = fifo_bytes / (osize * enc->channels);
1473 int frame_bytes = enc->frame_size*osize*enc->channels;
1474 if (allocated_audio_buf_size < frame_bytes)
1476 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1479 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1480 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1481 ost->st->time_base.num, enc->sample_rate);
1482 enc->frame_size = fs_tmp;
1485 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1488 fprintf(stderr, "Audio encoding failed\n");
1492 pkt.flags |= AV_PKT_FLAG_KEY;
1494 case AVMEDIA_TYPE_VIDEO:
1495 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1497 fprintf(stderr, "Video encoding failed\n");
1501 if(enc->coded_frame && enc->coded_frame->key_frame)
1502 pkt.flags |= AV_PKT_FLAG_KEY;
1503 if (ost->logfile && enc->stats_out) {
1504 fprintf(ost->logfile, "%s", enc->stats_out);
1513 pkt.data = bit_buffer;
1515 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1516 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1517 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1522 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1523 static int output_packet(InputStream *ist, int ist_index,
1524 OutputStream *ost_table, int nb_ostreams,
1525 const AVPacket *pkt)
1527 AVFormatContext *os;
1532 void *buffer_to_free = NULL;
1533 static unsigned int samples_size= 0;
1534 AVSubtitle subtitle, *subtitle_to_free;
1535 int64_t pkt_pts = AV_NOPTS_VALUE;
1537 int frame_available;
1542 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1544 if(ist->next_pts == AV_NOPTS_VALUE)
1545 ist->next_pts= ist->pts;
1549 av_init_packet(&avpkt);
1557 if(pkt->dts != AV_NOPTS_VALUE)
1558 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1559 if(pkt->pts != AV_NOPTS_VALUE)
1560 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1562 //while we have more to decode or while the decoder did output something on EOF
1563 while (avpkt.size > 0 || (!pkt && got_output)) {
1564 uint8_t *data_buf, *decoded_data_buf;
1565 int data_size, decoded_data_size;
1567 ist->pts= ist->next_pts;
1569 if(avpkt.size && avpkt.size != pkt->size &&
1570 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1571 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1572 ist->showed_multi_packet_warning=1;
1575 /* decode the packet if needed */
1576 decoded_data_buf = NULL; /* fail safe */
1577 decoded_data_size= 0;
1578 data_buf = avpkt.data;
1579 data_size = avpkt.size;
1580 subtitle_to_free = NULL;
1581 if (ist->decoding_needed) {
1582 switch(ist->st->codec->codec_type) {
1583 case AVMEDIA_TYPE_AUDIO:{
1584 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1585 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1587 samples= av_malloc(samples_size);
1589 decoded_data_size= samples_size;
1590 /* XXX: could avoid copy if PCM 16 bits with same
1591 endianness as CPU */
1592 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1599 got_output = decoded_data_size > 0;
1600 /* Some bug in mpeg audio decoder gives */
1601 /* decoded_data_size < 0, it seems they are overflows */
1603 /* no audio frame */
1606 decoded_data_buf = (uint8_t *)samples;
1607 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1608 (ist->st->codec->sample_rate * ist->st->codec->channels);
1610 case AVMEDIA_TYPE_VIDEO:
1611 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1612 /* XXX: allocate picture correctly */
1613 avcodec_get_frame_defaults(&picture);
1614 avpkt.pts = pkt_pts;
1615 avpkt.dts = ist->pts;
1616 pkt_pts = AV_NOPTS_VALUE;
1618 ret = avcodec_decode_video2(ist->st->codec,
1619 &picture, &got_output, &avpkt);
1620 quality = same_quant ? picture.quality : 0;
1624 /* no picture yet */
1625 goto discard_packet;
1627 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1628 if (ist->st->codec->time_base.num != 0) {
1629 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1630 ist->next_pts += ((int64_t)AV_TIME_BASE *
1631 ist->st->codec->time_base.num * ticks) /
1632 ist->st->codec->time_base.den;
1635 buffer_to_free = NULL;
1636 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1638 case AVMEDIA_TYPE_SUBTITLE:
1639 ret = avcodec_decode_subtitle2(ist->st->codec,
1640 &subtitle, &got_output, &avpkt);
1644 goto discard_packet;
1646 subtitle_to_free = &subtitle;
1653 switch(ist->st->codec->codec_type) {
1654 case AVMEDIA_TYPE_AUDIO:
1655 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1656 ist->st->codec->sample_rate;
1658 case AVMEDIA_TYPE_VIDEO:
1659 if (ist->st->codec->time_base.num != 0) {
1660 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1661 ist->next_pts += ((int64_t)AV_TIME_BASE *
1662 ist->st->codec->time_base.num * ticks) /
1663 ist->st->codec->time_base.den;
1670 // preprocess audio (volume)
1671 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1672 if (audio_volume != 256) {
1675 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1676 int v = ((*volp) * audio_volume + 128) >> 8;
1677 *volp++ = av_clip_int16(v);
1682 /* frame rate emulation */
1684 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1685 int64_t now = av_gettime() - ist->start;
1689 /* if output time reached then transcode raw format,
1690 encode packets and output them */
1691 for (i = 0; i < nb_ostreams; i++) {
1692 OutputFile *of = &output_files[ost_table[i].file_index];
1695 ost = &ost_table[i];
1696 if (ost->source_index != ist_index)
1699 if (of->start_time && ist->pts < of->start_time)
1702 if (of->recording_time != INT64_MAX &&
1703 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1704 (AVRational){1, 1000000}) >= 0) {
1705 ost->is_past_recording_time = 1;
1710 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1711 ost->input_video_filter) {
1713 if (ist->st->sample_aspect_ratio.num)
1714 sar = ist->st->sample_aspect_ratio;
1716 sar = ist->st->codec->sample_aspect_ratio;
1717 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, ist->pts, sar);
1719 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1720 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1721 while (frame_available) {
1722 AVRational ist_pts_tb;
1723 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1724 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1726 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1728 os = output_files[ost->file_index].ctx;
1730 /* set the input output pts pairs */
1731 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1733 if (ost->encoding_needed) {
1734 av_assert0(ist->decoding_needed);
1735 switch(ost->st->codec->codec_type) {
1736 case AVMEDIA_TYPE_AUDIO:
1737 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1739 case AVMEDIA_TYPE_VIDEO:
1741 if (ost->picref->video && !ost->frame_aspect_ratio)
1742 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1744 do_video_out(os, ost, ist, &picture, &frame_size,
1745 same_quant ? quality : ost->st->codec->global_quality);
1746 if (vstats_filename && frame_size)
1747 do_video_stats(os, ost, frame_size);
1749 case AVMEDIA_TYPE_SUBTITLE:
1750 do_subtitle_out(os, ost, ist, &subtitle,
1757 AVFrame avframe; //FIXME/XXX remove this
1759 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1761 av_init_packet(&opkt);
1763 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1764 #if !CONFIG_AVFILTER
1770 /* no reencoding needed : output the packet directly */
1771 /* force the input stream PTS */
1773 avcodec_get_frame_defaults(&avframe);
1774 ost->st->codec->coded_frame= &avframe;
1775 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1777 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1778 audio_size += data_size;
1779 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1780 video_size += data_size;
1784 opkt.stream_index= ost->index;
1785 if(pkt->pts != AV_NOPTS_VALUE)
1786 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1788 opkt.pts= AV_NOPTS_VALUE;
1790 if (pkt->dts == AV_NOPTS_VALUE)
1791 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1793 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1794 opkt.dts -= ost_tb_start_time;
1796 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1797 opkt.flags= pkt->flags;
1799 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1800 if( ost->st->codec->codec_id != CODEC_ID_H264
1801 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1802 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1804 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1805 opkt.destruct= av_destruct_packet;
1807 opkt.data = data_buf;
1808 opkt.size = data_size;
1811 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1812 ost->st->codec->frame_number++;
1813 ost->frame_number++;
1814 av_free_packet(&opkt);
1818 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1819 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1821 avfilter_unref_buffer(ost->picref);
1826 av_free(buffer_to_free);
1827 /* XXX: allocate the subtitles in the codec ? */
1828 if (subtitle_to_free) {
1829 avsubtitle_free(subtitle_to_free);
1830 subtitle_to_free = NULL;
1838 static void print_sdp(OutputFile *output_files, int n)
1842 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1846 for (i = 0; i < n; i++)
1847 avc[i] = output_files[i].ctx;
1849 av_sdp_create(avc, n, sdp, sizeof(sdp));
1850 printf("SDP:\n%s\n", sdp);
1855 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1856 char *error, int error_len)
1859 InputStream *ist = &input_streams[ist_index];
1860 if (ist->decoding_needed) {
1861 AVCodec *codec = ist->dec;
1863 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1864 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1865 return AVERROR(EINVAL);
1868 /* update requested sample format for the decoder based on the
1869 corresponding encoder sample format */
1870 for (i = 0; i < nb_output_streams; i++) {
1871 OutputStream *ost = &output_streams[i];
1872 if (ost->source_index == ist_index) {
1873 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1878 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1879 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1880 ist->file_index, ist->st->index);
1881 return AVERROR(EINVAL);
1883 assert_codec_experimental(ist->st->codec, 0);
1884 assert_avoptions(ist->opts);
1887 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;
1888 ist->next_pts = AV_NOPTS_VALUE;
1889 init_pts_correction(&ist->pts_ctx);
1895 static int transcode_init(OutputFile *output_files,
1896 int nb_output_files,
1897 InputFile *input_files,
1901 AVFormatContext *os;
1902 AVCodecContext *codec, *icodec;
1909 for (i = 0; i < nb_input_streams; i++)
1910 input_streams[i].start = av_gettime();
1912 /* output stream init */
1913 for(i=0;i<nb_output_files;i++) {
1914 os = output_files[i].ctx;
1915 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1916 av_dump_format(os, i, os->filename, 1);
1917 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1918 return AVERROR(EINVAL);
1922 /* for each output stream, we compute the right encoding parameters */
1923 for (i = 0; i < nb_output_streams; i++) {
1924 ost = &output_streams[i];
1925 os = output_files[ost->file_index].ctx;
1926 ist = &input_streams[ost->source_index];
1928 codec = ost->st->codec;
1929 icodec = ist->st->codec;
1931 ost->st->disposition = ist->st->disposition;
1932 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1933 codec->chroma_sample_location = icodec->chroma_sample_location;
1935 if (ost->st->stream_copy) {
1936 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1938 if (extra_size > INT_MAX) {
1939 return AVERROR(EINVAL);
1942 /* if stream_copy is selected, no need to decode or encode */
1943 codec->codec_id = icodec->codec_id;
1944 codec->codec_type = icodec->codec_type;
1946 if(!codec->codec_tag){
1947 if( !os->oformat->codec_tag
1948 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1949 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1950 codec->codec_tag = icodec->codec_tag;
1953 codec->bit_rate = icodec->bit_rate;
1954 codec->rc_max_rate = icodec->rc_max_rate;
1955 codec->rc_buffer_size = icodec->rc_buffer_size;
1956 codec->extradata= av_mallocz(extra_size);
1957 if (!codec->extradata) {
1958 return AVERROR(ENOMEM);
1960 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1961 codec->extradata_size= icodec->extradata_size;
1962 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){
1963 codec->time_base = icodec->time_base;
1964 codec->time_base.num *= icodec->ticks_per_frame;
1965 av_reduce(&codec->time_base.num, &codec->time_base.den,
1966 codec->time_base.num, codec->time_base.den, INT_MAX);
1968 codec->time_base = ist->st->time_base;
1969 switch(codec->codec_type) {
1970 case AVMEDIA_TYPE_AUDIO:
1971 if(audio_volume != 256) {
1972 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1975 codec->channel_layout = icodec->channel_layout;
1976 codec->sample_rate = icodec->sample_rate;
1977 codec->channels = icodec->channels;
1978 codec->frame_size = icodec->frame_size;
1979 codec->audio_service_type = icodec->audio_service_type;
1980 codec->block_align= icodec->block_align;
1981 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1982 codec->block_align= 0;
1983 if(codec->codec_id == CODEC_ID_AC3)
1984 codec->block_align= 0;
1986 case AVMEDIA_TYPE_VIDEO:
1987 codec->pix_fmt = icodec->pix_fmt;
1988 codec->width = icodec->width;
1989 codec->height = icodec->height;
1990 codec->has_b_frames = icodec->has_b_frames;
1991 if (!codec->sample_aspect_ratio.num) {
1992 codec->sample_aspect_ratio =
1993 ost->st->sample_aspect_ratio =
1994 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1995 ist->st->codec->sample_aspect_ratio.num ?
1996 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
1999 case AVMEDIA_TYPE_SUBTITLE:
2000 codec->width = icodec->width;
2001 codec->height = icodec->height;
2003 case AVMEDIA_TYPE_DATA:
2010 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2011 switch(codec->codec_type) {
2012 case AVMEDIA_TYPE_AUDIO:
2013 ost->fifo= av_fifo_alloc(1024);
2015 return AVERROR(ENOMEM);
2017 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2018 if (!codec->sample_rate) {
2019 codec->sample_rate = icodec->sample_rate;
2021 codec->sample_rate >>= icodec->lowres;
2023 choose_sample_rate(ost->st, ost->enc);
2024 codec->time_base = (AVRational){1, codec->sample_rate};
2025 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2026 codec->sample_fmt = icodec->sample_fmt;
2027 choose_sample_fmt(ost->st, ost->enc);
2028 if (!codec->channels)
2029 codec->channels = icodec->channels;
2030 codec->channel_layout = icodec->channel_layout;
2031 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2032 codec->channel_layout = 0;
2033 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2034 icodec->request_channels = codec->channels;
2035 ist->decoding_needed = 1;
2036 ost->encoding_needed = 1;
2037 ost->resample_sample_fmt = icodec->sample_fmt;
2038 ost->resample_sample_rate = icodec->sample_rate;
2039 ost->resample_channels = icodec->channels;
2041 case AVMEDIA_TYPE_VIDEO:
2042 if (codec->pix_fmt == PIX_FMT_NONE)
2043 codec->pix_fmt = icodec->pix_fmt;
2044 choose_pixel_fmt(ost->st, ost->enc);
2046 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2047 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2051 if (!codec->width || !codec->height) {
2052 codec->width = icodec->width;
2053 codec->height = icodec->height;
2056 ost->video_resample = codec->width != icodec->width ||
2057 codec->height != icodec->height ||
2058 codec->pix_fmt != icodec->pix_fmt;
2059 if (ost->video_resample) {
2060 #if !CONFIG_AVFILTER
2061 avcodec_get_frame_defaults(&ost->pict_tmp);
2062 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2063 codec->width, codec->height)) {
2064 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2067 ost->img_resample_ctx = sws_getContext(
2074 ost->sws_flags, NULL, NULL, NULL);
2075 if (ost->img_resample_ctx == NULL) {
2076 fprintf(stderr, "Cannot get resampling context\n");
2080 codec->bits_per_raw_sample= 0;
2083 ost->resample_height = icodec->height;
2084 ost->resample_width = icodec->width;
2085 ost->resample_pix_fmt= icodec->pix_fmt;
2086 ost->encoding_needed = 1;
2087 ist->decoding_needed = 1;
2089 if (!ost->frame_rate.num)
2090 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2091 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2092 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2093 ost->frame_rate = ost->enc->supported_framerates[idx];
2095 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2098 if (configure_video_filters(ist, ost)) {
2099 fprintf(stderr, "Error opening filters!\n");
2104 case AVMEDIA_TYPE_SUBTITLE:
2105 ost->encoding_needed = 1;
2106 ist->decoding_needed = 1;
2113 if (ost->encoding_needed &&
2114 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2115 char logfilename[1024];
2118 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2119 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2121 if (codec->flags & CODEC_FLAG_PASS1) {
2122 f = fopen(logfilename, "wb");
2124 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2130 size_t logbuffer_size;
2131 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2132 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2135 codec->stats_in = logbuffer;
2139 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2140 int size= codec->width * codec->height;
2141 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2146 bit_buffer = av_malloc(bit_buffer_size);
2148 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2150 return AVERROR(ENOMEM);
2153 /* open each encoder */
2154 for (i = 0; i < nb_output_streams; i++) {
2155 ost = &output_streams[i];
2156 if (ost->encoding_needed) {
2157 AVCodec *codec = ost->enc;
2158 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2160 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2161 ost->st->codec->codec_id, ost->file_index, ost->index);
2162 ret = AVERROR(EINVAL);
2165 if (dec->subtitle_header) {
2166 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2167 if (!ost->st->codec->subtitle_header) {
2168 ret = AVERROR(ENOMEM);
2171 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2172 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2174 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2175 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2176 ost->file_index, ost->index);
2177 ret = AVERROR(EINVAL);
2180 assert_codec_experimental(ost->st->codec, 1);
2181 assert_avoptions(ost->opts);
2182 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2183 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2184 "It takes bits/s as argument, not kbits/s\n");
2185 extra_size += ost->st->codec->extradata_size;
2189 /* init input streams */
2190 for (i = 0; i < nb_input_streams; i++)
2191 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2194 /* open files and write file headers */
2195 for (i = 0; i < nb_output_files; i++) {
2196 os = output_files[i].ctx;
2197 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2198 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2199 ret = AVERROR(EINVAL);
2202 assert_avoptions(output_files[i].opts);
2203 if (strcmp(os->oformat->name, "rtp")) {
2209 /* dump the file output parameters - cannot be done before in case
2211 for(i=0;i<nb_output_files;i++) {
2212 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2215 /* dump the stream mapping */
2217 fprintf(stderr, "Stream mapping:\n");
2218 for (i = 0; i < nb_output_streams;i ++) {
2219 ost = &output_streams[i];
2220 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2221 input_streams[ost->source_index].file_index,
2222 input_streams[ost->source_index].st->index,
2225 if (ost->sync_ist != &input_streams[ost->source_index])
2226 fprintf(stderr, " [sync #%d.%d]",
2227 ost->sync_ist->file_index,
2228 ost->sync_ist->st->index);
2229 if (ost->st->stream_copy)
2230 fprintf(stderr, " (copy)");
2232 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2233 input_streams[ost->source_index].dec->name : "?",
2234 ost->enc ? ost->enc->name : "?");
2235 fprintf(stderr, "\n");
2240 fprintf(stderr, "%s\n", error);
2245 print_sdp(output_files, nb_output_files);
2252 * The following code is the main loop of the file converter
2254 static int transcode(OutputFile *output_files,
2255 int nb_output_files,
2256 InputFile *input_files,
2260 AVFormatContext *is, *os;
2264 int no_packet_count=0;
2265 int64_t timer_start;
2267 if (!(no_packet = av_mallocz(nb_input_files)))
2270 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2275 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2278 timer_start = av_gettime();
2280 for(; received_sigterm == 0;) {
2281 int file_index, ist_index;
2286 ipts_min = INT64_MAX;
2289 /* select the stream that we must read now by looking at the
2290 smallest output pts */
2292 for (i = 0; i < nb_output_streams; i++) {
2296 ost = &output_streams[i];
2297 of = &output_files[ost->file_index];
2298 os = output_files[ost->file_index].ctx;
2299 ist = &input_streams[ost->source_index];
2300 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2301 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2303 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2305 if (!input_files[ist->file_index].eof_reached){
2306 if(ipts < ipts_min) {
2308 if(input_sync ) file_index = ist->file_index;
2310 if(opts < opts_min) {
2312 if(!input_sync) file_index = ist->file_index;
2315 if (ost->frame_number >= ost->max_frames) {
2317 for (j = of->ost_index; j < of->ctx->nb_streams; j++)
2318 output_streams[j].is_past_recording_time = 1;
2322 /* if none, if is finished */
2323 if (file_index < 0) {
2324 if(no_packet_count){
2326 memset(no_packet, 0, nb_input_files);
2333 /* read a frame from it and output it in the fifo */
2334 is = input_files[file_index].ctx;
2335 ret= av_read_frame(is, &pkt);
2336 if(ret == AVERROR(EAGAIN)){
2337 no_packet[file_index]=1;
2342 input_files[file_index].eof_reached = 1;
2350 memset(no_packet, 0, nb_input_files);
2353 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2354 is->streams[pkt.stream_index]);
2356 /* the following test is needed in case new streams appear
2357 dynamically in stream : we ignore them */
2358 if (pkt.stream_index >= input_files[file_index].nb_streams)
2359 goto discard_packet;
2360 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2361 ist = &input_streams[ist_index];
2363 goto discard_packet;
2365 if (pkt.dts != AV_NOPTS_VALUE)
2366 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2367 if (pkt.pts != AV_NOPTS_VALUE)
2368 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2370 if(pkt.pts != AV_NOPTS_VALUE)
2371 pkt.pts *= ist->ts_scale;
2372 if(pkt.dts != AV_NOPTS_VALUE)
2373 pkt.dts *= ist->ts_scale;
2375 // 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);
2376 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2377 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2378 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2379 int64_t delta= pkt_dts - ist->next_pts;
2380 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2381 input_files[ist->file_index].ts_offset -= delta;
2383 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2384 delta, input_files[ist->file_index].ts_offset);
2385 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2386 if(pkt.pts != AV_NOPTS_VALUE)
2387 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2391 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2392 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2395 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2396 ist->file_index, ist->st->index);
2399 av_free_packet(&pkt);
2404 av_free_packet(&pkt);
2406 /* dump report by using the output first video and audio streams */
2407 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2410 /* at the end of stream, we must flush the decoder buffers */
2411 for (i = 0; i < nb_input_streams; i++) {
2412 ist = &input_streams[i];
2413 if (ist->decoding_needed) {
2414 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2417 flush_encoders(output_streams, nb_output_streams);
2421 /* write the trailer if needed and close file */
2422 for(i=0;i<nb_output_files;i++) {
2423 os = output_files[i].ctx;
2424 av_write_trailer(os);
2427 /* dump report by using the first video and audio streams */
2428 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2430 /* close each encoder */
2431 for (i = 0; i < nb_output_streams; i++) {
2432 ost = &output_streams[i];
2433 if (ost->encoding_needed) {
2434 av_freep(&ost->st->codec->stats_in);
2435 avcodec_close(ost->st->codec);
2438 avfilter_graph_free(&ost->graph);
2442 /* close each decoder */
2443 for (i = 0; i < nb_input_streams; i++) {
2444 ist = &input_streams[i];
2445 if (ist->decoding_needed) {
2446 avcodec_close(ist->st->codec);
2454 av_freep(&bit_buffer);
2455 av_freep(&no_packet);
2457 if (output_streams) {
2458 for (i = 0; i < nb_output_streams; i++) {
2459 ost = &output_streams[i];
2461 if (ost->st->stream_copy)
2462 av_freep(&ost->st->codec->extradata);
2464 fclose(ost->logfile);
2465 ost->logfile = NULL;
2467 av_fifo_free(ost->fifo); /* works even if fifo is not
2468 initialized but set to zero */
2469 av_freep(&ost->st->codec->subtitle_header);
2470 av_free(ost->pict_tmp.data[0]);
2471 av_free(ost->forced_kf_pts);
2472 if (ost->video_resample)
2473 sws_freeContext(ost->img_resample_ctx);
2475 audio_resample_close(ost->resample);
2476 if (ost->reformat_ctx)
2477 av_audio_convert_free(ost->reformat_ctx);
2478 av_dict_free(&ost->opts);
2485 static int opt_video_rc_override_string(const char *opt, const char *arg)
2487 video_rc_override_string = arg;
2491 static int opt_me_threshold(const char *opt, const char *arg)
2493 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2497 static int opt_verbose(const char *opt, const char *arg)
2499 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2503 static int opt_frame_rate(const char *opt, const char *arg)
2505 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2506 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2512 static int opt_frame_size(const char *opt, const char *arg)
2514 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2515 fprintf(stderr, "Incorrect frame size\n");
2516 return AVERROR(EINVAL);
2521 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2523 if (strcmp(arg, "list")) {
2524 frame_pix_fmt = av_get_pix_fmt(arg);
2525 if (frame_pix_fmt == PIX_FMT_NONE) {
2526 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2527 return AVERROR(EINVAL);
2536 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2543 p = strchr(arg, ':');
2545 x = strtol(arg, &end, 10);
2547 y = strtol(end+1, &end, 10);
2549 ar = (double)x / (double)y;
2551 ar = strtod(arg, NULL);
2554 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2555 return AVERROR(EINVAL);
2557 frame_aspect_ratio = ar;
2561 static int opt_qscale(const char *opt, const char *arg)
2563 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2564 if (video_qscale == 0) {
2565 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2566 return AVERROR(EINVAL);
2571 static int opt_top_field_first(const char *opt, const char *arg)
2573 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2577 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2579 if (strcmp(arg, "list")) {
2580 audio_sample_fmt = av_get_sample_fmt(arg);
2581 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2582 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2583 return AVERROR(EINVAL);
2588 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2589 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2595 static int opt_audio_rate(const char *opt, const char *arg)
2597 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2601 static int opt_audio_channels(const char *opt, const char *arg)
2603 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2607 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2609 return parse_option(o, "codec:a", arg, options);
2612 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2614 return parse_option(o, "codec:v", arg, options);
2617 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2619 return parse_option(o, "codec:s", arg, options);
2622 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2624 return parse_option(o, "codec:d", arg, options);
2627 static int opt_codec_tag(const char *opt, const char *arg)
2630 uint32_t *codec_tag;
2632 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2633 !strcmp(opt, "vtag") ? &video_codec_tag :
2634 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2638 *codec_tag = strtol(arg, &tail, 0);
2640 *codec_tag = AV_RL32(arg);
2645 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2647 StreamMap *m = NULL;
2648 int i, negative = 0, file_idx;
2649 int sync_file_idx = -1, sync_stream_idx;
2657 map = av_strdup(arg);
2659 /* parse sync stream first, just pick first matching stream */
2660 if (sync = strchr(map, ',')) {
2662 sync_file_idx = strtol(sync + 1, &sync, 0);
2663 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2664 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2669 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2670 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2671 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2672 sync_stream_idx = i;
2675 if (i == input_files[sync_file_idx].nb_streams) {
2676 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2677 "match any streams.\n", arg);
2683 file_idx = strtol(map, &p, 0);
2684 if (file_idx >= nb_input_files || file_idx < 0) {
2685 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2689 /* disable some already defined maps */
2690 for (i = 0; i < o->nb_stream_maps; i++) {
2691 m = &o->stream_maps[i];
2692 if (check_stream_specifier(input_files[m->file_index].ctx,
2693 input_files[m->file_index].ctx->streams[m->stream_index],
2694 *p == ':' ? p + 1 : p) > 0)
2698 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2699 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2700 *p == ':' ? p + 1 : p) <= 0)
2702 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2703 &o->nb_stream_maps, o->nb_stream_maps + 1);
2704 m = &o->stream_maps[o->nb_stream_maps - 1];
2706 m->file_index = file_idx;
2707 m->stream_index = i;
2709 if (sync_file_idx >= 0) {
2710 m->sync_file_index = sync_file_idx;
2711 m->sync_stream_index = sync_stream_idx;
2713 m->sync_file_index = file_idx;
2714 m->sync_stream_index = i;
2719 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2727 static void parse_meta_type(char *arg, char *type, int *index)
2737 if (*(++arg) == ':')
2738 *index = strtol(++arg, NULL, 0);
2741 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2748 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2750 MetadataMap *m, *m1;
2753 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2754 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2756 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2757 m->file = strtol(arg, &p, 0);
2758 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2760 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2761 if (p = strchr(opt, ':'))
2762 parse_meta_type(p + 1, &m1->type, &m1->index);
2766 if (m->type == 'g' || m1->type == 'g')
2767 o->metadata_global_manual = 1;
2768 if (m->type == 's' || m1->type == 's')
2769 o->metadata_streams_manual = 1;
2770 if (m->type == 'c' || m1->type == 'c')
2771 o->metadata_chapters_manual = 1;
2776 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2778 const char *codec_string = encoder ? "encoder" : "decoder";
2782 return CODEC_ID_NONE;
2784 avcodec_find_encoder_by_name(name) :
2785 avcodec_find_decoder_by_name(name);
2787 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2790 if(codec->type != type) {
2791 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2797 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2799 char *codec_name = NULL;
2801 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2805 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2806 return avcodec_find_encoder(st->codec->codec_id);
2808 } else if (!strcmp(codec_name, "copy"))
2809 st->stream_copy = 1;
2811 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2812 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2813 avcodec_find_decoder_by_name(codec_name);
2820 * Add all the streams from the given input file to the global
2821 * list of input streams.
2823 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2825 int i, rfps, rfps_base;
2827 for (i = 0; i < ic->nb_streams; i++) {
2828 AVStream *st = ic->streams[i];
2829 AVCodecContext *dec = st->codec;
2833 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2834 ist = &input_streams[nb_input_streams - 1];
2836 ist->file_index = nb_input_files;
2838 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2840 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2841 ist->ts_scale = scale;
2843 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2845 ist->dec = avcodec_find_decoder(dec->codec_id);
2847 switch (dec->codec_type) {
2848 case AVMEDIA_TYPE_AUDIO:
2850 st->discard= AVDISCARD_ALL;
2852 case AVMEDIA_TYPE_VIDEO:
2853 rfps = ic->streams[i]->r_frame_rate.num;
2854 rfps_base = ic->streams[i]->r_frame_rate.den;
2856 dec->flags |= CODEC_FLAG_EMU_EDGE;
2857 dec->height >>= dec->lowres;
2858 dec->width >>= dec->lowres;
2861 dec->debug |= FF_DEBUG_MV;
2863 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2866 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2867 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2869 (float)rfps / rfps_base, rfps, rfps_base);
2873 st->discard= AVDISCARD_ALL;
2874 else if(video_discard)
2875 st->discard= video_discard;
2877 case AVMEDIA_TYPE_DATA:
2879 case AVMEDIA_TYPE_SUBTITLE:
2880 if(subtitle_disable)
2881 st->discard = AVDISCARD_ALL;
2883 case AVMEDIA_TYPE_ATTACHMENT:
2884 case AVMEDIA_TYPE_UNKNOWN:
2892 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2894 AVFormatContext *ic;
2895 AVInputFormat *file_iformat = NULL;
2899 AVDictionary **opts;
2900 int orig_nb_streams; // number of streams before avformat_find_stream_info
2903 if (!(file_iformat = av_find_input_format(o->format))) {
2904 fprintf(stderr, "Unknown input format: '%s'\n", o->format);
2909 if (!strcmp(filename, "-"))
2912 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2913 !strcmp(filename, "/dev/stdin");
2915 /* get default parameters from command line */
2916 ic = avformat_alloc_context();
2918 print_error(filename, AVERROR(ENOMEM));
2921 if (audio_sample_rate) {
2922 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
2923 av_dict_set(&format_opts, "sample_rate", buf, 0);
2925 if (audio_channels) {
2926 snprintf(buf, sizeof(buf), "%d", audio_channels);
2927 av_dict_set(&format_opts, "channels", buf, 0);
2929 if (frame_rate.num) {
2930 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
2931 av_dict_set(&format_opts, "framerate", buf, 0);
2933 if (frame_width && frame_height) {
2934 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
2935 av_dict_set(&format_opts, "video_size", buf, 0);
2937 if (frame_pix_fmt != PIX_FMT_NONE)
2938 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
2940 ic->flags |= AVFMT_FLAG_NONBLOCK;
2942 /* open the input file with generic libav function */
2943 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2945 print_error(filename, err);
2948 assert_avoptions(format_opts);
2953 for(i=0; i<ic->nb_streams; i++){
2954 ic->streams[i]->discard= AVDISCARD_ALL;
2956 for(i=0; i<ic->nb_programs; i++){
2957 AVProgram *p= ic->programs[i];
2958 if(p->id != opt_programid){
2959 p->discard = AVDISCARD_ALL;
2962 for(j=0; j<p->nb_stream_indexes; j++){
2963 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
2968 fprintf(stderr, "Specified program id not found\n");
2974 /* apply forced codec ids */
2975 for (i = 0; i < ic->nb_streams; i++)
2976 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
2978 /* Set AVCodecContext options for avformat_find_stream_info */
2979 opts = setup_find_stream_info_opts(ic, codec_opts);
2980 orig_nb_streams = ic->nb_streams;
2982 /* If not enough info to get the stream parameters, we decode the
2983 first frames to get it. (used in mpeg case for example) */
2984 ret = avformat_find_stream_info(ic, opts);
2985 if (ret < 0 && verbose >= 0) {
2986 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2987 av_close_input_file(ic);
2991 timestamp = o->start_time;
2992 /* add the stream start time */
2993 if (ic->start_time != AV_NOPTS_VALUE)
2994 timestamp += ic->start_time;
2996 /* if seeking requested, we execute it */
2997 if (o->start_time != 0) {
2998 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3000 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3001 filename, (double)timestamp / AV_TIME_BASE);
3005 /* update the current parameters so that they match the one of the input stream */
3006 add_input_streams(o, ic);
3008 /* dump the file content */
3010 av_dump_format(ic, nb_input_files, filename, 0);
3012 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3013 input_files[nb_input_files - 1].ctx = ic;
3014 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3015 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3016 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3018 frame_rate = (AVRational){0, 0};
3019 frame_pix_fmt = PIX_FMT_NONE;
3022 audio_sample_rate = 0;
3024 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3026 for (i = 0; i < orig_nb_streams; i++)
3027 av_dict_free(&opts[i]);
3034 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3035 AVCodecContext *avctx)
3041 for (p = kf; *p; p++)
3044 ost->forced_kf_count = n;
3045 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3046 if (!ost->forced_kf_pts) {
3047 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3050 for (i = 0; i < n; i++) {
3051 p = i ? strchr(p, ',') + 1 : kf;
3052 t = parse_time_or_die("force_key_frames", p, 1);
3053 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3057 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3060 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3061 int idx = oc->nb_streams - 1;
3062 int64_t max_frames = INT64_MAX;
3065 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3069 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3070 nb_output_streams + 1);
3071 ost = &output_streams[nb_output_streams - 1];
3072 ost->file_index = nb_output_files;
3075 st->codec->codec_type = type;
3076 ost->enc = choose_codec(o, oc, st, type);
3078 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3081 avcodec_get_context_defaults3(st->codec, ost->enc);
3082 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3084 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3085 ost->max_frames = max_frames;
3087 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3091 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3095 AVCodecContext *video_enc;
3097 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3099 if (!st->stream_copy) {
3100 ost->frame_aspect_ratio = frame_aspect_ratio;
3101 frame_aspect_ratio = 0;
3103 ost->avfilter= vfilters;
3108 ost->bitstream_filters = video_bitstream_filters;
3109 video_bitstream_filters= NULL;
3111 video_enc = st->codec;
3114 video_enc->codec_tag= video_codec_tag;
3116 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3117 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3120 if (st->stream_copy) {
3121 video_enc->sample_aspect_ratio =
3122 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3128 ost->frame_rate = frame_rate;
3130 video_enc->width = frame_width;
3131 video_enc->height = frame_height;
3132 video_enc->pix_fmt = frame_pix_fmt;
3133 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3135 if (video_qscale || same_quant) {
3136 video_enc->flags |= CODEC_FLAG_QSCALE;
3137 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3141 video_enc->intra_matrix = intra_matrix;
3143 video_enc->inter_matrix = inter_matrix;
3145 p= video_rc_override_string;
3148 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3150 fprintf(stderr, "error parsing rc_override\n");
3153 video_enc->rc_override=
3154 av_realloc(video_enc->rc_override,
3155 sizeof(RcOverride)*(i+1));
3156 video_enc->rc_override[i].start_frame= start;
3157 video_enc->rc_override[i].end_frame = end;
3159 video_enc->rc_override[i].qscale= q;
3160 video_enc->rc_override[i].quality_factor= 1.0;
3163 video_enc->rc_override[i].qscale= 0;
3164 video_enc->rc_override[i].quality_factor= -q/100.0;
3169 video_enc->rc_override_count=i;
3170 if (!video_enc->rc_initial_buffer_occupancy)
3171 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3172 video_enc->me_threshold= me_threshold;
3173 video_enc->intra_dc_precision= intra_dc_precision - 8;
3176 video_enc->flags|= CODEC_FLAG_PSNR;
3181 video_enc->flags |= CODEC_FLAG_PASS1;
3183 video_enc->flags |= CODEC_FLAG_PASS2;
3187 if (forced_key_frames)
3188 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3190 if (video_language) {
3191 av_dict_set(&st->metadata, "language", video_language, 0);
3192 av_freep(&video_language);
3195 /* reset some key parameters */
3197 av_freep(&forced_key_frames);
3198 frame_pix_fmt = PIX_FMT_NONE;
3202 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3206 AVCodecContext *audio_enc;
3208 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3211 ost->bitstream_filters = audio_bitstream_filters;
3212 audio_bitstream_filters= NULL;
3214 audio_enc = st->codec;
3215 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3218 audio_enc->codec_tag= audio_codec_tag;
3220 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3221 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3223 if (!st->stream_copy) {
3224 if (audio_qscale > QSCALE_NONE) {
3225 audio_enc->flags |= CODEC_FLAG_QSCALE;
3226 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3229 audio_enc->channels = audio_channels;
3230 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3231 audio_enc->sample_fmt = audio_sample_fmt;
3232 if (audio_sample_rate)
3233 audio_enc->sample_rate = audio_sample_rate;
3235 if (audio_language) {
3236 av_dict_set(&st->metadata, "language", audio_language, 0);
3237 av_freep(&audio_language);
3240 /* reset some key parameters */
3246 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3250 AVCodecContext *data_enc;
3252 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3254 data_enc = st->codec;
3255 if (!st->stream_copy) {
3256 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3261 data_enc->codec_tag= data_codec_tag;
3263 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3264 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3271 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3275 AVCodecContext *subtitle_enc;
3277 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3279 subtitle_enc = st->codec;
3281 ost->bitstream_filters = subtitle_bitstream_filters;
3282 subtitle_bitstream_filters= NULL;
3284 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3286 if(subtitle_codec_tag)
3287 subtitle_enc->codec_tag= subtitle_codec_tag;
3289 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3290 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3293 if (subtitle_language) {
3294 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3295 av_freep(&subtitle_language);
3298 subtitle_disable = 0;
3302 /* arg format is "output-stream-index:streamid-value". */
3303 static int opt_streamid(const char *opt, const char *arg)
3309 av_strlcpy(idx_str, arg, sizeof(idx_str));
3310 p = strchr(idx_str, ':');
3313 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3318 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3319 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3320 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3324 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3326 AVFormatContext *is = ifile->ctx;
3327 AVFormatContext *os = ofile->ctx;
3330 for (i = 0; i < is->nb_chapters; i++) {
3331 AVChapter *in_ch = is->chapters[i], *out_ch;
3332 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3333 AV_TIME_BASE_Q, in_ch->time_base);
3334 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3335 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3338 if (in_ch->end < ts_off)
3340 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3343 out_ch = av_mallocz(sizeof(AVChapter));
3345 return AVERROR(ENOMEM);
3347 out_ch->id = in_ch->id;
3348 out_ch->time_base = in_ch->time_base;
3349 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3350 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3353 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3356 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3358 return AVERROR(ENOMEM);
3359 os->chapters[os->nb_chapters - 1] = out_ch;
3364 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3367 AVFormatContext *ic = NULL;
3369 err = avformat_open_input(&ic, filename, NULL, NULL);
3372 /* copy stream format */
3373 for(i=0;i<ic->nb_streams;i++) {
3378 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3379 ost = new_output_stream(o, s, codec->type);
3382 // FIXME: a more elegant solution is needed
3383 memcpy(st, ic->streams[i], sizeof(AVStream));
3385 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3387 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3388 choose_sample_fmt(st, codec);
3389 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3390 choose_pixel_fmt(st, codec);
3393 av_close_input_file(ic);
3397 static void opt_output_file(void *optctx, const char *filename)
3399 OptionsContext *o = optctx;
3400 AVFormatContext *oc;
3402 AVOutputFormat *file_oformat;
3406 if (!strcmp(filename, "-"))
3409 oc = avformat_alloc_context();
3411 print_error(filename, AVERROR(ENOMEM));
3416 file_oformat = av_guess_format(o->format, NULL, NULL);
3417 if (!file_oformat) {
3418 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", o->format);
3422 file_oformat = av_guess_format(NULL, filename, NULL);
3423 if (!file_oformat) {
3424 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3430 oc->oformat = file_oformat;
3431 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3433 if (!strcmp(file_oformat->name, "ffm") &&
3434 av_strstart(filename, "http:", NULL)) {
3435 /* special case for files sent to avserver: we get the stream
3436 parameters from avserver */
3437 int err = read_avserver_streams(o, oc, filename);
3439 print_error(filename, err);
3442 } else if (!o->nb_stream_maps) {
3443 /* pick the "best" stream of each type */
3444 #define NEW_STREAM(type, index)\
3446 ost = new_ ## type ## _stream(o, oc);\
3447 ost->source_index = index;\
3448 ost->sync_ist = &input_streams[index];\
3449 input_streams[index].discard = 0;\
3452 /* video: highest resolution */
3453 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3454 int area = 0, idx = -1;
3455 for (i = 0; i < nb_input_streams; i++) {
3456 ist = &input_streams[i];
3457 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3458 ist->st->codec->width * ist->st->codec->height > area) {
3459 area = ist->st->codec->width * ist->st->codec->height;
3463 NEW_STREAM(video, idx);
3466 /* audio: most channels */
3467 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3468 int channels = 0, idx = -1;
3469 for (i = 0; i < nb_input_streams; i++) {
3470 ist = &input_streams[i];
3471 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3472 ist->st->codec->channels > channels) {
3473 channels = ist->st->codec->channels;
3477 NEW_STREAM(audio, idx);
3480 /* subtitles: pick first */
3481 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3482 for (i = 0; i < nb_input_streams; i++)
3483 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3484 NEW_STREAM(subtitle, i);
3488 /* do something with data? */
3490 for (i = 0; i < o->nb_stream_maps; i++) {
3491 StreamMap *map = &o->stream_maps[i];
3496 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3497 switch (ist->st->codec->codec_type) {
3498 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3499 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3500 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3501 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3503 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3504 map->file_index, map->stream_index);
3508 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3509 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3510 map->sync_stream_index];
3515 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3516 output_files[nb_output_files - 1].ctx = oc;
3517 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3518 output_files[nb_output_files - 1].recording_time = o->recording_time;
3519 output_files[nb_output_files - 1].start_time = o->start_time;
3520 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3521 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3523 /* check filename in case of an image number is expected */
3524 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3525 if (!av_filename_number_test(oc->filename)) {
3526 print_error(oc->filename, AVERROR(EINVAL));
3531 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3532 /* test if it already exists to avoid loosing precious files */
3533 if (!file_overwrite &&
3534 (strchr(filename, ':') == NULL ||
3535 filename[1] == ':' ||
3536 av_strstart(filename, "file:", NULL))) {
3537 if (avio_check(filename, 0) == 0) {
3539 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3541 if (!read_yesno()) {
3542 fprintf(stderr, "Not overwriting - exiting\n");
3547 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3554 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3555 print_error(filename, err);
3560 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3561 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3562 oc->flags |= AVFMT_FLAG_NONBLOCK;
3565 if (o->chapters_input_file >= nb_input_files) {
3566 if (o->chapters_input_file == INT_MAX) {
3567 /* copy chapters from the first input file that has them*/
3568 o->chapters_input_file = -1;
3569 for (i = 0; i < nb_input_files; i++)
3570 if (input_files[i].ctx->nb_chapters) {
3571 o->chapters_input_file = i;
3575 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3576 o->chapters_input_file);
3580 if (o->chapters_input_file >= 0)
3581 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3582 o->metadata_chapters_manual);
3585 for (i = 0; i < o->nb_meta_data_maps; i++) {
3586 AVFormatContext *files[2];
3587 AVDictionary **meta[2];
3590 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3591 if ((index) < 0 || (index) >= (nb_elems)) {\
3592 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3597 int in_file_index = o->meta_data_maps[i][1].file;
3598 if (in_file_index < 0)
3600 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3603 files[1] = input_files[in_file_index].ctx;
3605 for (j = 0; j < 2; j++) {
3606 MetadataMap *map = &o->meta_data_maps[i][j];
3608 switch (map->type) {
3610 meta[j] = &files[j]->metadata;
3613 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3614 meta[j] = &files[j]->streams[map->index]->metadata;
3617 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3618 meta[j] = &files[j]->chapters[map->index]->metadata;
3621 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3622 meta[j] = &files[j]->programs[map->index]->metadata;
3627 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3630 /* copy global metadata by default */
3631 if (!o->metadata_global_manual && nb_input_files)
3632 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3633 AV_DICT_DONT_OVERWRITE);
3634 if (!o->metadata_streams_manual)
3635 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3636 InputStream *ist = &input_streams[output_streams[i].source_index];
3637 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3640 /* process manually set metadata */
3641 for (i = 0; i < o->nb_metadata; i++) {
3646 val = strchr(o->metadata[i].u.str, '=');
3648 av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3649 o->metadata[i].u.str);
3654 parse_meta_type(o->metadata[i].specifier, &type, &index);
3660 if (index < 0 || index >= oc->nb_streams) {
3661 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3664 m = &oc->streams[i]->metadata;
3667 if (index < 0 || index >= oc->nb_chapters) {
3668 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3671 m = &oc->chapters[i]->metadata;
3674 av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3678 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3681 frame_rate = (AVRational){0, 0};
3684 audio_sample_rate = 0;
3686 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3688 av_freep(&streamid_map);
3689 nb_streamid_map = 0;
3691 av_freep(&forced_key_frames);
3695 /* same option as mencoder */
3696 static int opt_pass(const char *opt, const char *arg)
3698 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3702 static int64_t getutime(void)
3705 struct rusage rusage;
3707 getrusage(RUSAGE_SELF, &rusage);
3708 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3709 #elif HAVE_GETPROCESSTIMES
3711 FILETIME c, e, k, u;
3712 proc = GetCurrentProcess();
3713 GetProcessTimes(proc, &c, &e, &k, &u);
3714 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3716 return av_gettime();
3720 static int64_t getmaxrss(void)
3722 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3723 struct rusage rusage;
3724 getrusage(RUSAGE_SELF, &rusage);
3725 return (int64_t)rusage.ru_maxrss * 1024;
3726 #elif HAVE_GETPROCESSMEMORYINFO
3728 PROCESS_MEMORY_COUNTERS memcounters;
3729 proc = GetCurrentProcess();
3730 memcounters.cb = sizeof(memcounters);
3731 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3732 return memcounters.PeakPagefileUsage;
3738 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3741 const char *p = str;
3748 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3755 static void opt_inter_matrix(const char *arg)
3757 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3758 parse_matrix_coeffs(inter_matrix, arg);
3761 static void opt_intra_matrix(const char *arg)
3763 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3764 parse_matrix_coeffs(intra_matrix, arg);
3767 static void show_usage(void)
3769 printf("Hyper fast Audio and Video encoder\n");
3770 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3774 static void show_help(void)
3777 AVOutputFormat *oformat = NULL;
3778 AVInputFormat *iformat = NULL;
3779 const AVClass *class;
3781 av_log_set_callback(log_callback_help);
3783 show_help_options(options, "Main options:\n",
3784 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3785 show_help_options(options, "\nAdvanced options:\n",
3786 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3788 show_help_options(options, "\nVideo options:\n",
3789 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3791 show_help_options(options, "\nAdvanced Video options:\n",
3792 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3793 OPT_VIDEO | OPT_EXPERT);
3794 show_help_options(options, "\nAudio options:\n",
3795 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3797 show_help_options(options, "\nAdvanced Audio options:\n",
3798 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3799 OPT_AUDIO | OPT_EXPERT);
3800 show_help_options(options, "\nSubtitle options:\n",
3801 OPT_SUBTITLE | OPT_GRAB,
3803 show_help_options(options, "\nAudio/Video grab options:\n",
3807 class = avcodec_get_class();
3808 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3811 /* individual codec options */
3813 while ((c = av_codec_next(c))) {
3814 if (c->priv_class) {
3815 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3820 class = avformat_get_class();
3821 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3824 /* individual muxer options */
3825 while ((oformat = av_oformat_next(oformat))) {
3826 if (oformat->priv_class) {
3827 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3832 /* individual demuxer options */
3833 while ((iformat = av_iformat_next(iformat))) {
3834 if (iformat->priv_class) {
3835 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3840 class = sws_get_class();
3841 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3844 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3846 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3847 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3849 if(!strncmp(arg, "pal-", 4)) {
3852 } else if(!strncmp(arg, "ntsc-", 5)) {
3855 } else if(!strncmp(arg, "film-", 5)) {
3860 /* Calculate FR via float to avoid int overflow */
3861 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3864 } else if((fr == 29970) || (fr == 23976)) {
3867 /* Try to determine PAL/NTSC by peeking in the input files */
3868 if(nb_input_files) {
3870 for (j = 0; j < nb_input_files; j++) {
3871 for (i = 0; i < input_files[j].nb_streams; i++) {
3872 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3873 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3875 fr = c->time_base.den * 1000 / c->time_base.num;
3879 } else if((fr == 29970) || (fr == 23976)) {
3889 if(verbose > 0 && norm != UNKNOWN)
3890 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3893 if(norm == UNKNOWN) {
3894 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3895 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3896 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3900 if(!strcmp(arg, "vcd")) {
3901 opt_video_codec(o, "c:v", "mpeg1video");
3902 opt_audio_codec(o, "c:a", "mp2");
3903 parse_option(o, "f", "vcd", options);
3905 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
3906 opt_frame_rate("r", frame_rates[norm]);
3907 opt_default("g", norm == PAL ? "15" : "18");
3909 opt_default("b", "1150000");
3910 opt_default("maxrate", "1150000");
3911 opt_default("minrate", "1150000");
3912 opt_default("bufsize", "327680"); // 40*1024*8;
3914 opt_default("b:a", "224000");
3915 audio_sample_rate = 44100;
3918 opt_default("packetsize", "2324");
3919 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3921 /* We have to offset the PTS, so that it is consistent with the SCR.
3922 SCR starts at 36000, but the first two packs contain only padding
3923 and the first pack from the other stream, respectively, may also have
3924 been written before.
3925 So the real data starts at SCR 36000+3*1200. */
3926 mux_preload= (36000+3*1200) / 90000.0; //0.44
3927 } else if(!strcmp(arg, "svcd")) {
3929 opt_video_codec(o, "c:v", "mpeg2video");
3930 opt_audio_codec(o, "c:a", "mp2");
3931 parse_option(o, "f", "svcd", options);
3933 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
3934 opt_frame_rate("r", frame_rates[norm]);
3935 opt_default("g", norm == PAL ? "15" : "18");
3937 opt_default("b", "2040000");
3938 opt_default("maxrate", "2516000");
3939 opt_default("minrate", "0"); //1145000;
3940 opt_default("bufsize", "1835008"); //224*1024*8;
3941 opt_default("flags", "+scan_offset");
3944 opt_default("b:a", "224000");
3945 audio_sample_rate = 44100;
3947 opt_default("packetsize", "2324");
3949 } else if(!strcmp(arg, "dvd")) {
3951 opt_video_codec(o, "c:v", "mpeg2video");
3952 opt_audio_codec(o, "c:a", "ac3");
3953 parse_option(o, "f", "dvd", options);
3955 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
3956 opt_frame_rate("r", frame_rates[norm]);
3957 opt_default("g", norm == PAL ? "15" : "18");
3959 opt_default("b", "6000000");
3960 opt_default("maxrate", "9000000");
3961 opt_default("minrate", "0"); //1500000;
3962 opt_default("bufsize", "1835008"); //224*1024*8;
3964 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3965 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3967 opt_default("b:a", "448000");
3968 audio_sample_rate = 48000;
3970 } else if(!strncmp(arg, "dv", 2)) {
3972 parse_option(o, "f", "dv", options);
3974 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
3975 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3976 norm == PAL ? "yuv420p" : "yuv411p");
3977 opt_frame_rate("r", frame_rates[norm]);
3979 audio_sample_rate = 48000;
3983 fprintf(stderr, "Unknown target: %s\n", arg);
3984 return AVERROR(EINVAL);
3989 static int opt_vstats_file(const char *opt, const char *arg)
3991 av_free (vstats_filename);
3992 vstats_filename=av_strdup (arg);
3996 static int opt_vstats(const char *opt, const char *arg)
3999 time_t today2 = time(NULL);
4000 struct tm *today = localtime(&today2);
4002 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4004 return opt_vstats_file(opt, filename);
4007 static int opt_bsf(const char *opt, const char *arg)
4009 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4010 AVBitStreamFilterContext **bsfp;
4013 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4017 bsfp= *opt == 'v' ? &video_bitstream_filters :
4018 *opt == 'a' ? &audio_bitstream_filters :
4019 &subtitle_bitstream_filters;
4021 bsfp= &(*bsfp)->next;
4028 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4030 return parse_option(o, "frames:v", arg, options);
4033 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4035 return parse_option(o, "frames:a", arg, options);
4038 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4040 return parse_option(o, "frames:d", arg, options);
4043 #define OFFSET(x) offsetof(OptionsContext, x)
4044 static const OptionDef options[] = {
4046 #include "cmdutils_common_opts.h"
4047 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4048 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4049 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4050 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4051 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4052 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4053 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4054 "outfile[,metadata]:infile[,metadata]" },
4055 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4056 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4057 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4058 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4059 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4060 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4061 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4062 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4063 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4064 "add timings for benchmarking" },
4065 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4066 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4067 "dump each input packet" },
4068 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4069 "when dumping packets, also dump the payload" },
4070 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4071 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4072 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4073 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4074 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4075 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4076 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4077 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4078 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4079 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4080 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4081 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4082 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4083 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4086 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4087 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4088 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4089 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4090 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
4091 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4092 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4093 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4094 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4095 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4096 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold", "threshold" },
4097 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4098 "use same quantizer as source (implies VBR)" },
4099 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4100 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4101 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4102 "deinterlace pictures" },
4103 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4104 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4105 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4107 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4109 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4110 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4111 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4112 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4113 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4114 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4115 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4116 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4117 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4118 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4121 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4122 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4123 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4124 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4125 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4126 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4127 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4128 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4129 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4130 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
4132 /* subtitle options */
4133 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4134 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4135 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4136 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4139 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4142 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4143 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4145 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4146 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4147 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4149 /* data codec support */
4150 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4152 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4156 int main(int argc, char **argv)
4158 OptionsContext o = { 0 };
4163 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4165 avcodec_register_all();
4167 avdevice_register_all();
4170 avfilter_register_all();
4174 avio_set_interrupt_cb(decode_interrupt_cb);
4179 parse_options(&o, argc, argv, options, opt_output_file);
4181 if(nb_output_files <= 0 && nb_input_files == 0) {
4183 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4187 /* file converter / grab */
4188 if (nb_output_files <= 0) {
4189 fprintf(stderr, "At least one output file must be specified\n");
4193 if (nb_input_files == 0) {
4194 fprintf(stderr, "At least one input file must be specified\n");
4199 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4201 ti = getutime() - ti;
4203 int maxrss = getmaxrss() / 1024;
4204 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);