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 int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
110 static AVRational frame_rate;
111 static float video_qscale = 0;
112 static uint16_t *intra_matrix = NULL;
113 static uint16_t *inter_matrix = NULL;
114 static const char *video_rc_override_string=NULL;
115 static int video_disable = 0;
116 static int video_discard = 0;
117 static unsigned int video_codec_tag = 0;
118 static char *video_language = NULL;
119 static int same_quant = 0;
120 static int do_deinterlace = 0;
121 static int top_field_first = -1;
122 static int me_threshold = 0;
123 static int intra_dc_precision = 8;
124 static int qp_hist = 0;
126 static char *vfilters = NULL;
129 static int audio_sample_rate = 0;
130 #define QSCALE_NONE -99999
131 static float audio_qscale = QSCALE_NONE;
132 static int audio_disable = 0;
133 static int audio_channels = 0;
134 static unsigned int audio_codec_tag = 0;
135 static char *audio_language = NULL;
137 static int subtitle_disable = 0;
138 static char *subtitle_language = NULL;
139 static unsigned int subtitle_codec_tag = 0;
141 static int data_disable = 0;
142 static unsigned int data_codec_tag = 0;
144 static float mux_preload= 0.5;
145 static float mux_max_delay= 0.7;
147 static int file_overwrite = 0;
148 static int do_benchmark = 0;
149 static int do_hex_dump = 0;
150 static int do_pkt_dump = 0;
151 static int do_psnr = 0;
152 static int do_pass = 0;
153 static char *pass_logfilename_prefix = NULL;
154 static int video_sync_method= -1;
155 static int audio_sync_method= 0;
156 static float audio_drift_threshold= 0.1;
157 static int copy_ts= 0;
159 static int opt_shortest = 0;
160 static char *vstats_filename;
161 static FILE *vstats_file;
162 static int opt_programid = 0;
163 static int copy_initial_nonkeyframes = 0;
165 static int rate_emu = 0;
167 static int audio_volume = 256;
169 static int exit_on_error = 0;
170 static int using_stdin = 0;
171 static int verbose = 1;
172 static int64_t video_size = 0;
173 static int64_t audio_size = 0;
174 static int64_t extra_size = 0;
175 static int nb_frames_dup = 0;
176 static int nb_frames_drop = 0;
177 static int input_sync;
178 static int force_fps = 0;
179 static char *forced_key_frames = NULL;
181 static float dts_delta_threshold = 10;
183 static uint8_t *audio_buf;
184 static uint8_t *audio_out;
185 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
187 static short *samples;
189 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
190 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
191 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
193 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
195 typedef struct InputStream {
198 int discard; /* true if stream data should be discarded */
199 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
202 int64_t start; /* time when read started */
203 int64_t next_pts; /* synthetic pts for cases where pkt.pts
205 int64_t pts; /* current pts */
206 PtsCorrectionContext pts_ctx;
208 int is_start; /* is 1 at the start and after a discontinuity */
209 int showed_multi_packet_warning;
213 typedef struct InputFile {
214 AVFormatContext *ctx;
215 int eof_reached; /* true if eof reached */
216 int ist_index; /* index of first stream in ist_table */
217 int buffer_size; /* current total buffer size */
219 int nb_streams; /* number of stream that avconv is aware of; may be different
220 from ctx.nb_streams if new streams appear during av_read_frame() */
223 typedef struct OutputStream {
224 int file_index; /* file index */
225 int index; /* stream index in the output file */
226 int source_index; /* InputStream index */
227 AVStream *st; /* stream in the output file */
228 int encoding_needed; /* true if encoding needed for this stream */
230 /* input pts and corresponding output pts
232 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
233 struct InputStream *sync_ist; /* input stream to sync against */
234 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
235 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;
331 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
334 for (i = 0; i < o->nb_ ## name; i++) {\
335 char *spec = o->name[i].specifier;\
336 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
337 outvar = o->name[i].u.type;\
343 static void reset_options(OptionsContext *o)
345 const OptionDef *po = options;
347 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
349 void *dst = (uint8_t*)o + po->u.off;
351 if (po->flags & OPT_SPEC) {
352 SpecifierOpt **so = dst;
353 int i, *count = (int*)(so + 1);
354 for (i = 0; i < *count; i++) {
355 av_freep(&(*so)[i].specifier);
356 if (po->flags & OPT_STRING)
357 av_freep(&(*so)[i].u.str);
361 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
366 av_freep(&o->stream_maps);
367 av_freep(&o->meta_data_maps);
369 memset(o, 0, sizeof(*o));
371 o->recording_time = INT64_MAX;
372 o->limit_filesize = UINT64_MAX;
373 o->chapters_input_file = INT_MAX;
381 static int configure_video_filters(InputStream *ist, OutputStream *ost)
383 AVFilterContext *last_filter, *filter;
384 /** filter graph containing all filters including input & output */
385 AVCodecContext *codec = ost->st->codec;
386 AVCodecContext *icodec = ist->st->codec;
387 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
388 AVRational sample_aspect_ratio;
392 ost->graph = avfilter_graph_alloc();
394 if (ist->st->sample_aspect_ratio.num){
395 sample_aspect_ratio = ist->st->sample_aspect_ratio;
397 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
399 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
400 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
401 sample_aspect_ratio.num, sample_aspect_ratio.den);
403 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
404 "src", args, NULL, ost->graph);
407 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
408 "out", NULL, &ffsink_ctx, ost->graph);
411 last_filter = ost->input_video_filter;
413 if (codec->width != icodec->width || codec->height != icodec->height) {
414 snprintf(args, 255, "%d:%d:flags=0x%X",
418 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
419 NULL, args, NULL, ost->graph)) < 0)
421 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
423 last_filter = filter;
426 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
427 ost->graph->scale_sws_opts = av_strdup(args);
430 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
431 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
433 outputs->name = av_strdup("in");
434 outputs->filter_ctx = last_filter;
435 outputs->pad_idx = 0;
436 outputs->next = NULL;
438 inputs->name = av_strdup("out");
439 inputs->filter_ctx = ost->output_video_filter;
443 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
445 av_freep(&ost->avfilter);
447 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
451 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
454 codec->width = ost->output_video_filter->inputs[0]->w;
455 codec->height = ost->output_video_filter->inputs[0]->h;
456 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
457 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
458 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
459 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
463 #endif /* CONFIG_AVFILTER */
465 static void term_exit(void)
467 av_log(NULL, AV_LOG_QUIET, "");
470 static volatile int received_sigterm = 0;
471 static volatile int received_nb_signals = 0;
474 sigterm_handler(int sig)
476 received_sigterm = sig;
477 received_nb_signals++;
481 static void term_init(void)
483 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
484 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
486 signal(SIGXCPU, sigterm_handler);
490 static int decode_interrupt_cb(void)
492 return received_nb_signals > 1;
495 void exit_program(int ret)
500 for(i=0;i<nb_output_files;i++) {
501 AVFormatContext *s = output_files[i].ctx;
502 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
504 avformat_free_context(s);
505 av_dict_free(&output_files[i].opts);
507 for(i=0;i<nb_input_files;i++) {
508 av_close_input_file(input_files[i].ctx);
510 for (i = 0; i < nb_input_streams; i++)
511 av_dict_free(&input_streams[i].opts);
513 av_free(intra_matrix);
514 av_free(inter_matrix);
518 av_free(vstats_filename);
520 av_freep(&input_streams);
521 av_freep(&input_files);
522 av_freep(&output_streams);
523 av_freep(&output_files);
528 allocated_audio_buf_size= allocated_audio_out_size= 0;
535 if (received_sigterm) {
537 "Received signal %d: terminating.\n",
538 (int) received_sigterm);
542 exit(ret); /* not all OS-es handle main() return value */
545 static void assert_avoptions(AVDictionary *m)
547 AVDictionaryEntry *t;
548 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
549 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
554 static void assert_codec_experimental(AVCodecContext *c, int encoder)
556 const char *codec_string = encoder ? "encoder" : "decoder";
558 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
559 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
560 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
561 "results.\nAdd '-strict experimental' if you want to use it.\n",
562 codec_string, c->codec->name);
563 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
564 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
565 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
566 codec_string, codec->name);
571 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
573 if(codec && codec->sample_fmts){
574 const enum AVSampleFormat *p= codec->sample_fmts;
576 if(*p == st->codec->sample_fmt)
580 av_log(NULL, AV_LOG_WARNING,
581 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
582 av_get_sample_fmt_name(st->codec->sample_fmt),
584 av_get_sample_fmt_name(codec->sample_fmts[0]));
585 st->codec->sample_fmt = codec->sample_fmts[0];
591 * Update the requested input sample format based on the output sample format.
592 * This is currently only used to request float output from decoders which
593 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
594 * Ideally this will be removed in the future when decoders do not do format
595 * conversion and only output in their native format.
597 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
600 /* if sample formats match or a decoder sample format has already been
601 requested, just return */
602 if (enc->sample_fmt == dec->sample_fmt ||
603 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
606 /* if decoder supports more than one output format */
607 if (dec_codec && dec_codec->sample_fmts &&
608 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
609 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
610 const enum AVSampleFormat *p;
611 int min_dec = -1, min_inc = -1;
613 /* find a matching sample format in the encoder */
614 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
615 if (*p == enc->sample_fmt) {
616 dec->request_sample_fmt = *p;
618 } else if (*p > enc->sample_fmt) {
619 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
621 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
624 /* if none match, provide the one that matches quality closest */
625 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
626 enc->sample_fmt - min_dec;
630 static void choose_sample_rate(AVStream *st, AVCodec *codec)
632 if(codec && codec->supported_samplerates){
633 const int *p= codec->supported_samplerates;
635 int best_dist=INT_MAX;
637 int dist= abs(st->codec->sample_rate - *p);
638 if(dist < best_dist){
644 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
646 st->codec->sample_rate= best;
650 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
652 if(codec && codec->pix_fmts){
653 const enum PixelFormat *p= codec->pix_fmts;
654 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
655 if(st->codec->codec_id==CODEC_ID_MJPEG){
656 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
657 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
658 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};
662 if(*p == st->codec->pix_fmt)
666 if(st->codec->pix_fmt != PIX_FMT_NONE)
667 av_log(NULL, AV_LOG_WARNING,
668 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
669 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
671 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
672 st->codec->pix_fmt = codec->pix_fmts[0];
678 get_sync_ipts(const OutputStream *ost)
680 const InputStream *ist = ost->sync_ist;
681 OutputFile *of = &output_files[ost->file_index];
682 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
685 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
689 AVPacket new_pkt= *pkt;
690 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
691 &new_pkt.data, &new_pkt.size,
692 pkt->data, pkt->size,
693 pkt->flags & AV_PKT_FLAG_KEY);
696 new_pkt.destruct= av_destruct_packet;
698 fprintf(stderr, "%s failed for stream %d, codec %s",
699 bsfc->filter->name, pkt->stream_index,
700 avctx->codec ? avctx->codec->name : "copy");
710 ret= av_interleaved_write_frame(s, pkt);
712 print_error("av_interleaved_write_frame()", ret);
717 static void do_audio_out(AVFormatContext *s,
720 unsigned char *buf, int size)
723 int64_t audio_out_size, audio_buf_size;
724 int64_t allocated_for_size= size;
726 int size_out, frame_bytes, ret, resample_changed;
727 AVCodecContext *enc= ost->st->codec;
728 AVCodecContext *dec= ist->st->codec;
729 int osize = av_get_bytes_per_sample(enc->sample_fmt);
730 int isize = av_get_bytes_per_sample(dec->sample_fmt);
731 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
734 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
735 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
736 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
737 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
738 audio_buf_size*= osize*enc->channels;
740 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
741 if(coded_bps > 8*osize)
742 audio_out_size= audio_out_size * coded_bps / (8*osize);
743 audio_out_size += FF_MIN_BUFFER_SIZE;
745 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
746 fprintf(stderr, "Buffer sizes too large\n");
750 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
751 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
752 if (!audio_buf || !audio_out){
753 fprintf(stderr, "Out of memory in do_audio_out\n");
757 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
758 ost->audio_resample = 1;
760 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
761 ost->resample_channels != dec->channels ||
762 ost->resample_sample_rate != dec->sample_rate;
764 if ((ost->audio_resample && !ost->resample) || resample_changed) {
765 if (resample_changed) {
766 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",
767 ist->file_index, ist->st->index,
768 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
769 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
770 ost->resample_sample_fmt = dec->sample_fmt;
771 ost->resample_channels = dec->channels;
772 ost->resample_sample_rate = dec->sample_rate;
774 audio_resample_close(ost->resample);
776 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
777 if (audio_sync_method <= 1 &&
778 ost->resample_sample_fmt == enc->sample_fmt &&
779 ost->resample_channels == enc->channels &&
780 ost->resample_sample_rate == enc->sample_rate) {
781 ost->resample = NULL;
782 ost->audio_resample = 0;
783 } else if (ost->audio_resample) {
784 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
785 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
786 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
787 enc->sample_rate, dec->sample_rate,
788 enc->sample_fmt, dec->sample_fmt,
790 if (!ost->resample) {
791 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
792 dec->channels, dec->sample_rate,
793 enc->channels, enc->sample_rate);
799 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
800 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
801 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
802 if (ost->reformat_ctx)
803 av_audio_convert_free(ost->reformat_ctx);
804 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
805 dec->sample_fmt, 1, NULL, 0);
806 if (!ost->reformat_ctx) {
807 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
808 av_get_sample_fmt_name(dec->sample_fmt),
809 av_get_sample_fmt_name(enc->sample_fmt));
812 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
815 if(audio_sync_method){
816 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
817 - av_fifo_size(ost->fifo)/(enc->channels * 2);
818 double idelta= delta*dec->sample_rate / enc->sample_rate;
819 int byte_delta= ((int)idelta)*2*dec->channels;
821 //FIXME resample delay
822 if(fabs(delta) > 50){
823 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
825 byte_delta= FFMAX(byte_delta, -size);
829 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
834 static uint8_t *input_tmp= NULL;
835 input_tmp= av_realloc(input_tmp, byte_delta + size);
837 if(byte_delta > allocated_for_size - size){
838 allocated_for_size= byte_delta + (int64_t)size;
843 memset(input_tmp, 0, byte_delta);
844 memcpy(input_tmp + byte_delta, buf, size);
848 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
850 }else if(audio_sync_method>1){
851 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
852 av_assert0(ost->audio_resample);
854 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
855 // 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));
856 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
860 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
861 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
863 if (ost->audio_resample) {
865 size_out = audio_resample(ost->resample,
866 (short *)buftmp, (short *)buf,
867 size / (dec->channels * isize));
868 size_out = size_out * enc->channels * osize;
874 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
875 const void *ibuf[6]= {buftmp};
876 void *obuf[6]= {audio_buf};
877 int istride[6]= {isize};
878 int ostride[6]= {osize};
879 int len= size_out/istride[0];
880 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
881 printf("av_audio_convert() failed\n");
887 size_out = len*osize;
890 /* now encode as many frames as possible */
891 if (enc->frame_size > 1) {
892 /* output resampled raw samples */
893 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
894 fprintf(stderr, "av_fifo_realloc2() failed\n");
897 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
899 frame_bytes = enc->frame_size * osize * enc->channels;
901 while (av_fifo_size(ost->fifo) >= frame_bytes) {
903 av_init_packet(&pkt);
905 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
907 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
909 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
912 fprintf(stderr, "Audio encoding failed\n");
916 pkt.stream_index= ost->index;
919 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
920 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
921 pkt.flags |= AV_PKT_FLAG_KEY;
922 write_frame(s, &pkt, enc, ost->bitstream_filters);
924 ost->sync_opts += enc->frame_size;
928 av_init_packet(&pkt);
930 ost->sync_opts += size_out / (osize * enc->channels);
932 /* output a pcm frame */
933 /* determine the size of the coded buffer */
936 size_out = size_out*coded_bps/8;
938 if(size_out > audio_out_size){
939 fprintf(stderr, "Internal error, buffer size too small\n");
943 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
944 ret = avcodec_encode_audio(enc, audio_out, size_out,
947 fprintf(stderr, "Audio encoding failed\n");
951 pkt.stream_index= ost->index;
954 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
955 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
956 pkt.flags |= AV_PKT_FLAG_KEY;
957 write_frame(s, &pkt, enc, ost->bitstream_filters);
961 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
965 AVPicture picture_tmp;
968 dec = ist->st->codec;
970 /* deinterlace : must be done before any resize */
971 if (do_deinterlace) {
974 /* create temporary picture */
975 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
976 buf = av_malloc(size);
980 picture2 = &picture_tmp;
981 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
983 if(avpicture_deinterlace(picture2, picture,
984 dec->pix_fmt, dec->width, dec->height) < 0) {
985 /* if error, do not deinterlace */
986 fprintf(stderr, "Deinterlacing failed\n");
995 if (picture != picture2)
996 *picture = *picture2;
1000 static void do_subtitle_out(AVFormatContext *s,
1006 static uint8_t *subtitle_out = NULL;
1007 int subtitle_out_max_size = 1024 * 1024;
1008 int subtitle_out_size, nb, i;
1009 AVCodecContext *enc;
1012 if (pts == AV_NOPTS_VALUE) {
1013 fprintf(stderr, "Subtitle packets must have a pts\n");
1019 enc = ost->st->codec;
1021 if (!subtitle_out) {
1022 subtitle_out = av_malloc(subtitle_out_max_size);
1025 /* Note: DVB subtitle need one packet to draw them and one other
1026 packet to clear them */
1027 /* XXX: signal it in the codec context ? */
1028 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1033 for(i = 0; i < nb; i++) {
1034 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1035 // start_display_time is required to be 0
1036 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1037 sub->end_display_time -= sub->start_display_time;
1038 sub->start_display_time = 0;
1039 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1040 subtitle_out_max_size, sub);
1041 if (subtitle_out_size < 0) {
1042 fprintf(stderr, "Subtitle encoding failed\n");
1046 av_init_packet(&pkt);
1047 pkt.stream_index = ost->index;
1048 pkt.data = subtitle_out;
1049 pkt.size = subtitle_out_size;
1050 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1051 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1052 /* XXX: the pts correction is handled here. Maybe handling
1053 it in the codec would be better */
1055 pkt.pts += 90 * sub->start_display_time;
1057 pkt.pts += 90 * sub->end_display_time;
1059 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1063 static int bit_buffer_size= 1024*256;
1064 static uint8_t *bit_buffer= NULL;
1066 static void do_video_resample(OutputStream *ost,
1068 AVFrame *in_picture,
1069 AVFrame **out_picture)
1071 int resample_changed = 0;
1072 AVCodecContext *dec = ist->st->codec;
1073 *out_picture = in_picture;
1075 resample_changed = ost->resample_width != dec->width ||
1076 ost->resample_height != dec->height ||
1077 ost->resample_pix_fmt != dec->pix_fmt;
1079 if (resample_changed) {
1080 av_log(NULL, AV_LOG_INFO,
1081 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1082 ist->file_index, ist->st->index,
1083 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1084 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1085 if(!ost->video_resample)
1086 ost->video_resample = 1;
1089 #if !CONFIG_AVFILTER
1090 if (ost->video_resample) {
1091 *out_picture = &ost->pict_tmp;
1092 if (resample_changed) {
1093 /* initialize a new scaler context */
1094 sws_freeContext(ost->img_resample_ctx);
1095 ost->img_resample_ctx = sws_getContext(
1096 ist->st->codec->width,
1097 ist->st->codec->height,
1098 ist->st->codec->pix_fmt,
1099 ost->st->codec->width,
1100 ost->st->codec->height,
1101 ost->st->codec->pix_fmt,
1102 ost->sws_flags, NULL, NULL, NULL);
1103 if (ost->img_resample_ctx == NULL) {
1104 fprintf(stderr, "Cannot get resampling context\n");
1108 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1109 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1112 if (resample_changed) {
1113 avfilter_graph_free(&ost->graph);
1114 if (configure_video_filters(ist, ost)) {
1115 fprintf(stderr, "Error reinitializing filters!\n");
1120 if (resample_changed) {
1121 ost->resample_width = dec->width;
1122 ost->resample_height = dec->height;
1123 ost->resample_pix_fmt = dec->pix_fmt;
1128 static void do_video_out(AVFormatContext *s,
1131 AVFrame *in_picture,
1132 int *frame_size, float quality)
1134 int nb_frames, i, ret, format_video_sync;
1135 AVFrame *final_picture;
1136 AVCodecContext *enc;
1139 enc = ost->st->codec;
1141 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1143 /* by default, we output a single frame */
1148 format_video_sync = video_sync_method;
1149 if (format_video_sync < 0)
1150 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1152 if (format_video_sync) {
1153 double vdelta = sync_ipts - ost->sync_opts;
1154 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1157 else if (format_video_sync == 2) {
1160 }else if(vdelta>0.6)
1161 ost->sync_opts= lrintf(sync_ipts);
1162 }else if (vdelta > 1.1)
1163 nb_frames = lrintf(vdelta);
1164 //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);
1165 if (nb_frames == 0){
1168 fprintf(stderr, "*** drop!\n");
1169 }else if (nb_frames > 1) {
1170 nb_frames_dup += nb_frames - 1;
1172 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1175 ost->sync_opts= lrintf(sync_ipts);
1177 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1181 do_video_resample(ost, ist, in_picture, &final_picture);
1183 /* duplicates frame if needed */
1184 for(i=0;i<nb_frames;i++) {
1186 av_init_packet(&pkt);
1187 pkt.stream_index= ost->index;
1189 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1190 /* raw pictures are written as AVPicture structure to
1191 avoid any copies. We support temporarily the older
1193 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1194 enc->coded_frame->top_field_first = in_picture->top_field_first;
1195 pkt.data= (uint8_t *)final_picture;
1196 pkt.size= sizeof(AVPicture);
1197 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1198 pkt.flags |= AV_PKT_FLAG_KEY;
1200 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1202 AVFrame big_picture;
1204 big_picture= *final_picture;
1205 /* better than nothing: use input picture interlaced
1207 big_picture.interlaced_frame = in_picture->interlaced_frame;
1208 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1209 if(top_field_first == -1)
1210 big_picture.top_field_first = in_picture->top_field_first;
1212 big_picture.top_field_first = top_field_first;
1215 /* handles same_quant here. This is not correct because it may
1216 not be a global option */
1217 big_picture.quality = quality;
1219 big_picture.pict_type = 0;
1220 // big_picture.pts = AV_NOPTS_VALUE;
1221 big_picture.pts= ost->sync_opts;
1222 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1223 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1224 if (ost->forced_kf_index < ost->forced_kf_count &&
1225 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1226 big_picture.pict_type = AV_PICTURE_TYPE_I;
1227 ost->forced_kf_index++;
1229 ret = avcodec_encode_video(enc,
1230 bit_buffer, bit_buffer_size,
1233 fprintf(stderr, "Video encoding failed\n");
1238 pkt.data= bit_buffer;
1240 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1241 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1242 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1243 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1244 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1246 if(enc->coded_frame->key_frame)
1247 pkt.flags |= AV_PKT_FLAG_KEY;
1248 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1251 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1252 // enc->frame_number-1, ret, enc->pict_type);
1253 /* if two pass, output log */
1254 if (ost->logfile && enc->stats_out) {
1255 fprintf(ost->logfile, "%s", enc->stats_out);
1260 ost->frame_number++;
1264 static double psnr(double d){
1265 return -10.0*log(d)/log(10.0);
1268 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1271 AVCodecContext *enc;
1273 double ti1, bitrate, avg_bitrate;
1275 /* this is executed just the first time do_video_stats is called */
1277 vstats_file = fopen(vstats_filename, "w");
1284 enc = ost->st->codec;
1285 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1286 frame_number = ost->frame_number;
1287 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1288 if (enc->flags&CODEC_FLAG_PSNR)
1289 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1291 fprintf(vstats_file,"f_size= %6d ", frame_size);
1292 /* compute pts value */
1293 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1297 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1298 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1299 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1300 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1301 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1305 static void print_report(OutputFile *output_files,
1306 OutputStream *ost_table, int nb_ostreams,
1307 int is_last_report, int64_t timer_start)
1311 AVFormatContext *oc;
1313 AVCodecContext *enc;
1314 int frame_number, vid, i;
1315 double bitrate, ti1, pts;
1316 static int64_t last_time = -1;
1317 static int qp_histogram[52];
1319 if (!is_last_report) {
1321 /* display the report every 0.5 seconds */
1322 cur_time = av_gettime();
1323 if (last_time == -1) {
1324 last_time = cur_time;
1327 if ((cur_time - last_time) < 500000)
1329 last_time = cur_time;
1333 oc = output_files[0].ctx;
1335 total_size = avio_size(oc->pb);
1336 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1337 total_size= avio_tell(oc->pb);
1342 for(i=0;i<nb_ostreams;i++) {
1344 ost = &ost_table[i];
1345 enc = ost->st->codec;
1346 if (!ost->st->stream_copy && enc->coded_frame)
1347 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1348 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1349 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1351 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1352 float t = (av_gettime()-timer_start) / 1000000.0;
1354 frame_number = ost->frame_number;
1355 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1356 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1358 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1362 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1365 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1367 if (enc->flags&CODEC_FLAG_PSNR){
1369 double error, error_sum=0;
1370 double scale, scale_sum=0;
1371 char type[3]= {'Y','U','V'};
1372 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1375 error= enc->error[j];
1376 scale= enc->width*enc->height*255.0*255.0*frame_number;
1378 error= enc->coded_frame->error[j];
1379 scale= enc->width*enc->height*255.0*255.0;
1384 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1386 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1390 /* compute min output value */
1391 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1392 if ((pts < ti1) && (pts > 0))
1398 if (verbose > 0 || is_last_report) {
1399 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1401 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1402 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1403 (double)total_size / 1024, ti1, bitrate);
1405 if (nb_frames_dup || nb_frames_drop)
1406 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1407 nb_frames_dup, nb_frames_drop);
1410 fprintf(stderr, "%s \r", buf);
1415 if (is_last_report && verbose >= 0){
1416 int64_t raw= audio_size + video_size + extra_size;
1417 fprintf(stderr, "\n");
1418 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1422 100.0*(total_size - raw)/raw
1427 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1429 int fill_char = 0x00;
1430 if (sample_fmt == AV_SAMPLE_FMT_U8)
1432 memset(buf, fill_char, size);
1435 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1439 for (i = 0; i < nb_ostreams; i++) {
1440 OutputStream *ost = &ost_table[i];
1441 AVCodecContext *enc = ost->st->codec;
1442 AVFormatContext *os = output_files[ost->file_index].ctx;
1444 if (!ost->encoding_needed)
1447 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1449 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1455 av_init_packet(&pkt);
1456 pkt.stream_index= ost->index;
1458 switch (ost->st->codec->codec_type) {
1459 case AVMEDIA_TYPE_AUDIO:
1460 fifo_bytes = av_fifo_size(ost->fifo);
1462 /* encode any samples remaining in fifo */
1463 if (fifo_bytes > 0) {
1464 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1465 int fs_tmp = enc->frame_size;
1467 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1468 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1469 enc->frame_size = fifo_bytes / (osize * enc->channels);
1471 int frame_bytes = enc->frame_size*osize*enc->channels;
1472 if (allocated_audio_buf_size < frame_bytes)
1474 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1477 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1478 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1479 ost->st->time_base.num, enc->sample_rate);
1480 enc->frame_size = fs_tmp;
1483 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1486 fprintf(stderr, "Audio encoding failed\n");
1490 pkt.flags |= AV_PKT_FLAG_KEY;
1492 case AVMEDIA_TYPE_VIDEO:
1493 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1495 fprintf(stderr, "Video encoding failed\n");
1499 if(enc->coded_frame && enc->coded_frame->key_frame)
1500 pkt.flags |= AV_PKT_FLAG_KEY;
1501 if (ost->logfile && enc->stats_out) {
1502 fprintf(ost->logfile, "%s", enc->stats_out);
1511 pkt.data = bit_buffer;
1513 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1514 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1515 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1520 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1521 static int output_packet(InputStream *ist, int ist_index,
1522 OutputStream *ost_table, int nb_ostreams,
1523 const AVPacket *pkt)
1525 AVFormatContext *os;
1530 void *buffer_to_free = NULL;
1531 static unsigned int samples_size= 0;
1532 AVSubtitle subtitle, *subtitle_to_free;
1533 int64_t pkt_pts = AV_NOPTS_VALUE;
1535 int frame_available;
1540 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1542 if(ist->next_pts == AV_NOPTS_VALUE)
1543 ist->next_pts= ist->pts;
1547 av_init_packet(&avpkt);
1555 if(pkt->dts != AV_NOPTS_VALUE)
1556 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1557 if(pkt->pts != AV_NOPTS_VALUE)
1558 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1560 //while we have more to decode or while the decoder did output something on EOF
1561 while (avpkt.size > 0 || (!pkt && got_output)) {
1562 uint8_t *data_buf, *decoded_data_buf;
1563 int data_size, decoded_data_size;
1565 ist->pts= ist->next_pts;
1567 if(avpkt.size && avpkt.size != pkt->size &&
1568 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1569 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1570 ist->showed_multi_packet_warning=1;
1573 /* decode the packet if needed */
1574 decoded_data_buf = NULL; /* fail safe */
1575 decoded_data_size= 0;
1576 data_buf = avpkt.data;
1577 data_size = avpkt.size;
1578 subtitle_to_free = NULL;
1579 if (ist->decoding_needed) {
1580 switch(ist->st->codec->codec_type) {
1581 case AVMEDIA_TYPE_AUDIO:{
1582 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1583 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1585 samples= av_malloc(samples_size);
1587 decoded_data_size= samples_size;
1588 /* XXX: could avoid copy if PCM 16 bits with same
1589 endianness as CPU */
1590 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1597 got_output = decoded_data_size > 0;
1598 /* Some bug in mpeg audio decoder gives */
1599 /* decoded_data_size < 0, it seems they are overflows */
1601 /* no audio frame */
1604 decoded_data_buf = (uint8_t *)samples;
1605 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1606 (ist->st->codec->sample_rate * ist->st->codec->channels);
1608 case AVMEDIA_TYPE_VIDEO:
1609 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1610 /* XXX: allocate picture correctly */
1611 avcodec_get_frame_defaults(&picture);
1612 avpkt.pts = pkt_pts;
1613 avpkt.dts = ist->pts;
1614 pkt_pts = AV_NOPTS_VALUE;
1616 ret = avcodec_decode_video2(ist->st->codec,
1617 &picture, &got_output, &avpkt);
1618 quality = same_quant ? picture.quality : 0;
1622 /* no picture yet */
1623 goto discard_packet;
1625 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1626 if (ist->st->codec->time_base.num != 0) {
1627 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1628 ist->next_pts += ((int64_t)AV_TIME_BASE *
1629 ist->st->codec->time_base.num * ticks) /
1630 ist->st->codec->time_base.den;
1633 buffer_to_free = NULL;
1634 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1636 case AVMEDIA_TYPE_SUBTITLE:
1637 ret = avcodec_decode_subtitle2(ist->st->codec,
1638 &subtitle, &got_output, &avpkt);
1642 goto discard_packet;
1644 subtitle_to_free = &subtitle;
1651 switch(ist->st->codec->codec_type) {
1652 case AVMEDIA_TYPE_AUDIO:
1653 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1654 ist->st->codec->sample_rate;
1656 case AVMEDIA_TYPE_VIDEO:
1657 if (ist->st->codec->time_base.num != 0) {
1658 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1659 ist->next_pts += ((int64_t)AV_TIME_BASE *
1660 ist->st->codec->time_base.num * ticks) /
1661 ist->st->codec->time_base.den;
1668 // preprocess audio (volume)
1669 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1670 if (audio_volume != 256) {
1673 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1674 int v = ((*volp) * audio_volume + 128) >> 8;
1675 *volp++ = av_clip_int16(v);
1680 /* frame rate emulation */
1682 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1683 int64_t now = av_gettime() - ist->start;
1687 /* if output time reached then transcode raw format,
1688 encode packets and output them */
1689 for (i = 0; i < nb_ostreams; i++) {
1690 OutputFile *of = &output_files[ost_table[i].file_index];
1693 ost = &ost_table[i];
1694 if (ost->source_index != ist_index)
1697 if (of->start_time && ist->pts < of->start_time)
1700 if (of->recording_time != INT64_MAX &&
1701 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1702 (AVRational){1, 1000000}) >= 0) {
1703 ost->is_past_recording_time = 1;
1708 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1709 ost->input_video_filter) {
1711 if (ist->st->sample_aspect_ratio.num)
1712 sar = ist->st->sample_aspect_ratio;
1714 sar = ist->st->codec->sample_aspect_ratio;
1715 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, ist->pts, sar);
1717 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1718 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1719 while (frame_available) {
1720 AVRational ist_pts_tb;
1721 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1722 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1724 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1726 os = output_files[ost->file_index].ctx;
1728 /* set the input output pts pairs */
1729 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1731 if (ost->encoding_needed) {
1732 av_assert0(ist->decoding_needed);
1733 switch(ost->st->codec->codec_type) {
1734 case AVMEDIA_TYPE_AUDIO:
1735 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1737 case AVMEDIA_TYPE_VIDEO:
1739 if (ost->picref->video && !ost->frame_aspect_ratio)
1740 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1742 do_video_out(os, ost, ist, &picture, &frame_size,
1743 same_quant ? quality : ost->st->codec->global_quality);
1744 if (vstats_filename && frame_size)
1745 do_video_stats(os, ost, frame_size);
1747 case AVMEDIA_TYPE_SUBTITLE:
1748 do_subtitle_out(os, ost, ist, &subtitle,
1755 AVFrame avframe; //FIXME/XXX remove this
1757 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1759 av_init_packet(&opkt);
1761 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1762 #if !CONFIG_AVFILTER
1768 /* no reencoding needed : output the packet directly */
1769 /* force the input stream PTS */
1771 avcodec_get_frame_defaults(&avframe);
1772 ost->st->codec->coded_frame= &avframe;
1773 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1775 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1776 audio_size += data_size;
1777 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1778 video_size += data_size;
1782 opkt.stream_index= ost->index;
1783 if(pkt->pts != AV_NOPTS_VALUE)
1784 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1786 opkt.pts= AV_NOPTS_VALUE;
1788 if (pkt->dts == AV_NOPTS_VALUE)
1789 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1791 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1792 opkt.dts -= ost_tb_start_time;
1794 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1795 opkt.flags= pkt->flags;
1797 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1798 if( ost->st->codec->codec_id != CODEC_ID_H264
1799 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1800 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1802 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1803 opkt.destruct= av_destruct_packet;
1805 opkt.data = data_buf;
1806 opkt.size = data_size;
1809 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1810 ost->st->codec->frame_number++;
1811 ost->frame_number++;
1812 av_free_packet(&opkt);
1816 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1817 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1819 avfilter_unref_buffer(ost->picref);
1824 av_free(buffer_to_free);
1825 /* XXX: allocate the subtitles in the codec ? */
1826 if (subtitle_to_free) {
1827 avsubtitle_free(subtitle_to_free);
1828 subtitle_to_free = NULL;
1836 static void print_sdp(OutputFile *output_files, int n)
1840 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1844 for (i = 0; i < n; i++)
1845 avc[i] = output_files[i].ctx;
1847 av_sdp_create(avc, n, sdp, sizeof(sdp));
1848 printf("SDP:\n%s\n", sdp);
1853 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1854 char *error, int error_len)
1857 InputStream *ist = &input_streams[ist_index];
1858 if (ist->decoding_needed) {
1859 AVCodec *codec = ist->dec;
1861 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1862 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1863 return AVERROR(EINVAL);
1866 /* update requested sample format for the decoder based on the
1867 corresponding encoder sample format */
1868 for (i = 0; i < nb_output_streams; i++) {
1869 OutputStream *ost = &output_streams[i];
1870 if (ost->source_index == ist_index) {
1871 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1876 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1877 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1878 ist->file_index, ist->st->index);
1879 return AVERROR(EINVAL);
1881 assert_codec_experimental(ist->st->codec, 0);
1882 assert_avoptions(ist->opts);
1885 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;
1886 ist->next_pts = AV_NOPTS_VALUE;
1887 init_pts_correction(&ist->pts_ctx);
1893 static int transcode_init(OutputFile *output_files,
1894 int nb_output_files,
1895 InputFile *input_files,
1899 AVFormatContext *os;
1900 AVCodecContext *codec, *icodec;
1907 for (i = 0; i < nb_input_streams; i++)
1908 input_streams[i].start = av_gettime();
1910 /* output stream init */
1911 for(i=0;i<nb_output_files;i++) {
1912 os = output_files[i].ctx;
1913 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1914 av_dump_format(os, i, os->filename, 1);
1915 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1916 return AVERROR(EINVAL);
1920 /* for each output stream, we compute the right encoding parameters */
1921 for (i = 0; i < nb_output_streams; i++) {
1922 ost = &output_streams[i];
1923 os = output_files[ost->file_index].ctx;
1924 ist = &input_streams[ost->source_index];
1926 codec = ost->st->codec;
1927 icodec = ist->st->codec;
1929 ost->st->disposition = ist->st->disposition;
1930 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1931 codec->chroma_sample_location = icodec->chroma_sample_location;
1933 if (ost->st->stream_copy) {
1934 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1936 if (extra_size > INT_MAX) {
1937 return AVERROR(EINVAL);
1940 /* if stream_copy is selected, no need to decode or encode */
1941 codec->codec_id = icodec->codec_id;
1942 codec->codec_type = icodec->codec_type;
1944 if(!codec->codec_tag){
1945 if( !os->oformat->codec_tag
1946 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1947 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1948 codec->codec_tag = icodec->codec_tag;
1951 codec->bit_rate = icodec->bit_rate;
1952 codec->rc_max_rate = icodec->rc_max_rate;
1953 codec->rc_buffer_size = icodec->rc_buffer_size;
1954 codec->extradata= av_mallocz(extra_size);
1955 if (!codec->extradata) {
1956 return AVERROR(ENOMEM);
1958 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1959 codec->extradata_size= icodec->extradata_size;
1960 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){
1961 codec->time_base = icodec->time_base;
1962 codec->time_base.num *= icodec->ticks_per_frame;
1963 av_reduce(&codec->time_base.num, &codec->time_base.den,
1964 codec->time_base.num, codec->time_base.den, INT_MAX);
1966 codec->time_base = ist->st->time_base;
1967 switch(codec->codec_type) {
1968 case AVMEDIA_TYPE_AUDIO:
1969 if(audio_volume != 256) {
1970 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1973 codec->channel_layout = icodec->channel_layout;
1974 codec->sample_rate = icodec->sample_rate;
1975 codec->channels = icodec->channels;
1976 codec->frame_size = icodec->frame_size;
1977 codec->audio_service_type = icodec->audio_service_type;
1978 codec->block_align= icodec->block_align;
1979 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1980 codec->block_align= 0;
1981 if(codec->codec_id == CODEC_ID_AC3)
1982 codec->block_align= 0;
1984 case AVMEDIA_TYPE_VIDEO:
1985 codec->pix_fmt = icodec->pix_fmt;
1986 codec->width = icodec->width;
1987 codec->height = icodec->height;
1988 codec->has_b_frames = icodec->has_b_frames;
1989 if (!codec->sample_aspect_ratio.num) {
1990 codec->sample_aspect_ratio =
1991 ost->st->sample_aspect_ratio =
1992 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1993 ist->st->codec->sample_aspect_ratio.num ?
1994 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
1997 case AVMEDIA_TYPE_SUBTITLE:
1998 codec->width = icodec->width;
1999 codec->height = icodec->height;
2001 case AVMEDIA_TYPE_DATA:
2008 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2009 switch(codec->codec_type) {
2010 case AVMEDIA_TYPE_AUDIO:
2011 ost->fifo= av_fifo_alloc(1024);
2013 return AVERROR(ENOMEM);
2015 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2016 if (!codec->sample_rate) {
2017 codec->sample_rate = icodec->sample_rate;
2019 codec->sample_rate >>= icodec->lowres;
2021 choose_sample_rate(ost->st, ost->enc);
2022 codec->time_base = (AVRational){1, codec->sample_rate};
2023 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2024 codec->sample_fmt = icodec->sample_fmt;
2025 choose_sample_fmt(ost->st, ost->enc);
2026 if (!codec->channels)
2027 codec->channels = icodec->channels;
2028 codec->channel_layout = icodec->channel_layout;
2029 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2030 codec->channel_layout = 0;
2031 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2032 icodec->request_channels = codec->channels;
2033 ist->decoding_needed = 1;
2034 ost->encoding_needed = 1;
2035 ost->resample_sample_fmt = icodec->sample_fmt;
2036 ost->resample_sample_rate = icodec->sample_rate;
2037 ost->resample_channels = icodec->channels;
2039 case AVMEDIA_TYPE_VIDEO:
2040 if (codec->pix_fmt == PIX_FMT_NONE)
2041 codec->pix_fmt = icodec->pix_fmt;
2042 choose_pixel_fmt(ost->st, ost->enc);
2044 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2045 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2049 if (!codec->width || !codec->height) {
2050 codec->width = icodec->width;
2051 codec->height = icodec->height;
2054 ost->video_resample = codec->width != icodec->width ||
2055 codec->height != icodec->height ||
2056 codec->pix_fmt != icodec->pix_fmt;
2057 if (ost->video_resample) {
2058 #if !CONFIG_AVFILTER
2059 avcodec_get_frame_defaults(&ost->pict_tmp);
2060 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2061 codec->width, codec->height)) {
2062 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2065 ost->img_resample_ctx = sws_getContext(
2072 ost->sws_flags, NULL, NULL, NULL);
2073 if (ost->img_resample_ctx == NULL) {
2074 fprintf(stderr, "Cannot get resampling context\n");
2078 codec->bits_per_raw_sample= 0;
2081 ost->resample_height = icodec->height;
2082 ost->resample_width = icodec->width;
2083 ost->resample_pix_fmt= icodec->pix_fmt;
2084 ost->encoding_needed = 1;
2085 ist->decoding_needed = 1;
2087 if (!ost->frame_rate.num)
2088 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2089 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2090 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2091 ost->frame_rate = ost->enc->supported_framerates[idx];
2093 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2096 if (configure_video_filters(ist, ost)) {
2097 fprintf(stderr, "Error opening filters!\n");
2102 case AVMEDIA_TYPE_SUBTITLE:
2103 ost->encoding_needed = 1;
2104 ist->decoding_needed = 1;
2111 if (ost->encoding_needed &&
2112 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2113 char logfilename[1024];
2116 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2117 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2119 if (codec->flags & CODEC_FLAG_PASS1) {
2120 f = fopen(logfilename, "wb");
2122 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2128 size_t logbuffer_size;
2129 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2130 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2133 codec->stats_in = logbuffer;
2137 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2138 int size= codec->width * codec->height;
2139 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2144 bit_buffer = av_malloc(bit_buffer_size);
2146 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2148 return AVERROR(ENOMEM);
2151 /* open each encoder */
2152 for (i = 0; i < nb_output_streams; i++) {
2153 ost = &output_streams[i];
2154 if (ost->encoding_needed) {
2155 AVCodec *codec = ost->enc;
2156 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2158 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2159 ost->st->codec->codec_id, ost->file_index, ost->index);
2160 ret = AVERROR(EINVAL);
2163 if (dec->subtitle_header) {
2164 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2165 if (!ost->st->codec->subtitle_header) {
2166 ret = AVERROR(ENOMEM);
2169 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2170 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2172 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2173 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2174 ost->file_index, ost->index);
2175 ret = AVERROR(EINVAL);
2178 assert_codec_experimental(ost->st->codec, 1);
2179 assert_avoptions(ost->opts);
2180 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2181 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2182 "It takes bits/s as argument, not kbits/s\n");
2183 extra_size += ost->st->codec->extradata_size;
2187 /* init input streams */
2188 for (i = 0; i < nb_input_streams; i++)
2189 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2192 /* open files and write file headers */
2193 for (i = 0; i < nb_output_files; i++) {
2194 os = output_files[i].ctx;
2195 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2196 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2197 ret = AVERROR(EINVAL);
2200 assert_avoptions(output_files[i].opts);
2201 if (strcmp(os->oformat->name, "rtp")) {
2207 /* dump the file output parameters - cannot be done before in case
2209 for(i=0;i<nb_output_files;i++) {
2210 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2213 /* dump the stream mapping */
2215 fprintf(stderr, "Stream mapping:\n");
2216 for (i = 0; i < nb_output_streams;i ++) {
2217 ost = &output_streams[i];
2218 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2219 input_streams[ost->source_index].file_index,
2220 input_streams[ost->source_index].st->index,
2223 if (ost->sync_ist != &input_streams[ost->source_index])
2224 fprintf(stderr, " [sync #%d.%d]",
2225 ost->sync_ist->file_index,
2226 ost->sync_ist->st->index);
2227 if (ost->st->stream_copy)
2228 fprintf(stderr, " (copy)");
2230 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2231 input_streams[ost->source_index].dec->name : "?",
2232 ost->enc ? ost->enc->name : "?");
2233 fprintf(stderr, "\n");
2238 fprintf(stderr, "%s\n", error);
2243 print_sdp(output_files, nb_output_files);
2250 * The following code is the main loop of the file converter
2252 static int transcode(OutputFile *output_files,
2253 int nb_output_files,
2254 InputFile *input_files,
2258 AVFormatContext *is, *os;
2262 int no_packet_count=0;
2263 int64_t timer_start;
2265 if (!(no_packet = av_mallocz(nb_input_files)))
2268 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2273 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2276 timer_start = av_gettime();
2278 for(; received_sigterm == 0;) {
2279 int file_index, ist_index;
2284 ipts_min = INT64_MAX;
2287 /* select the stream that we must read now by looking at the
2288 smallest output pts */
2290 for (i = 0; i < nb_output_streams; i++) {
2294 ost = &output_streams[i];
2295 of = &output_files[ost->file_index];
2296 os = output_files[ost->file_index].ctx;
2297 ist = &input_streams[ost->source_index];
2298 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2299 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2301 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2303 if (!input_files[ist->file_index].eof_reached){
2304 if(ipts < ipts_min) {
2306 if(input_sync ) file_index = ist->file_index;
2308 if(opts < opts_min) {
2310 if(!input_sync) file_index = ist->file_index;
2313 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2318 /* if none, if is finished */
2319 if (file_index < 0) {
2320 if(no_packet_count){
2322 memset(no_packet, 0, nb_input_files);
2329 /* read a frame from it and output it in the fifo */
2330 is = input_files[file_index].ctx;
2331 ret= av_read_frame(is, &pkt);
2332 if(ret == AVERROR(EAGAIN)){
2333 no_packet[file_index]=1;
2338 input_files[file_index].eof_reached = 1;
2346 memset(no_packet, 0, nb_input_files);
2349 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2350 is->streams[pkt.stream_index]);
2352 /* the following test is needed in case new streams appear
2353 dynamically in stream : we ignore them */
2354 if (pkt.stream_index >= input_files[file_index].nb_streams)
2355 goto discard_packet;
2356 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2357 ist = &input_streams[ist_index];
2359 goto discard_packet;
2361 if (pkt.dts != AV_NOPTS_VALUE)
2362 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2363 if (pkt.pts != AV_NOPTS_VALUE)
2364 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2366 if(pkt.pts != AV_NOPTS_VALUE)
2367 pkt.pts *= ist->ts_scale;
2368 if(pkt.dts != AV_NOPTS_VALUE)
2369 pkt.dts *= ist->ts_scale;
2371 // 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);
2372 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2373 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2374 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2375 int64_t delta= pkt_dts - ist->next_pts;
2376 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2377 input_files[ist->file_index].ts_offset -= delta;
2379 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2380 delta, input_files[ist->file_index].ts_offset);
2381 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2382 if(pkt.pts != AV_NOPTS_VALUE)
2383 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2387 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2388 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2391 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2392 ist->file_index, ist->st->index);
2395 av_free_packet(&pkt);
2400 av_free_packet(&pkt);
2402 /* dump report by using the output first video and audio streams */
2403 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2406 /* at the end of stream, we must flush the decoder buffers */
2407 for (i = 0; i < nb_input_streams; i++) {
2408 ist = &input_streams[i];
2409 if (ist->decoding_needed) {
2410 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2413 flush_encoders(output_streams, nb_output_streams);
2417 /* write the trailer if needed and close file */
2418 for(i=0;i<nb_output_files;i++) {
2419 os = output_files[i].ctx;
2420 av_write_trailer(os);
2423 /* dump report by using the first video and audio streams */
2424 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2426 /* close each encoder */
2427 for (i = 0; i < nb_output_streams; i++) {
2428 ost = &output_streams[i];
2429 if (ost->encoding_needed) {
2430 av_freep(&ost->st->codec->stats_in);
2431 avcodec_close(ost->st->codec);
2434 avfilter_graph_free(&ost->graph);
2438 /* close each decoder */
2439 for (i = 0; i < nb_input_streams; i++) {
2440 ist = &input_streams[i];
2441 if (ist->decoding_needed) {
2442 avcodec_close(ist->st->codec);
2450 av_freep(&bit_buffer);
2451 av_freep(&no_packet);
2453 if (output_streams) {
2454 for (i = 0; i < nb_output_streams; i++) {
2455 ost = &output_streams[i];
2457 if (ost->st->stream_copy)
2458 av_freep(&ost->st->codec->extradata);
2460 fclose(ost->logfile);
2461 ost->logfile = NULL;
2463 av_fifo_free(ost->fifo); /* works even if fifo is not
2464 initialized but set to zero */
2465 av_freep(&ost->st->codec->subtitle_header);
2466 av_free(ost->pict_tmp.data[0]);
2467 av_free(ost->forced_kf_pts);
2468 if (ost->video_resample)
2469 sws_freeContext(ost->img_resample_ctx);
2471 audio_resample_close(ost->resample);
2472 if (ost->reformat_ctx)
2473 av_audio_convert_free(ost->reformat_ctx);
2474 av_dict_free(&ost->opts);
2481 static int opt_video_rc_override_string(const char *opt, const char *arg)
2483 video_rc_override_string = arg;
2487 static int opt_me_threshold(const char *opt, const char *arg)
2489 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2493 static int opt_verbose(const char *opt, const char *arg)
2495 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2499 static int opt_frame_rate(const char *opt, const char *arg)
2501 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2502 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2508 static int opt_frame_size(const char *opt, const char *arg)
2510 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2511 fprintf(stderr, "Incorrect frame size\n");
2512 return AVERROR(EINVAL);
2517 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2519 if (strcmp(arg, "list")) {
2520 frame_pix_fmt = av_get_pix_fmt(arg);
2521 if (frame_pix_fmt == PIX_FMT_NONE) {
2522 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2523 return AVERROR(EINVAL);
2532 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2539 p = strchr(arg, ':');
2541 x = strtol(arg, &end, 10);
2543 y = strtol(end+1, &end, 10);
2545 ar = (double)x / (double)y;
2547 ar = strtod(arg, NULL);
2550 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2551 return AVERROR(EINVAL);
2553 frame_aspect_ratio = ar;
2557 static int opt_qscale(const char *opt, const char *arg)
2559 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2560 if (video_qscale == 0) {
2561 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2562 return AVERROR(EINVAL);
2567 static int opt_top_field_first(const char *opt, const char *arg)
2569 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2573 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2575 if (strcmp(arg, "list")) {
2576 audio_sample_fmt = av_get_sample_fmt(arg);
2577 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2578 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2579 return AVERROR(EINVAL);
2584 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2585 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2591 static int opt_audio_rate(const char *opt, const char *arg)
2593 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2597 static int opt_audio_channels(const char *opt, const char *arg)
2599 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2603 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2605 return parse_option(o, "codec:a", arg, options);
2608 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2610 return parse_option(o, "codec:v", arg, options);
2613 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2615 return parse_option(o, "codec:s", arg, options);
2618 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2620 return parse_option(o, "codec:d", arg, options);
2623 static int opt_codec_tag(const char *opt, const char *arg)
2626 uint32_t *codec_tag;
2628 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2629 !strcmp(opt, "vtag") ? &video_codec_tag :
2630 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2634 *codec_tag = strtol(arg, &tail, 0);
2636 *codec_tag = AV_RL32(arg);
2641 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2643 StreamMap *m = NULL;
2644 int i, negative = 0, file_idx;
2645 int sync_file_idx = -1, sync_stream_idx;
2653 map = av_strdup(arg);
2655 /* parse sync stream first, just pick first matching stream */
2656 if (sync = strchr(map, ',')) {
2658 sync_file_idx = strtol(sync + 1, &sync, 0);
2659 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2660 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2665 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2666 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2667 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2668 sync_stream_idx = i;
2671 if (i == input_files[sync_file_idx].nb_streams) {
2672 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2673 "match any streams.\n", arg);
2679 file_idx = strtol(map, &p, 0);
2680 if (file_idx >= nb_input_files || file_idx < 0) {
2681 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2685 /* disable some already defined maps */
2686 for (i = 0; i < o->nb_stream_maps; i++) {
2687 m = &o->stream_maps[i];
2688 if (check_stream_specifier(input_files[m->file_index].ctx,
2689 input_files[m->file_index].ctx->streams[m->stream_index],
2690 *p == ':' ? p + 1 : p) > 0)
2694 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2695 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2696 *p == ':' ? p + 1 : p) <= 0)
2698 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2699 &o->nb_stream_maps, o->nb_stream_maps + 1);
2700 m = &o->stream_maps[o->nb_stream_maps - 1];
2702 m->file_index = file_idx;
2703 m->stream_index = i;
2705 if (sync_file_idx >= 0) {
2706 m->sync_file_index = sync_file_idx;
2707 m->sync_stream_index = sync_stream_idx;
2709 m->sync_file_index = file_idx;
2710 m->sync_stream_index = i;
2715 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2723 static void parse_meta_type(char *arg, char *type, int *index)
2733 if (*(++arg) == ':')
2734 *index = strtol(++arg, NULL, 0);
2737 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2744 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2746 MetadataMap *m, *m1;
2749 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2750 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2752 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2753 m->file = strtol(arg, &p, 0);
2754 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2756 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2757 if (p = strchr(opt, ':'))
2758 parse_meta_type(p + 1, &m1->type, &m1->index);
2762 if (m->type == 'g' || m1->type == 'g')
2763 o->metadata_global_manual = 1;
2764 if (m->type == 's' || m1->type == 's')
2765 o->metadata_streams_manual = 1;
2766 if (m->type == 'c' || m1->type == 'c')
2767 o->metadata_chapters_manual = 1;
2772 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2774 const char *codec_string = encoder ? "encoder" : "decoder";
2778 return CODEC_ID_NONE;
2780 avcodec_find_encoder_by_name(name) :
2781 avcodec_find_decoder_by_name(name);
2783 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2786 if(codec->type != type) {
2787 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2793 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2795 char *codec_name = NULL;
2797 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2801 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2802 return avcodec_find_encoder(st->codec->codec_id);
2804 } else if (!strcmp(codec_name, "copy"))
2805 st->stream_copy = 1;
2807 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2808 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2809 avcodec_find_decoder_by_name(codec_name);
2816 * Add all the streams from the given input file to the global
2817 * list of input streams.
2819 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2821 int i, rfps, rfps_base;
2823 for (i = 0; i < ic->nb_streams; i++) {
2824 AVStream *st = ic->streams[i];
2825 AVCodecContext *dec = st->codec;
2829 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2830 ist = &input_streams[nb_input_streams - 1];
2832 ist->file_index = nb_input_files;
2834 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2836 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2837 ist->ts_scale = scale;
2839 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2841 ist->dec = avcodec_find_decoder(dec->codec_id);
2843 switch (dec->codec_type) {
2844 case AVMEDIA_TYPE_AUDIO:
2846 st->discard= AVDISCARD_ALL;
2848 case AVMEDIA_TYPE_VIDEO:
2849 rfps = ic->streams[i]->r_frame_rate.num;
2850 rfps_base = ic->streams[i]->r_frame_rate.den;
2852 dec->flags |= CODEC_FLAG_EMU_EDGE;
2853 dec->height >>= dec->lowres;
2854 dec->width >>= dec->lowres;
2857 dec->debug |= FF_DEBUG_MV;
2859 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2862 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2863 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2865 (float)rfps / rfps_base, rfps, rfps_base);
2869 st->discard= AVDISCARD_ALL;
2870 else if(video_discard)
2871 st->discard= video_discard;
2873 case AVMEDIA_TYPE_DATA:
2875 case AVMEDIA_TYPE_SUBTITLE:
2876 if(subtitle_disable)
2877 st->discard = AVDISCARD_ALL;
2879 case AVMEDIA_TYPE_ATTACHMENT:
2880 case AVMEDIA_TYPE_UNKNOWN:
2888 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2890 AVFormatContext *ic;
2891 AVInputFormat *file_iformat = NULL;
2895 AVDictionary **opts;
2896 int orig_nb_streams; // number of streams before avformat_find_stream_info
2899 if (!(file_iformat = av_find_input_format(o->format))) {
2900 fprintf(stderr, "Unknown input format: '%s'\n", o->format);
2905 if (!strcmp(filename, "-"))
2908 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2909 !strcmp(filename, "/dev/stdin");
2911 /* get default parameters from command line */
2912 ic = avformat_alloc_context();
2914 print_error(filename, AVERROR(ENOMEM));
2917 if (audio_sample_rate) {
2918 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
2919 av_dict_set(&format_opts, "sample_rate", buf, 0);
2921 if (audio_channels) {
2922 snprintf(buf, sizeof(buf), "%d", audio_channels);
2923 av_dict_set(&format_opts, "channels", buf, 0);
2925 if (frame_rate.num) {
2926 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
2927 av_dict_set(&format_opts, "framerate", buf, 0);
2929 if (frame_width && frame_height) {
2930 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
2931 av_dict_set(&format_opts, "video_size", buf, 0);
2933 if (frame_pix_fmt != PIX_FMT_NONE)
2934 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
2936 ic->flags |= AVFMT_FLAG_NONBLOCK;
2938 /* open the input file with generic libav function */
2939 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2941 print_error(filename, err);
2944 assert_avoptions(format_opts);
2949 for(i=0; i<ic->nb_streams; i++){
2950 ic->streams[i]->discard= AVDISCARD_ALL;
2952 for(i=0; i<ic->nb_programs; i++){
2953 AVProgram *p= ic->programs[i];
2954 if(p->id != opt_programid){
2955 p->discard = AVDISCARD_ALL;
2958 for(j=0; j<p->nb_stream_indexes; j++){
2959 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
2964 fprintf(stderr, "Specified program id not found\n");
2970 /* apply forced codec ids */
2971 for (i = 0; i < ic->nb_streams; i++)
2972 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
2974 /* Set AVCodecContext options for avformat_find_stream_info */
2975 opts = setup_find_stream_info_opts(ic, codec_opts);
2976 orig_nb_streams = ic->nb_streams;
2978 /* If not enough info to get the stream parameters, we decode the
2979 first frames to get it. (used in mpeg case for example) */
2980 ret = avformat_find_stream_info(ic, opts);
2981 if (ret < 0 && verbose >= 0) {
2982 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2983 av_close_input_file(ic);
2987 timestamp = o->start_time;
2988 /* add the stream start time */
2989 if (ic->start_time != AV_NOPTS_VALUE)
2990 timestamp += ic->start_time;
2992 /* if seeking requested, we execute it */
2993 if (o->start_time != 0) {
2994 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2996 fprintf(stderr, "%s: could not seek to position %0.3f\n",
2997 filename, (double)timestamp / AV_TIME_BASE);
3001 /* update the current parameters so that they match the one of the input stream */
3002 add_input_streams(o, ic);
3004 /* dump the file content */
3006 av_dump_format(ic, nb_input_files, filename, 0);
3008 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3009 input_files[nb_input_files - 1].ctx = ic;
3010 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3011 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3012 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3014 frame_rate = (AVRational){0, 0};
3015 frame_pix_fmt = PIX_FMT_NONE;
3018 audio_sample_rate = 0;
3020 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3022 for (i = 0; i < orig_nb_streams; i++)
3023 av_dict_free(&opts[i]);
3030 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3031 AVCodecContext *avctx)
3037 for (p = kf; *p; p++)
3040 ost->forced_kf_count = n;
3041 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3042 if (!ost->forced_kf_pts) {
3043 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3046 for (i = 0; i < n; i++) {
3047 p = i ? strchr(p, ',') + 1 : kf;
3048 t = parse_time_or_die("force_key_frames", p, 1);
3049 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3053 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3056 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3057 int idx = oc->nb_streams - 1;
3060 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3064 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3065 nb_output_streams + 1);
3066 ost = &output_streams[nb_output_streams - 1];
3067 ost->file_index = nb_output_files;
3070 st->codec->codec_type = type;
3071 ost->enc = choose_codec(o, oc, st, type);
3073 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3076 avcodec_get_context_defaults3(st->codec, ost->enc);
3077 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3079 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3083 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3087 AVCodecContext *video_enc;
3089 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3091 if (!st->stream_copy) {
3092 ost->frame_aspect_ratio = frame_aspect_ratio;
3093 frame_aspect_ratio = 0;
3095 ost->avfilter= vfilters;
3100 ost->bitstream_filters = video_bitstream_filters;
3101 video_bitstream_filters= NULL;
3103 video_enc = st->codec;
3106 video_enc->codec_tag= video_codec_tag;
3108 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3109 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3112 if (st->stream_copy) {
3113 video_enc->sample_aspect_ratio =
3114 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3120 ost->frame_rate = frame_rate;
3122 video_enc->width = frame_width;
3123 video_enc->height = frame_height;
3124 video_enc->pix_fmt = frame_pix_fmt;
3125 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3127 if (video_qscale || same_quant) {
3128 video_enc->flags |= CODEC_FLAG_QSCALE;
3129 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3133 video_enc->intra_matrix = intra_matrix;
3135 video_enc->inter_matrix = inter_matrix;
3137 p= video_rc_override_string;
3140 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3142 fprintf(stderr, "error parsing rc_override\n");
3145 video_enc->rc_override=
3146 av_realloc(video_enc->rc_override,
3147 sizeof(RcOverride)*(i+1));
3148 video_enc->rc_override[i].start_frame= start;
3149 video_enc->rc_override[i].end_frame = end;
3151 video_enc->rc_override[i].qscale= q;
3152 video_enc->rc_override[i].quality_factor= 1.0;
3155 video_enc->rc_override[i].qscale= 0;
3156 video_enc->rc_override[i].quality_factor= -q/100.0;
3161 video_enc->rc_override_count=i;
3162 if (!video_enc->rc_initial_buffer_occupancy)
3163 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3164 video_enc->me_threshold= me_threshold;
3165 video_enc->intra_dc_precision= intra_dc_precision - 8;
3168 video_enc->flags|= CODEC_FLAG_PSNR;
3173 video_enc->flags |= CODEC_FLAG_PASS1;
3175 video_enc->flags |= CODEC_FLAG_PASS2;
3179 if (forced_key_frames)
3180 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3182 if (video_language) {
3183 av_dict_set(&st->metadata, "language", video_language, 0);
3184 av_freep(&video_language);
3187 /* reset some key parameters */
3189 av_freep(&forced_key_frames);
3190 frame_pix_fmt = PIX_FMT_NONE;
3194 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3198 AVCodecContext *audio_enc;
3200 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3203 ost->bitstream_filters = audio_bitstream_filters;
3204 audio_bitstream_filters= NULL;
3206 audio_enc = st->codec;
3207 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3210 audio_enc->codec_tag= audio_codec_tag;
3212 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3213 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3215 if (!st->stream_copy) {
3216 if (audio_qscale > QSCALE_NONE) {
3217 audio_enc->flags |= CODEC_FLAG_QSCALE;
3218 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3221 audio_enc->channels = audio_channels;
3222 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3223 audio_enc->sample_fmt = audio_sample_fmt;
3224 if (audio_sample_rate)
3225 audio_enc->sample_rate = audio_sample_rate;
3227 if (audio_language) {
3228 av_dict_set(&st->metadata, "language", audio_language, 0);
3229 av_freep(&audio_language);
3232 /* reset some key parameters */
3238 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3242 AVCodecContext *data_enc;
3244 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3246 data_enc = st->codec;
3247 if (!st->stream_copy) {
3248 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3253 data_enc->codec_tag= data_codec_tag;
3255 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3256 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3263 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3267 AVCodecContext *subtitle_enc;
3269 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3271 subtitle_enc = st->codec;
3273 ost->bitstream_filters = subtitle_bitstream_filters;
3274 subtitle_bitstream_filters= NULL;
3276 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3278 if(subtitle_codec_tag)
3279 subtitle_enc->codec_tag= subtitle_codec_tag;
3281 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3282 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3285 if (subtitle_language) {
3286 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3287 av_freep(&subtitle_language);
3290 subtitle_disable = 0;
3294 /* arg format is "output-stream-index:streamid-value". */
3295 static int opt_streamid(const char *opt, const char *arg)
3301 av_strlcpy(idx_str, arg, sizeof(idx_str));
3302 p = strchr(idx_str, ':');
3305 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3310 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3311 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3312 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3316 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3318 AVFormatContext *is = ifile->ctx;
3319 AVFormatContext *os = ofile->ctx;
3322 for (i = 0; i < is->nb_chapters; i++) {
3323 AVChapter *in_ch = is->chapters[i], *out_ch;
3324 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3325 AV_TIME_BASE_Q, in_ch->time_base);
3326 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3327 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3330 if (in_ch->end < ts_off)
3332 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3335 out_ch = av_mallocz(sizeof(AVChapter));
3337 return AVERROR(ENOMEM);
3339 out_ch->id = in_ch->id;
3340 out_ch->time_base = in_ch->time_base;
3341 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3342 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3345 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3348 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3350 return AVERROR(ENOMEM);
3351 os->chapters[os->nb_chapters - 1] = out_ch;
3356 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3359 AVFormatContext *ic = NULL;
3361 err = avformat_open_input(&ic, filename, NULL, NULL);
3364 /* copy stream format */
3365 for(i=0;i<ic->nb_streams;i++) {
3370 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3371 ost = new_output_stream(o, s, codec->type);
3374 // FIXME: a more elegant solution is needed
3375 memcpy(st, ic->streams[i], sizeof(AVStream));
3377 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3379 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3380 choose_sample_fmt(st, codec);
3381 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3382 choose_pixel_fmt(st, codec);
3385 av_close_input_file(ic);
3389 static void opt_output_file(void *optctx, const char *filename)
3391 OptionsContext *o = optctx;
3392 AVFormatContext *oc;
3394 AVOutputFormat *file_oformat;
3398 if (!strcmp(filename, "-"))
3401 oc = avformat_alloc_context();
3403 print_error(filename, AVERROR(ENOMEM));
3408 file_oformat = av_guess_format(o->format, NULL, NULL);
3409 if (!file_oformat) {
3410 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", o->format);
3414 file_oformat = av_guess_format(NULL, filename, NULL);
3415 if (!file_oformat) {
3416 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3422 oc->oformat = file_oformat;
3423 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3425 if (!strcmp(file_oformat->name, "ffm") &&
3426 av_strstart(filename, "http:", NULL)) {
3427 /* special case for files sent to avserver: we get the stream
3428 parameters from avserver */
3429 int err = read_avserver_streams(o, oc, filename);
3431 print_error(filename, err);
3434 } else if (!o->nb_stream_maps) {
3435 /* pick the "best" stream of each type */
3436 #define NEW_STREAM(type, index)\
3438 ost = new_ ## type ## _stream(o, oc);\
3439 ost->source_index = index;\
3440 ost->sync_ist = &input_streams[index];\
3441 input_streams[index].discard = 0;\
3444 /* video: highest resolution */
3445 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3446 int area = 0, idx = -1;
3447 for (i = 0; i < nb_input_streams; i++) {
3448 ist = &input_streams[i];
3449 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3450 ist->st->codec->width * ist->st->codec->height > area) {
3451 area = ist->st->codec->width * ist->st->codec->height;
3455 NEW_STREAM(video, idx);
3458 /* audio: most channels */
3459 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3460 int channels = 0, idx = -1;
3461 for (i = 0; i < nb_input_streams; i++) {
3462 ist = &input_streams[i];
3463 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3464 ist->st->codec->channels > channels) {
3465 channels = ist->st->codec->channels;
3469 NEW_STREAM(audio, idx);
3472 /* subtitles: pick first */
3473 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3474 for (i = 0; i < nb_input_streams; i++)
3475 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3476 NEW_STREAM(subtitle, i);
3480 /* do something with data? */
3482 for (i = 0; i < o->nb_stream_maps; i++) {
3483 StreamMap *map = &o->stream_maps[i];
3488 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3489 switch (ist->st->codec->codec_type) {
3490 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3491 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3492 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3493 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3495 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3496 map->file_index, map->stream_index);
3500 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3501 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3502 map->sync_stream_index];
3507 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3508 output_files[nb_output_files - 1].ctx = oc;
3509 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3510 output_files[nb_output_files - 1].recording_time = o->recording_time;
3511 output_files[nb_output_files - 1].start_time = o->start_time;
3512 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3513 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3515 /* check filename in case of an image number is expected */
3516 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3517 if (!av_filename_number_test(oc->filename)) {
3518 print_error(oc->filename, AVERROR(EINVAL));
3523 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3524 /* test if it already exists to avoid loosing precious files */
3525 if (!file_overwrite &&
3526 (strchr(filename, ':') == NULL ||
3527 filename[1] == ':' ||
3528 av_strstart(filename, "file:", NULL))) {
3529 if (avio_check(filename, 0) == 0) {
3531 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3533 if (!read_yesno()) {
3534 fprintf(stderr, "Not overwriting - exiting\n");
3539 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3546 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3547 print_error(filename, err);
3552 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3553 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3554 oc->flags |= AVFMT_FLAG_NONBLOCK;
3557 if (o->chapters_input_file >= nb_input_files) {
3558 if (o->chapters_input_file == INT_MAX) {
3559 /* copy chapters from the first input file that has them*/
3560 o->chapters_input_file = -1;
3561 for (i = 0; i < nb_input_files; i++)
3562 if (input_files[i].ctx->nb_chapters) {
3563 o->chapters_input_file = i;
3567 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3568 o->chapters_input_file);
3572 if (o->chapters_input_file >= 0)
3573 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3574 o->metadata_chapters_manual);
3577 for (i = 0; i < o->nb_meta_data_maps; i++) {
3578 AVFormatContext *files[2];
3579 AVDictionary **meta[2];
3582 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3583 if ((index) < 0 || (index) >= (nb_elems)) {\
3584 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3589 int in_file_index = o->meta_data_maps[i][1].file;
3590 if (in_file_index < 0)
3592 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3595 files[1] = input_files[in_file_index].ctx;
3597 for (j = 0; j < 2; j++) {
3598 MetadataMap *map = &o->meta_data_maps[i][j];
3600 switch (map->type) {
3602 meta[j] = &files[j]->metadata;
3605 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3606 meta[j] = &files[j]->streams[map->index]->metadata;
3609 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3610 meta[j] = &files[j]->chapters[map->index]->metadata;
3613 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3614 meta[j] = &files[j]->programs[map->index]->metadata;
3619 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3622 /* copy global metadata by default */
3623 if (!o->metadata_global_manual && nb_input_files)
3624 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3625 AV_DICT_DONT_OVERWRITE);
3626 if (!o->metadata_streams_manual)
3627 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3628 InputStream *ist = &input_streams[output_streams[i].source_index];
3629 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3632 /* process manually set metadata */
3633 for (i = 0; i < o->nb_metadata; i++) {
3638 val = strchr(o->metadata[i].u.str, '=');
3640 av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3641 o->metadata[i].u.str);
3646 parse_meta_type(o->metadata[i].specifier, &type, &index);
3652 if (index < 0 || index >= oc->nb_streams) {
3653 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3656 m = &oc->streams[i]->metadata;
3659 if (index < 0 || index >= oc->nb_chapters) {
3660 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3663 m = &oc->chapters[i]->metadata;
3666 av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3670 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3673 frame_rate = (AVRational){0, 0};
3676 audio_sample_rate = 0;
3678 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3680 av_freep(&streamid_map);
3681 nb_streamid_map = 0;
3683 av_freep(&forced_key_frames);
3687 /* same option as mencoder */
3688 static int opt_pass(const char *opt, const char *arg)
3690 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3694 static int64_t getutime(void)
3697 struct rusage rusage;
3699 getrusage(RUSAGE_SELF, &rusage);
3700 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3701 #elif HAVE_GETPROCESSTIMES
3703 FILETIME c, e, k, u;
3704 proc = GetCurrentProcess();
3705 GetProcessTimes(proc, &c, &e, &k, &u);
3706 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3708 return av_gettime();
3712 static int64_t getmaxrss(void)
3714 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3715 struct rusage rusage;
3716 getrusage(RUSAGE_SELF, &rusage);
3717 return (int64_t)rusage.ru_maxrss * 1024;
3718 #elif HAVE_GETPROCESSMEMORYINFO
3720 PROCESS_MEMORY_COUNTERS memcounters;
3721 proc = GetCurrentProcess();
3722 memcounters.cb = sizeof(memcounters);
3723 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3724 return memcounters.PeakPagefileUsage;
3730 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3733 const char *p = str;
3740 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3747 static void opt_inter_matrix(const char *arg)
3749 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3750 parse_matrix_coeffs(inter_matrix, arg);
3753 static void opt_intra_matrix(const char *arg)
3755 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3756 parse_matrix_coeffs(intra_matrix, arg);
3759 static void show_usage(void)
3761 printf("Hyper fast Audio and Video encoder\n");
3762 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3766 static void show_help(void)
3769 AVOutputFormat *oformat = NULL;
3770 AVInputFormat *iformat = NULL;
3771 const AVClass *class;
3773 av_log_set_callback(log_callback_help);
3775 show_help_options(options, "Main options:\n",
3776 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3777 show_help_options(options, "\nAdvanced options:\n",
3778 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3780 show_help_options(options, "\nVideo options:\n",
3781 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3783 show_help_options(options, "\nAdvanced Video options:\n",
3784 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3785 OPT_VIDEO | OPT_EXPERT);
3786 show_help_options(options, "\nAudio options:\n",
3787 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3789 show_help_options(options, "\nAdvanced Audio options:\n",
3790 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3791 OPT_AUDIO | OPT_EXPERT);
3792 show_help_options(options, "\nSubtitle options:\n",
3793 OPT_SUBTITLE | OPT_GRAB,
3795 show_help_options(options, "\nAudio/Video grab options:\n",
3799 class = avcodec_get_class();
3800 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3803 /* individual codec options */
3805 while ((c = av_codec_next(c))) {
3806 if (c->priv_class) {
3807 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3812 class = avformat_get_class();
3813 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3816 /* individual muxer options */
3817 while ((oformat = av_oformat_next(oformat))) {
3818 if (oformat->priv_class) {
3819 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3824 /* individual demuxer options */
3825 while ((iformat = av_iformat_next(iformat))) {
3826 if (iformat->priv_class) {
3827 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3832 class = sws_get_class();
3833 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3836 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3838 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3839 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3841 if(!strncmp(arg, "pal-", 4)) {
3844 } else if(!strncmp(arg, "ntsc-", 5)) {
3847 } else if(!strncmp(arg, "film-", 5)) {
3852 /* Calculate FR via float to avoid int overflow */
3853 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3856 } else if((fr == 29970) || (fr == 23976)) {
3859 /* Try to determine PAL/NTSC by peeking in the input files */
3860 if(nb_input_files) {
3862 for (j = 0; j < nb_input_files; j++) {
3863 for (i = 0; i < input_files[j].nb_streams; i++) {
3864 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3865 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3867 fr = c->time_base.den * 1000 / c->time_base.num;
3871 } else if((fr == 29970) || (fr == 23976)) {
3881 if(verbose > 0 && norm != UNKNOWN)
3882 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3885 if(norm == UNKNOWN) {
3886 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3887 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3888 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3892 if(!strcmp(arg, "vcd")) {
3893 opt_video_codec(o, "c:v", "mpeg1video");
3894 opt_audio_codec(o, "c:a", "mp2");
3895 parse_option(o, "f", "vcd", options);
3897 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
3898 opt_frame_rate("r", frame_rates[norm]);
3899 opt_default("g", norm == PAL ? "15" : "18");
3901 opt_default("b", "1150000");
3902 opt_default("maxrate", "1150000");
3903 opt_default("minrate", "1150000");
3904 opt_default("bufsize", "327680"); // 40*1024*8;
3906 opt_default("b:a", "224000");
3907 audio_sample_rate = 44100;
3910 opt_default("packetsize", "2324");
3911 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3913 /* We have to offset the PTS, so that it is consistent with the SCR.
3914 SCR starts at 36000, but the first two packs contain only padding
3915 and the first pack from the other stream, respectively, may also have
3916 been written before.
3917 So the real data starts at SCR 36000+3*1200. */
3918 mux_preload= (36000+3*1200) / 90000.0; //0.44
3919 } else if(!strcmp(arg, "svcd")) {
3921 opt_video_codec(o, "c:v", "mpeg2video");
3922 opt_audio_codec(o, "c:a", "mp2");
3923 parse_option(o, "f", "svcd", options);
3925 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
3926 opt_frame_rate("r", frame_rates[norm]);
3927 opt_default("g", norm == PAL ? "15" : "18");
3929 opt_default("b", "2040000");
3930 opt_default("maxrate", "2516000");
3931 opt_default("minrate", "0"); //1145000;
3932 opt_default("bufsize", "1835008"); //224*1024*8;
3933 opt_default("flags", "+scan_offset");
3936 opt_default("b:a", "224000");
3937 audio_sample_rate = 44100;
3939 opt_default("packetsize", "2324");
3941 } else if(!strcmp(arg, "dvd")) {
3943 opt_video_codec(o, "c:v", "mpeg2video");
3944 opt_audio_codec(o, "c:a", "ac3");
3945 parse_option(o, "f", "dvd", options);
3947 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
3948 opt_frame_rate("r", frame_rates[norm]);
3949 opt_default("g", norm == PAL ? "15" : "18");
3951 opt_default("b", "6000000");
3952 opt_default("maxrate", "9000000");
3953 opt_default("minrate", "0"); //1500000;
3954 opt_default("bufsize", "1835008"); //224*1024*8;
3956 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3957 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3959 opt_default("b:a", "448000");
3960 audio_sample_rate = 48000;
3962 } else if(!strncmp(arg, "dv", 2)) {
3964 parse_option(o, "f", "dv", options);
3966 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
3967 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3968 norm == PAL ? "yuv420p" : "yuv411p");
3969 opt_frame_rate("r", frame_rates[norm]);
3971 audio_sample_rate = 48000;
3975 fprintf(stderr, "Unknown target: %s\n", arg);
3976 return AVERROR(EINVAL);
3981 static int opt_vstats_file(const char *opt, const char *arg)
3983 av_free (vstats_filename);
3984 vstats_filename=av_strdup (arg);
3988 static int opt_vstats(const char *opt, const char *arg)
3991 time_t today2 = time(NULL);
3992 struct tm *today = localtime(&today2);
3994 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3996 return opt_vstats_file(opt, filename);
3999 static int opt_bsf(const char *opt, const char *arg)
4001 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4002 AVBitStreamFilterContext **bsfp;
4005 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4009 bsfp= *opt == 'v' ? &video_bitstream_filters :
4010 *opt == 'a' ? &audio_bitstream_filters :
4011 &subtitle_bitstream_filters;
4013 bsfp= &(*bsfp)->next;
4020 #define OFFSET(x) offsetof(OptionsContext, x)
4021 static const OptionDef options[] = {
4023 #include "cmdutils_common_opts.h"
4024 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4025 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4026 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4027 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4028 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4029 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4030 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4031 "outfile[,metadata]:infile[,metadata]" },
4032 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4033 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4034 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4035 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4036 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4037 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4038 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4039 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4040 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4041 "add timings for benchmarking" },
4042 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4043 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4044 "dump each input packet" },
4045 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4046 "when dumping packets, also dump the payload" },
4047 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4048 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4049 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4050 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4051 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4052 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4053 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4054 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4055 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4056 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4057 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4058 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4059 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4062 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4063 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4064 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4065 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4066 { "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" },
4067 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4068 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4069 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4070 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4071 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4072 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold", "threshold" },
4073 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4074 "use same quantizer as source (implies VBR)" },
4075 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4076 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4077 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4078 "deinterlace pictures" },
4079 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4080 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4081 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4083 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4085 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4086 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4087 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4088 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4089 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4090 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4091 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4092 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4093 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4094 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4097 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4098 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4099 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4100 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4101 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4102 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4103 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4104 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4105 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4106 { "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" },
4108 /* subtitle options */
4109 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4110 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4111 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4112 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4115 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4118 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4119 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4121 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4122 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4123 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4125 /* data codec support */
4126 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4128 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4132 int main(int argc, char **argv)
4134 OptionsContext o = { 0 };
4139 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4141 avcodec_register_all();
4143 avdevice_register_all();
4146 avfilter_register_all();
4150 avio_set_interrupt_cb(decode_interrupt_cb);
4155 parse_options(&o, argc, argv, options, opt_output_file);
4157 if(nb_output_files <= 0 && nb_input_files == 0) {
4159 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4163 /* file converter / grab */
4164 if (nb_output_files <= 0) {
4165 fprintf(stderr, "At least one output file must be specified\n");
4169 if (nb_input_files == 0) {
4170 fprintf(stderr, "At least one input file must be specified\n");
4175 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4177 ti = getutime() - ti;
4179 int maxrss = getmaxrss() / 1024;
4180 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);