3 * Copyright (c) 2000-2011 The libav developers.
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "avconv";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
82 int disabled; /** 1 is this mapping is disabled by a negative map */
86 int sync_stream_index;
90 * select an input file for an output file
92 typedef struct MetadataMap {
93 int file; ///< file index
94 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
95 int index; ///< stream/chapter/program number
98 static const OptionDef options[];
100 static const char *last_asked_format = NULL;
101 static AVDictionary *ts_scale;
103 static StreamMap *stream_maps = NULL;
104 static int nb_stream_maps;
106 static AVDictionary *codec_names;
108 /* first item specifies output metadata, second is input */
109 static MetadataMap (*meta_data_maps)[2] = NULL;
110 static int nb_meta_data_maps;
111 static int metadata_global_autocopy = 1;
112 static int metadata_streams_autocopy = 1;
113 static int metadata_chapters_autocopy = 1;
115 static int chapters_input_file = INT_MAX;
117 /* indexed by output file stream index */
118 static int *streamid_map = NULL;
119 static int nb_streamid_map = 0;
121 static int frame_width = 0;
122 static int frame_height = 0;
123 static float frame_aspect_ratio = 0;
124 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
125 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
126 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
127 static AVRational frame_rate;
128 static float video_qscale = 0;
129 static uint16_t *intra_matrix = NULL;
130 static uint16_t *inter_matrix = NULL;
131 static const char *video_rc_override_string=NULL;
132 static int video_disable = 0;
133 static int video_discard = 0;
134 static unsigned int video_codec_tag = 0;
135 static char *video_language = NULL;
136 static int same_quant = 0;
137 static int do_deinterlace = 0;
138 static int top_field_first = -1;
139 static int me_threshold = 0;
140 static int intra_dc_precision = 8;
141 static int qp_hist = 0;
143 static char *vfilters = NULL;
146 static int audio_sample_rate = 0;
147 #define QSCALE_NONE -99999
148 static float audio_qscale = QSCALE_NONE;
149 static int audio_disable = 0;
150 static int audio_channels = 0;
151 static unsigned int audio_codec_tag = 0;
152 static char *audio_language = NULL;
154 static int subtitle_disable = 0;
155 static char *subtitle_language = NULL;
156 static unsigned int subtitle_codec_tag = 0;
158 static int data_disable = 0;
159 static unsigned int data_codec_tag = 0;
161 static float mux_preload= 0.5;
162 static float mux_max_delay= 0.7;
164 static int64_t recording_time = INT64_MAX;
165 static int64_t start_time = 0;
166 static int64_t input_ts_offset = 0;
167 static int file_overwrite = 0;
168 static AVDictionary *metadata;
169 static int do_benchmark = 0;
170 static int do_hex_dump = 0;
171 static int do_pkt_dump = 0;
172 static int do_psnr = 0;
173 static int do_pass = 0;
174 static char *pass_logfilename_prefix = NULL;
175 static int video_sync_method= -1;
176 static int audio_sync_method= 0;
177 static float audio_drift_threshold= 0.1;
178 static int copy_ts= 0;
180 static int opt_shortest = 0;
181 static char *vstats_filename;
182 static FILE *vstats_file;
183 static int opt_programid = 0;
184 static int copy_initial_nonkeyframes = 0;
186 static int rate_emu = 0;
188 static int audio_volume = 256;
190 static int exit_on_error = 0;
191 static int using_stdin = 0;
192 static int verbose = 1;
193 static int64_t video_size = 0;
194 static int64_t audio_size = 0;
195 static int64_t extra_size = 0;
196 static int nb_frames_dup = 0;
197 static int nb_frames_drop = 0;
198 static int input_sync;
199 static uint64_t limit_filesize = UINT64_MAX;
200 static int force_fps = 0;
201 static char *forced_key_frames = NULL;
203 static float dts_delta_threshold = 10;
205 static uint8_t *audio_buf;
206 static uint8_t *audio_out;
207 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
209 static short *samples;
211 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
212 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
213 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
215 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
217 typedef struct InputStream {
220 int discard; /* true if stream data should be discarded */
221 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
224 int64_t start; /* time when read started */
225 int64_t next_pts; /* synthetic pts for cases where pkt.pts
227 int64_t pts; /* current pts */
228 PtsCorrectionContext pts_ctx;
230 int is_start; /* is 1 at the start and after a discontinuity */
231 int showed_multi_packet_warning;
235 typedef struct InputFile {
236 AVFormatContext *ctx;
237 int eof_reached; /* true if eof reached */
238 int ist_index; /* index of first stream in ist_table */
239 int buffer_size; /* current total buffer size */
241 int nb_streams; /* number of stream that avconv is aware of; may be different
242 from ctx.nb_streams if new streams appear during av_read_frame() */
245 typedef struct OutputStream {
246 int file_index; /* file index */
247 int index; /* stream index in the output file */
248 int source_index; /* InputStream index */
249 AVStream *st; /* stream in the output file */
250 int encoding_needed; /* true if encoding needed for this stream */
252 /* input pts and corresponding output pts
254 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
255 struct InputStream *sync_ist; /* input stream to sync against */
256 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
257 AVBitStreamFilterContext *bitstream_filters;
262 AVFrame pict_tmp; /* temporary image for resampling */
263 struct SwsContext *img_resample_ctx; /* for image resampling */
266 int resample_pix_fmt;
267 AVRational frame_rate;
269 float frame_aspect_ratio;
271 /* forced key frames */
272 int64_t *forced_kf_pts;
278 ReSampleContext *resample; /* for audio resampling */
279 int resample_sample_fmt;
280 int resample_channels;
281 int resample_sample_rate;
283 AVAudioConvert *reformat_ctx;
284 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
288 AVFilterContext *output_video_filter;
289 AVFilterContext *input_video_filter;
290 AVFilterBufferRef *picref;
292 AVFilterGraph *graph;
297 int is_past_recording_time;
301 typedef struct OutputFile {
302 AVFormatContext *ctx;
304 int ost_index; /* index of the first stream in output_streams */
305 int64_t recording_time; /* desired length of the resulting file in microseconds */
306 int64_t start_time; /* start time in microseconds */
307 uint64_t limit_filesize;
310 static InputStream *input_streams = NULL;
311 static int nb_input_streams = 0;
312 static InputFile *input_files = NULL;
313 static int nb_input_files = 0;
315 static OutputStream *output_streams = NULL;
316 static int nb_output_streams = 0;
317 static OutputFile *output_files = NULL;
318 static int nb_output_files = 0;
322 static int configure_video_filters(InputStream *ist, OutputStream *ost)
324 AVFilterContext *last_filter, *filter;
325 /** filter graph containing all filters including input & output */
326 AVCodecContext *codec = ost->st->codec;
327 AVCodecContext *icodec = ist->st->codec;
328 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
329 AVRational sample_aspect_ratio;
333 ost->graph = avfilter_graph_alloc();
335 if (ist->st->sample_aspect_ratio.num){
336 sample_aspect_ratio = ist->st->sample_aspect_ratio;
338 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
340 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
341 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
342 sample_aspect_ratio.num, sample_aspect_ratio.den);
344 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
345 "src", args, NULL, ost->graph);
348 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
349 "out", NULL, &ffsink_ctx, ost->graph);
352 last_filter = ost->input_video_filter;
354 if (codec->width != icodec->width || codec->height != icodec->height) {
355 snprintf(args, 255, "%d:%d:flags=0x%X",
359 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
360 NULL, args, NULL, ost->graph)) < 0)
362 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
364 last_filter = filter;
367 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
368 ost->graph->scale_sws_opts = av_strdup(args);
371 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
372 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
374 outputs->name = av_strdup("in");
375 outputs->filter_ctx = last_filter;
376 outputs->pad_idx = 0;
377 outputs->next = NULL;
379 inputs->name = av_strdup("out");
380 inputs->filter_ctx = ost->output_video_filter;
384 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
386 av_freep(&ost->avfilter);
388 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
392 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
395 codec->width = ost->output_video_filter->inputs[0]->w;
396 codec->height = ost->output_video_filter->inputs[0]->h;
397 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
398 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
399 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
400 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
404 #endif /* CONFIG_AVFILTER */
406 static void term_exit(void)
408 av_log(NULL, AV_LOG_QUIET, "");
411 static volatile int received_sigterm = 0;
412 static volatile int received_nb_signals = 0;
415 sigterm_handler(int sig)
417 received_sigterm = sig;
418 received_nb_signals++;
422 static void term_init(void)
424 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
425 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
427 signal(SIGXCPU, sigterm_handler);
431 static int decode_interrupt_cb(void)
433 return received_nb_signals > 1;
436 void exit_program(int ret)
441 for(i=0;i<nb_output_files;i++) {
442 AVFormatContext *s = output_files[i].ctx;
443 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
445 avformat_free_context(s);
446 av_dict_free(&output_files[i].opts);
448 for(i=0;i<nb_input_files;i++) {
449 av_close_input_file(input_files[i].ctx);
451 for (i = 0; i < nb_input_streams; i++)
452 av_dict_free(&input_streams[i].opts);
454 av_free(intra_matrix);
455 av_free(inter_matrix);
459 av_free(vstats_filename);
461 av_free(meta_data_maps);
463 av_freep(&input_streams);
464 av_freep(&input_files);
465 av_freep(&output_streams);
466 av_freep(&output_files);
471 allocated_audio_buf_size= allocated_audio_out_size= 0;
478 if (received_sigterm) {
480 "Received signal %d: terminating.\n",
481 (int) received_sigterm);
485 exit(ret); /* not all OS-es handle main() return value */
488 static void assert_avoptions(AVDictionary *m)
490 AVDictionaryEntry *t;
491 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
492 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
497 static void assert_codec_experimental(AVCodecContext *c, int encoder)
499 const char *codec_string = encoder ? "encoder" : "decoder";
501 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
502 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
503 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
504 "results.\nAdd '-strict experimental' if you want to use it.\n",
505 codec_string, c->codec->name);
506 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
507 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
508 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
509 codec_string, codec->name);
514 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
516 if(codec && codec->sample_fmts){
517 const enum AVSampleFormat *p= codec->sample_fmts;
519 if(*p == st->codec->sample_fmt)
523 av_log(NULL, AV_LOG_WARNING,
524 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
525 av_get_sample_fmt_name(st->codec->sample_fmt),
527 av_get_sample_fmt_name(codec->sample_fmts[0]));
528 st->codec->sample_fmt = codec->sample_fmts[0];
534 * Update the requested input sample format based on the output sample format.
535 * This is currently only used to request float output from decoders which
536 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
537 * Ideally this will be removed in the future when decoders do not do format
538 * conversion and only output in their native format.
540 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
543 /* if sample formats match or a decoder sample format has already been
544 requested, just return */
545 if (enc->sample_fmt == dec->sample_fmt ||
546 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
549 /* if decoder supports more than one output format */
550 if (dec_codec && dec_codec->sample_fmts &&
551 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
552 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
553 const enum AVSampleFormat *p;
554 int min_dec = -1, min_inc = -1;
556 /* find a matching sample format in the encoder */
557 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
558 if (*p == enc->sample_fmt) {
559 dec->request_sample_fmt = *p;
561 } else if (*p > enc->sample_fmt) {
562 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
564 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
567 /* if none match, provide the one that matches quality closest */
568 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
569 enc->sample_fmt - min_dec;
573 static void choose_sample_rate(AVStream *st, AVCodec *codec)
575 if(codec && codec->supported_samplerates){
576 const int *p= codec->supported_samplerates;
578 int best_dist=INT_MAX;
580 int dist= abs(st->codec->sample_rate - *p);
581 if(dist < best_dist){
587 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
589 st->codec->sample_rate= best;
593 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
595 if(codec && codec->pix_fmts){
596 const enum PixelFormat *p= codec->pix_fmts;
597 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
598 if(st->codec->codec_id==CODEC_ID_MJPEG){
599 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
600 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
601 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};
605 if(*p == st->codec->pix_fmt)
609 if(st->codec->pix_fmt != PIX_FMT_NONE)
610 av_log(NULL, AV_LOG_WARNING,
611 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
612 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
614 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
615 st->codec->pix_fmt = codec->pix_fmts[0];
621 get_sync_ipts(const OutputStream *ost)
623 const InputStream *ist = ost->sync_ist;
624 OutputFile *of = &output_files[ost->file_index];
625 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
628 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
632 AVPacket new_pkt= *pkt;
633 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
634 &new_pkt.data, &new_pkt.size,
635 pkt->data, pkt->size,
636 pkt->flags & AV_PKT_FLAG_KEY);
639 new_pkt.destruct= av_destruct_packet;
641 fprintf(stderr, "%s failed for stream %d, codec %s",
642 bsfc->filter->name, pkt->stream_index,
643 avctx->codec ? avctx->codec->name : "copy");
653 ret= av_interleaved_write_frame(s, pkt);
655 print_error("av_interleaved_write_frame()", ret);
660 static void do_audio_out(AVFormatContext *s,
663 unsigned char *buf, int size)
666 int64_t audio_out_size, audio_buf_size;
667 int64_t allocated_for_size= size;
669 int size_out, frame_bytes, ret, resample_changed;
670 AVCodecContext *enc= ost->st->codec;
671 AVCodecContext *dec= ist->st->codec;
672 int osize = av_get_bytes_per_sample(enc->sample_fmt);
673 int isize = av_get_bytes_per_sample(dec->sample_fmt);
674 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
677 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
678 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
679 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
680 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
681 audio_buf_size*= osize*enc->channels;
683 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
684 if(coded_bps > 8*osize)
685 audio_out_size= audio_out_size * coded_bps / (8*osize);
686 audio_out_size += FF_MIN_BUFFER_SIZE;
688 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
689 fprintf(stderr, "Buffer sizes too large\n");
693 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
694 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
695 if (!audio_buf || !audio_out){
696 fprintf(stderr, "Out of memory in do_audio_out\n");
700 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
701 ost->audio_resample = 1;
703 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
704 ost->resample_channels != dec->channels ||
705 ost->resample_sample_rate != dec->sample_rate;
707 if ((ost->audio_resample && !ost->resample) || resample_changed) {
708 if (resample_changed) {
709 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",
710 ist->file_index, ist->st->index,
711 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
712 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
713 ost->resample_sample_fmt = dec->sample_fmt;
714 ost->resample_channels = dec->channels;
715 ost->resample_sample_rate = dec->sample_rate;
717 audio_resample_close(ost->resample);
719 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
720 if (audio_sync_method <= 1 &&
721 ost->resample_sample_fmt == enc->sample_fmt &&
722 ost->resample_channels == enc->channels &&
723 ost->resample_sample_rate == enc->sample_rate) {
724 ost->resample = NULL;
725 ost->audio_resample = 0;
726 } else if (ost->audio_resample) {
727 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
728 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
729 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
730 enc->sample_rate, dec->sample_rate,
731 enc->sample_fmt, dec->sample_fmt,
733 if (!ost->resample) {
734 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
735 dec->channels, dec->sample_rate,
736 enc->channels, enc->sample_rate);
742 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
743 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
744 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
745 if (ost->reformat_ctx)
746 av_audio_convert_free(ost->reformat_ctx);
747 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
748 dec->sample_fmt, 1, NULL, 0);
749 if (!ost->reformat_ctx) {
750 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
751 av_get_sample_fmt_name(dec->sample_fmt),
752 av_get_sample_fmt_name(enc->sample_fmt));
755 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
758 if(audio_sync_method){
759 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
760 - av_fifo_size(ost->fifo)/(enc->channels * 2);
761 double idelta= delta*dec->sample_rate / enc->sample_rate;
762 int byte_delta= ((int)idelta)*2*dec->channels;
764 //FIXME resample delay
765 if(fabs(delta) > 50){
766 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
768 byte_delta= FFMAX(byte_delta, -size);
772 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
777 static uint8_t *input_tmp= NULL;
778 input_tmp= av_realloc(input_tmp, byte_delta + size);
780 if(byte_delta > allocated_for_size - size){
781 allocated_for_size= byte_delta + (int64_t)size;
786 memset(input_tmp, 0, byte_delta);
787 memcpy(input_tmp + byte_delta, buf, size);
791 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
793 }else if(audio_sync_method>1){
794 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
795 av_assert0(ost->audio_resample);
797 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
798 // 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));
799 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
803 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
804 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
806 if (ost->audio_resample) {
808 size_out = audio_resample(ost->resample,
809 (short *)buftmp, (short *)buf,
810 size / (dec->channels * isize));
811 size_out = size_out * enc->channels * osize;
817 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
818 const void *ibuf[6]= {buftmp};
819 void *obuf[6]= {audio_buf};
820 int istride[6]= {isize};
821 int ostride[6]= {osize};
822 int len= size_out/istride[0];
823 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
824 printf("av_audio_convert() failed\n");
830 size_out = len*osize;
833 /* now encode as many frames as possible */
834 if (enc->frame_size > 1) {
835 /* output resampled raw samples */
836 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
837 fprintf(stderr, "av_fifo_realloc2() failed\n");
840 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
842 frame_bytes = enc->frame_size * osize * enc->channels;
844 while (av_fifo_size(ost->fifo) >= frame_bytes) {
846 av_init_packet(&pkt);
848 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
850 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
852 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
855 fprintf(stderr, "Audio encoding failed\n");
859 pkt.stream_index= ost->index;
862 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
863 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
864 pkt.flags |= AV_PKT_FLAG_KEY;
865 write_frame(s, &pkt, enc, ost->bitstream_filters);
867 ost->sync_opts += enc->frame_size;
871 av_init_packet(&pkt);
873 ost->sync_opts += size_out / (osize * enc->channels);
875 /* output a pcm frame */
876 /* determine the size of the coded buffer */
879 size_out = size_out*coded_bps/8;
881 if(size_out > audio_out_size){
882 fprintf(stderr, "Internal error, buffer size too small\n");
886 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
887 ret = avcodec_encode_audio(enc, audio_out, size_out,
890 fprintf(stderr, "Audio encoding failed\n");
894 pkt.stream_index= ost->index;
897 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
898 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
899 pkt.flags |= AV_PKT_FLAG_KEY;
900 write_frame(s, &pkt, enc, ost->bitstream_filters);
904 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
908 AVPicture picture_tmp;
911 dec = ist->st->codec;
913 /* deinterlace : must be done before any resize */
914 if (do_deinterlace) {
917 /* create temporary picture */
918 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
919 buf = av_malloc(size);
923 picture2 = &picture_tmp;
924 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
926 if(avpicture_deinterlace(picture2, picture,
927 dec->pix_fmt, dec->width, dec->height) < 0) {
928 /* if error, do not deinterlace */
929 fprintf(stderr, "Deinterlacing failed\n");
938 if (picture != picture2)
939 *picture = *picture2;
943 static void do_subtitle_out(AVFormatContext *s,
949 static uint8_t *subtitle_out = NULL;
950 int subtitle_out_max_size = 1024 * 1024;
951 int subtitle_out_size, nb, i;
955 if (pts == AV_NOPTS_VALUE) {
956 fprintf(stderr, "Subtitle packets must have a pts\n");
962 enc = ost->st->codec;
965 subtitle_out = av_malloc(subtitle_out_max_size);
968 /* Note: DVB subtitle need one packet to draw them and one other
969 packet to clear them */
970 /* XXX: signal it in the codec context ? */
971 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
976 for(i = 0; i < nb; i++) {
977 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
978 // start_display_time is required to be 0
979 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
980 sub->end_display_time -= sub->start_display_time;
981 sub->start_display_time = 0;
982 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
983 subtitle_out_max_size, sub);
984 if (subtitle_out_size < 0) {
985 fprintf(stderr, "Subtitle encoding failed\n");
989 av_init_packet(&pkt);
990 pkt.stream_index = ost->index;
991 pkt.data = subtitle_out;
992 pkt.size = subtitle_out_size;
993 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
994 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
995 /* XXX: the pts correction is handled here. Maybe handling
996 it in the codec would be better */
998 pkt.pts += 90 * sub->start_display_time;
1000 pkt.pts += 90 * sub->end_display_time;
1002 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1006 static int bit_buffer_size= 1024*256;
1007 static uint8_t *bit_buffer= NULL;
1009 static void do_video_resample(OutputStream *ost,
1011 AVFrame *in_picture,
1012 AVFrame **out_picture)
1014 int resample_changed = 0;
1015 AVCodecContext *dec = ist->st->codec;
1016 *out_picture = in_picture;
1018 resample_changed = ost->resample_width != dec->width ||
1019 ost->resample_height != dec->height ||
1020 ost->resample_pix_fmt != dec->pix_fmt;
1022 if (resample_changed) {
1023 av_log(NULL, AV_LOG_INFO,
1024 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1025 ist->file_index, ist->st->index,
1026 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1027 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1028 if(!ost->video_resample)
1029 ost->video_resample = 1;
1032 #if !CONFIG_AVFILTER
1033 if (ost->video_resample) {
1034 *out_picture = &ost->pict_tmp;
1035 if (resample_changed) {
1036 /* initialize a new scaler context */
1037 sws_freeContext(ost->img_resample_ctx);
1038 ost->img_resample_ctx = sws_getContext(
1039 ist->st->codec->width,
1040 ist->st->codec->height,
1041 ist->st->codec->pix_fmt,
1042 ost->st->codec->width,
1043 ost->st->codec->height,
1044 ost->st->codec->pix_fmt,
1045 ost->sws_flags, NULL, NULL, NULL);
1046 if (ost->img_resample_ctx == NULL) {
1047 fprintf(stderr, "Cannot get resampling context\n");
1051 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1052 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1055 if (resample_changed) {
1056 avfilter_graph_free(&ost->graph);
1057 if (configure_video_filters(ist, ost)) {
1058 fprintf(stderr, "Error reinitializing filters!\n");
1063 if (resample_changed) {
1064 ost->resample_width = dec->width;
1065 ost->resample_height = dec->height;
1066 ost->resample_pix_fmt = dec->pix_fmt;
1071 static void do_video_out(AVFormatContext *s,
1074 AVFrame *in_picture,
1075 int *frame_size, float quality)
1077 int nb_frames, i, ret, format_video_sync;
1078 AVFrame *final_picture;
1079 AVCodecContext *enc;
1082 enc = ost->st->codec;
1084 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1086 /* by default, we output a single frame */
1091 format_video_sync = video_sync_method;
1092 if (format_video_sync < 0)
1093 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1095 if (format_video_sync) {
1096 double vdelta = sync_ipts - ost->sync_opts;
1097 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1100 else if (format_video_sync == 2) {
1103 }else if(vdelta>0.6)
1104 ost->sync_opts= lrintf(sync_ipts);
1105 }else if (vdelta > 1.1)
1106 nb_frames = lrintf(vdelta);
1107 //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);
1108 if (nb_frames == 0){
1111 fprintf(stderr, "*** drop!\n");
1112 }else if (nb_frames > 1) {
1113 nb_frames_dup += nb_frames - 1;
1115 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1118 ost->sync_opts= lrintf(sync_ipts);
1120 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1124 do_video_resample(ost, ist, in_picture, &final_picture);
1126 /* duplicates frame if needed */
1127 for(i=0;i<nb_frames;i++) {
1129 av_init_packet(&pkt);
1130 pkt.stream_index= ost->index;
1132 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1133 /* raw pictures are written as AVPicture structure to
1134 avoid any copies. We support temporarily the older
1136 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1137 enc->coded_frame->top_field_first = in_picture->top_field_first;
1138 pkt.data= (uint8_t *)final_picture;
1139 pkt.size= sizeof(AVPicture);
1140 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1141 pkt.flags |= AV_PKT_FLAG_KEY;
1143 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1145 AVFrame big_picture;
1147 big_picture= *final_picture;
1148 /* better than nothing: use input picture interlaced
1150 big_picture.interlaced_frame = in_picture->interlaced_frame;
1151 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1152 if(top_field_first == -1)
1153 big_picture.top_field_first = in_picture->top_field_first;
1155 big_picture.top_field_first = top_field_first;
1158 /* handles same_quant here. This is not correct because it may
1159 not be a global option */
1160 big_picture.quality = quality;
1162 big_picture.pict_type = 0;
1163 // big_picture.pts = AV_NOPTS_VALUE;
1164 big_picture.pts= ost->sync_opts;
1165 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1166 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1167 if (ost->forced_kf_index < ost->forced_kf_count &&
1168 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1169 big_picture.pict_type = AV_PICTURE_TYPE_I;
1170 ost->forced_kf_index++;
1172 ret = avcodec_encode_video(enc,
1173 bit_buffer, bit_buffer_size,
1176 fprintf(stderr, "Video encoding failed\n");
1181 pkt.data= bit_buffer;
1183 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1184 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1185 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1186 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1187 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1189 if(enc->coded_frame->key_frame)
1190 pkt.flags |= AV_PKT_FLAG_KEY;
1191 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1194 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1195 // enc->frame_number-1, ret, enc->pict_type);
1196 /* if two pass, output log */
1197 if (ost->logfile && enc->stats_out) {
1198 fprintf(ost->logfile, "%s", enc->stats_out);
1203 ost->frame_number++;
1207 static double psnr(double d){
1208 return -10.0*log(d)/log(10.0);
1211 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1214 AVCodecContext *enc;
1216 double ti1, bitrate, avg_bitrate;
1218 /* this is executed just the first time do_video_stats is called */
1220 vstats_file = fopen(vstats_filename, "w");
1227 enc = ost->st->codec;
1228 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1229 frame_number = ost->frame_number;
1230 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1231 if (enc->flags&CODEC_FLAG_PSNR)
1232 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1234 fprintf(vstats_file,"f_size= %6d ", frame_size);
1235 /* compute pts value */
1236 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1240 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1241 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1242 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1243 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1244 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1248 static void print_report(OutputFile *output_files,
1249 OutputStream *ost_table, int nb_ostreams,
1250 int is_last_report, int64_t timer_start)
1254 AVFormatContext *oc;
1256 AVCodecContext *enc;
1257 int frame_number, vid, i;
1258 double bitrate, ti1, pts;
1259 static int64_t last_time = -1;
1260 static int qp_histogram[52];
1262 if (!is_last_report) {
1264 /* display the report every 0.5 seconds */
1265 cur_time = av_gettime();
1266 if (last_time == -1) {
1267 last_time = cur_time;
1270 if ((cur_time - last_time) < 500000)
1272 last_time = cur_time;
1276 oc = output_files[0].ctx;
1278 total_size = avio_size(oc->pb);
1279 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1280 total_size= avio_tell(oc->pb);
1285 for(i=0;i<nb_ostreams;i++) {
1287 ost = &ost_table[i];
1288 enc = ost->st->codec;
1289 if (!ost->st->stream_copy && enc->coded_frame)
1290 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1291 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1292 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1294 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1295 float t = (av_gettime()-timer_start) / 1000000.0;
1297 frame_number = ost->frame_number;
1298 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1299 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1301 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1305 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1308 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1310 if (enc->flags&CODEC_FLAG_PSNR){
1312 double error, error_sum=0;
1313 double scale, scale_sum=0;
1314 char type[3]= {'Y','U','V'};
1315 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1318 error= enc->error[j];
1319 scale= enc->width*enc->height*255.0*255.0*frame_number;
1321 error= enc->coded_frame->error[j];
1322 scale= enc->width*enc->height*255.0*255.0;
1327 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1329 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1333 /* compute min output value */
1334 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1335 if ((pts < ti1) && (pts > 0))
1341 if (verbose > 0 || is_last_report) {
1342 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1344 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1345 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1346 (double)total_size / 1024, ti1, bitrate);
1348 if (nb_frames_dup || nb_frames_drop)
1349 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1350 nb_frames_dup, nb_frames_drop);
1353 fprintf(stderr, "%s \r", buf);
1358 if (is_last_report && verbose >= 0){
1359 int64_t raw= audio_size + video_size + extra_size;
1360 fprintf(stderr, "\n");
1361 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1365 100.0*(total_size - raw)/raw
1370 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1372 int fill_char = 0x00;
1373 if (sample_fmt == AV_SAMPLE_FMT_U8)
1375 memset(buf, fill_char, size);
1378 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1382 for (i = 0; i < nb_ostreams; i++) {
1383 OutputStream *ost = &ost_table[i];
1384 AVCodecContext *enc = ost->st->codec;
1385 AVFormatContext *os = output_files[ost->file_index].ctx;
1387 if (!ost->encoding_needed)
1390 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1392 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1398 av_init_packet(&pkt);
1399 pkt.stream_index= ost->index;
1401 switch (ost->st->codec->codec_type) {
1402 case AVMEDIA_TYPE_AUDIO:
1403 fifo_bytes = av_fifo_size(ost->fifo);
1405 /* encode any samples remaining in fifo */
1406 if (fifo_bytes > 0) {
1407 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1408 int fs_tmp = enc->frame_size;
1410 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1411 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1412 enc->frame_size = fifo_bytes / (osize * enc->channels);
1414 int frame_bytes = enc->frame_size*osize*enc->channels;
1415 if (allocated_audio_buf_size < frame_bytes)
1417 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1420 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1421 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1422 ost->st->time_base.num, enc->sample_rate);
1423 enc->frame_size = fs_tmp;
1426 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1429 fprintf(stderr, "Audio encoding failed\n");
1433 pkt.flags |= AV_PKT_FLAG_KEY;
1435 case AVMEDIA_TYPE_VIDEO:
1436 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1438 fprintf(stderr, "Video encoding failed\n");
1442 if(enc->coded_frame && enc->coded_frame->key_frame)
1443 pkt.flags |= AV_PKT_FLAG_KEY;
1444 if (ost->logfile && enc->stats_out) {
1445 fprintf(ost->logfile, "%s", enc->stats_out);
1454 pkt.data = bit_buffer;
1456 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1457 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1458 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1463 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1464 static int output_packet(InputStream *ist, int ist_index,
1465 OutputStream *ost_table, int nb_ostreams,
1466 const AVPacket *pkt)
1468 AVFormatContext *os;
1473 void *buffer_to_free = NULL;
1474 static unsigned int samples_size= 0;
1475 AVSubtitle subtitle, *subtitle_to_free;
1476 int64_t pkt_pts = AV_NOPTS_VALUE;
1478 int frame_available;
1483 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1485 if(ist->next_pts == AV_NOPTS_VALUE)
1486 ist->next_pts= ist->pts;
1490 av_init_packet(&avpkt);
1498 if(pkt->dts != AV_NOPTS_VALUE)
1499 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1500 if(pkt->pts != AV_NOPTS_VALUE)
1501 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1503 //while we have more to decode or while the decoder did output something on EOF
1504 while (avpkt.size > 0 || (!pkt && got_output)) {
1505 uint8_t *data_buf, *decoded_data_buf;
1506 int data_size, decoded_data_size;
1508 ist->pts= ist->next_pts;
1510 if(avpkt.size && avpkt.size != pkt->size &&
1511 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1512 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1513 ist->showed_multi_packet_warning=1;
1516 /* decode the packet if needed */
1517 decoded_data_buf = NULL; /* fail safe */
1518 decoded_data_size= 0;
1519 data_buf = avpkt.data;
1520 data_size = avpkt.size;
1521 subtitle_to_free = NULL;
1522 if (ist->decoding_needed) {
1523 switch(ist->st->codec->codec_type) {
1524 case AVMEDIA_TYPE_AUDIO:{
1525 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1526 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1528 samples= av_malloc(samples_size);
1530 decoded_data_size= samples_size;
1531 /* XXX: could avoid copy if PCM 16 bits with same
1532 endianness as CPU */
1533 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1540 got_output = decoded_data_size > 0;
1541 /* Some bug in mpeg audio decoder gives */
1542 /* decoded_data_size < 0, it seems they are overflows */
1544 /* no audio frame */
1547 decoded_data_buf = (uint8_t *)samples;
1548 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1549 (ist->st->codec->sample_rate * ist->st->codec->channels);
1551 case AVMEDIA_TYPE_VIDEO:
1552 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1553 /* XXX: allocate picture correctly */
1554 avcodec_get_frame_defaults(&picture);
1555 avpkt.pts = pkt_pts;
1556 avpkt.dts = ist->pts;
1557 pkt_pts = AV_NOPTS_VALUE;
1559 ret = avcodec_decode_video2(ist->st->codec,
1560 &picture, &got_output, &avpkt);
1561 quality = same_quant ? picture.quality : 0;
1565 /* no picture yet */
1566 goto discard_packet;
1568 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1569 if (ist->st->codec->time_base.num != 0) {
1570 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1571 ist->next_pts += ((int64_t)AV_TIME_BASE *
1572 ist->st->codec->time_base.num * ticks) /
1573 ist->st->codec->time_base.den;
1576 buffer_to_free = NULL;
1577 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1579 case AVMEDIA_TYPE_SUBTITLE:
1580 ret = avcodec_decode_subtitle2(ist->st->codec,
1581 &subtitle, &got_output, &avpkt);
1585 goto discard_packet;
1587 subtitle_to_free = &subtitle;
1594 switch(ist->st->codec->codec_type) {
1595 case AVMEDIA_TYPE_AUDIO:
1596 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1597 ist->st->codec->sample_rate;
1599 case AVMEDIA_TYPE_VIDEO:
1600 if (ist->st->codec->time_base.num != 0) {
1601 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1602 ist->next_pts += ((int64_t)AV_TIME_BASE *
1603 ist->st->codec->time_base.num * ticks) /
1604 ist->st->codec->time_base.den;
1611 // preprocess audio (volume)
1612 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1613 if (audio_volume != 256) {
1616 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1617 int v = ((*volp) * audio_volume + 128) >> 8;
1618 *volp++ = av_clip_int16(v);
1623 /* frame rate emulation */
1625 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1626 int64_t now = av_gettime() - ist->start;
1630 /* if output time reached then transcode raw format,
1631 encode packets and output them */
1632 for (i = 0; i < nb_ostreams; i++) {
1633 OutputFile *of = &output_files[ost_table[i].file_index];
1636 ost = &ost_table[i];
1637 if (ost->source_index != ist_index)
1640 if (of->start_time && ist->pts < of->start_time)
1643 if (of->recording_time != INT64_MAX &&
1644 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1645 (AVRational){1, 1000000}) >= 0) {
1646 ost->is_past_recording_time = 1;
1651 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1652 ost->input_video_filter) {
1654 if (ist->st->sample_aspect_ratio.num)
1655 sar = ist->st->sample_aspect_ratio;
1657 sar = ist->st->codec->sample_aspect_ratio;
1658 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, ist->pts, sar);
1660 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1661 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1662 while (frame_available) {
1663 AVRational ist_pts_tb;
1664 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1665 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1667 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1669 os = output_files[ost->file_index].ctx;
1671 /* set the input output pts pairs */
1672 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1674 if (ost->encoding_needed) {
1675 av_assert0(ist->decoding_needed);
1676 switch(ost->st->codec->codec_type) {
1677 case AVMEDIA_TYPE_AUDIO:
1678 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1680 case AVMEDIA_TYPE_VIDEO:
1682 if (ost->picref->video && !ost->frame_aspect_ratio)
1683 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1685 do_video_out(os, ost, ist, &picture, &frame_size,
1686 same_quant ? quality : ost->st->codec->global_quality);
1687 if (vstats_filename && frame_size)
1688 do_video_stats(os, ost, frame_size);
1690 case AVMEDIA_TYPE_SUBTITLE:
1691 do_subtitle_out(os, ost, ist, &subtitle,
1698 AVFrame avframe; //FIXME/XXX remove this
1700 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1702 av_init_packet(&opkt);
1704 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1705 #if !CONFIG_AVFILTER
1711 /* no reencoding needed : output the packet directly */
1712 /* force the input stream PTS */
1714 avcodec_get_frame_defaults(&avframe);
1715 ost->st->codec->coded_frame= &avframe;
1716 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1718 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1719 audio_size += data_size;
1720 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1721 video_size += data_size;
1725 opkt.stream_index= ost->index;
1726 if(pkt->pts != AV_NOPTS_VALUE)
1727 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1729 opkt.pts= AV_NOPTS_VALUE;
1731 if (pkt->dts == AV_NOPTS_VALUE)
1732 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1734 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1735 opkt.dts -= ost_tb_start_time;
1737 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1738 opkt.flags= pkt->flags;
1740 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1741 if( ost->st->codec->codec_id != CODEC_ID_H264
1742 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1743 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1745 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1746 opkt.destruct= av_destruct_packet;
1748 opkt.data = data_buf;
1749 opkt.size = data_size;
1752 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1753 ost->st->codec->frame_number++;
1754 ost->frame_number++;
1755 av_free_packet(&opkt);
1759 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1760 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1762 avfilter_unref_buffer(ost->picref);
1767 av_free(buffer_to_free);
1768 /* XXX: allocate the subtitles in the codec ? */
1769 if (subtitle_to_free) {
1770 avsubtitle_free(subtitle_to_free);
1771 subtitle_to_free = NULL;
1779 static void print_sdp(OutputFile *output_files, int n)
1783 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1787 for (i = 0; i < n; i++)
1788 avc[i] = output_files[i].ctx;
1790 av_sdp_create(avc, n, sdp, sizeof(sdp));
1791 printf("SDP:\n%s\n", sdp);
1796 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1797 char *error, int error_len)
1800 InputStream *ist = &input_streams[ist_index];
1801 if (ist->decoding_needed) {
1802 AVCodec *codec = ist->dec;
1804 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1805 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1806 return AVERROR(EINVAL);
1809 /* update requested sample format for the decoder based on the
1810 corresponding encoder sample format */
1811 for (i = 0; i < nb_output_streams; i++) {
1812 OutputStream *ost = &output_streams[i];
1813 if (ost->source_index == ist_index) {
1814 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1819 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1820 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1821 ist->file_index, ist->st->index);
1822 return AVERROR(EINVAL);
1824 assert_codec_experimental(ist->st->codec, 0);
1825 assert_avoptions(ist->opts);
1828 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;
1829 ist->next_pts = AV_NOPTS_VALUE;
1830 init_pts_correction(&ist->pts_ctx);
1836 static int transcode_init(OutputFile *output_files,
1837 int nb_output_files,
1838 InputFile *input_files,
1842 AVFormatContext *os;
1843 AVCodecContext *codec, *icodec;
1850 for (i = 0; i < nb_input_streams; i++)
1851 input_streams[i].start = av_gettime();
1853 /* output stream init */
1854 for(i=0;i<nb_output_files;i++) {
1855 os = output_files[i].ctx;
1856 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1857 av_dump_format(os, i, os->filename, 1);
1858 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1859 return AVERROR(EINVAL);
1863 /* for each output stream, we compute the right encoding parameters */
1864 for (i = 0; i < nb_output_streams; i++) {
1865 ost = &output_streams[i];
1866 os = output_files[ost->file_index].ctx;
1867 ist = &input_streams[ost->source_index];
1869 codec = ost->st->codec;
1870 icodec = ist->st->codec;
1872 ost->st->disposition = ist->st->disposition;
1873 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1874 codec->chroma_sample_location = icodec->chroma_sample_location;
1876 if (ost->st->stream_copy) {
1877 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1879 if (extra_size > INT_MAX) {
1880 return AVERROR(EINVAL);
1883 /* if stream_copy is selected, no need to decode or encode */
1884 codec->codec_id = icodec->codec_id;
1885 codec->codec_type = icodec->codec_type;
1887 if(!codec->codec_tag){
1888 if( !os->oformat->codec_tag
1889 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1890 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1891 codec->codec_tag = icodec->codec_tag;
1894 codec->bit_rate = icodec->bit_rate;
1895 codec->rc_max_rate = icodec->rc_max_rate;
1896 codec->rc_buffer_size = icodec->rc_buffer_size;
1897 codec->extradata= av_mallocz(extra_size);
1898 if (!codec->extradata) {
1899 return AVERROR(ENOMEM);
1901 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1902 codec->extradata_size= icodec->extradata_size;
1903 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){
1904 codec->time_base = icodec->time_base;
1905 codec->time_base.num *= icodec->ticks_per_frame;
1906 av_reduce(&codec->time_base.num, &codec->time_base.den,
1907 codec->time_base.num, codec->time_base.den, INT_MAX);
1909 codec->time_base = ist->st->time_base;
1910 switch(codec->codec_type) {
1911 case AVMEDIA_TYPE_AUDIO:
1912 if(audio_volume != 256) {
1913 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1916 codec->channel_layout = icodec->channel_layout;
1917 codec->sample_rate = icodec->sample_rate;
1918 codec->channels = icodec->channels;
1919 codec->frame_size = icodec->frame_size;
1920 codec->audio_service_type = icodec->audio_service_type;
1921 codec->block_align= icodec->block_align;
1922 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1923 codec->block_align= 0;
1924 if(codec->codec_id == CODEC_ID_AC3)
1925 codec->block_align= 0;
1927 case AVMEDIA_TYPE_VIDEO:
1928 codec->pix_fmt = icodec->pix_fmt;
1929 codec->width = icodec->width;
1930 codec->height = icodec->height;
1931 codec->has_b_frames = icodec->has_b_frames;
1932 if (!codec->sample_aspect_ratio.num) {
1933 codec->sample_aspect_ratio =
1934 ost->st->sample_aspect_ratio =
1935 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1936 ist->st->codec->sample_aspect_ratio.num ?
1937 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
1940 case AVMEDIA_TYPE_SUBTITLE:
1941 codec->width = icodec->width;
1942 codec->height = icodec->height;
1944 case AVMEDIA_TYPE_DATA:
1951 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1952 switch(codec->codec_type) {
1953 case AVMEDIA_TYPE_AUDIO:
1954 ost->fifo= av_fifo_alloc(1024);
1956 return AVERROR(ENOMEM);
1958 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
1959 if (!codec->sample_rate) {
1960 codec->sample_rate = icodec->sample_rate;
1962 codec->sample_rate >>= icodec->lowres;
1964 choose_sample_rate(ost->st, ost->enc);
1965 codec->time_base = (AVRational){1, codec->sample_rate};
1966 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
1967 codec->sample_fmt = icodec->sample_fmt;
1968 choose_sample_fmt(ost->st, ost->enc);
1969 if (!codec->channels)
1970 codec->channels = icodec->channels;
1971 codec->channel_layout = icodec->channel_layout;
1972 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
1973 codec->channel_layout = 0;
1974 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
1975 icodec->request_channels = codec->channels;
1976 ist->decoding_needed = 1;
1977 ost->encoding_needed = 1;
1978 ost->resample_sample_fmt = icodec->sample_fmt;
1979 ost->resample_sample_rate = icodec->sample_rate;
1980 ost->resample_channels = icodec->channels;
1982 case AVMEDIA_TYPE_VIDEO:
1983 if (codec->pix_fmt == PIX_FMT_NONE)
1984 codec->pix_fmt = icodec->pix_fmt;
1985 choose_pixel_fmt(ost->st, ost->enc);
1987 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
1988 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
1992 if (!codec->width || !codec->height) {
1993 codec->width = icodec->width;
1994 codec->height = icodec->height;
1997 ost->video_resample = codec->width != icodec->width ||
1998 codec->height != icodec->height ||
1999 codec->pix_fmt != icodec->pix_fmt;
2000 if (ost->video_resample) {
2001 #if !CONFIG_AVFILTER
2002 avcodec_get_frame_defaults(&ost->pict_tmp);
2003 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2004 codec->width, codec->height)) {
2005 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2008 ost->img_resample_ctx = sws_getContext(
2015 ost->sws_flags, NULL, NULL, NULL);
2016 if (ost->img_resample_ctx == NULL) {
2017 fprintf(stderr, "Cannot get resampling context\n");
2021 codec->bits_per_raw_sample= 0;
2024 ost->resample_height = icodec->height;
2025 ost->resample_width = icodec->width;
2026 ost->resample_pix_fmt= icodec->pix_fmt;
2027 ost->encoding_needed = 1;
2028 ist->decoding_needed = 1;
2030 if (!ost->frame_rate.num)
2031 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2032 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2033 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2034 ost->frame_rate = ost->enc->supported_framerates[idx];
2036 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2039 if (configure_video_filters(ist, ost)) {
2040 fprintf(stderr, "Error opening filters!\n");
2045 case AVMEDIA_TYPE_SUBTITLE:
2046 ost->encoding_needed = 1;
2047 ist->decoding_needed = 1;
2054 if (ost->encoding_needed &&
2055 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2056 char logfilename[1024];
2059 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2060 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2062 if (codec->flags & CODEC_FLAG_PASS1) {
2063 f = fopen(logfilename, "wb");
2065 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2071 size_t logbuffer_size;
2072 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2073 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2076 codec->stats_in = logbuffer;
2080 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2081 int size= codec->width * codec->height;
2082 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2087 bit_buffer = av_malloc(bit_buffer_size);
2089 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2091 return AVERROR(ENOMEM);
2094 /* open each encoder */
2095 for (i = 0; i < nb_output_streams; i++) {
2096 ost = &output_streams[i];
2097 if (ost->encoding_needed) {
2098 AVCodec *codec = ost->enc;
2099 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2101 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2102 ost->st->codec->codec_id, ost->file_index, ost->index);
2103 ret = AVERROR(EINVAL);
2106 if (dec->subtitle_header) {
2107 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2108 if (!ost->st->codec->subtitle_header) {
2109 ret = AVERROR(ENOMEM);
2112 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2113 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2115 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2116 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2117 ost->file_index, ost->index);
2118 ret = AVERROR(EINVAL);
2121 assert_codec_experimental(ost->st->codec, 1);
2122 assert_avoptions(ost->opts);
2123 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2124 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2125 "It takes bits/s as argument, not kbits/s\n");
2126 extra_size += ost->st->codec->extradata_size;
2130 /* init input streams */
2131 for (i = 0; i < nb_input_streams; i++)
2132 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2135 /* open files and write file headers */
2136 for (i = 0; i < nb_output_files; i++) {
2137 os = output_files[i].ctx;
2138 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2139 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2140 ret = AVERROR(EINVAL);
2143 assert_avoptions(output_files[i].opts);
2144 if (strcmp(os->oformat->name, "rtp")) {
2150 /* dump the file output parameters - cannot be done before in case
2152 for(i=0;i<nb_output_files;i++) {
2153 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2156 /* dump the stream mapping */
2158 fprintf(stderr, "Stream mapping:\n");
2159 for (i = 0; i < nb_output_streams;i ++) {
2160 ost = &output_streams[i];
2161 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2162 input_streams[ost->source_index].file_index,
2163 input_streams[ost->source_index].st->index,
2166 if (ost->sync_ist != &input_streams[ost->source_index])
2167 fprintf(stderr, " [sync #%d.%d]",
2168 ost->sync_ist->file_index,
2169 ost->sync_ist->st->index);
2170 if (ost->st->stream_copy)
2171 fprintf(stderr, " (copy)");
2173 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2174 input_streams[ost->source_index].dec->name : "?",
2175 ost->enc ? ost->enc->name : "?");
2176 fprintf(stderr, "\n");
2181 fprintf(stderr, "%s\n", error);
2186 print_sdp(output_files, nb_output_files);
2193 * The following code is the main loop of the file converter
2195 static int transcode(OutputFile *output_files,
2196 int nb_output_files,
2197 InputFile *input_files,
2201 AVFormatContext *is, *os;
2205 int no_packet_count=0;
2206 int64_t timer_start;
2208 if (!(no_packet = av_mallocz(nb_input_files)))
2211 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2216 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2219 timer_start = av_gettime();
2221 for(; received_sigterm == 0;) {
2222 int file_index, ist_index;
2227 ipts_min = INT64_MAX;
2230 /* select the stream that we must read now by looking at the
2231 smallest output pts */
2233 for (i = 0; i < nb_output_streams; i++) {
2237 ost = &output_streams[i];
2238 of = &output_files[ost->file_index];
2239 os = output_files[ost->file_index].ctx;
2240 ist = &input_streams[ost->source_index];
2241 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2242 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2244 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2246 if (!input_files[ist->file_index].eof_reached){
2247 if(ipts < ipts_min) {
2249 if(input_sync ) file_index = ist->file_index;
2251 if(opts < opts_min) {
2253 if(!input_sync) file_index = ist->file_index;
2256 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2261 /* if none, if is finished */
2262 if (file_index < 0) {
2263 if(no_packet_count){
2265 memset(no_packet, 0, nb_input_files);
2272 /* read a frame from it and output it in the fifo */
2273 is = input_files[file_index].ctx;
2274 ret= av_read_frame(is, &pkt);
2275 if(ret == AVERROR(EAGAIN)){
2276 no_packet[file_index]=1;
2281 input_files[file_index].eof_reached = 1;
2289 memset(no_packet, 0, nb_input_files);
2292 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2293 is->streams[pkt.stream_index]);
2295 /* the following test is needed in case new streams appear
2296 dynamically in stream : we ignore them */
2297 if (pkt.stream_index >= input_files[file_index].nb_streams)
2298 goto discard_packet;
2299 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2300 ist = &input_streams[ist_index];
2302 goto discard_packet;
2304 if (pkt.dts != AV_NOPTS_VALUE)
2305 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2306 if (pkt.pts != AV_NOPTS_VALUE)
2307 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2309 if (ist->ts_scale) {
2310 if(pkt.pts != AV_NOPTS_VALUE)
2311 pkt.pts *= ist->ts_scale;
2312 if(pkt.dts != AV_NOPTS_VALUE)
2313 pkt.dts *= ist->ts_scale;
2316 // 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);
2317 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2318 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2319 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2320 int64_t delta= pkt_dts - ist->next_pts;
2321 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2322 input_files[ist->file_index].ts_offset -= delta;
2324 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2325 delta, input_files[ist->file_index].ts_offset);
2326 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2327 if(pkt.pts != AV_NOPTS_VALUE)
2328 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2332 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2333 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2336 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2337 ist->file_index, ist->st->index);
2340 av_free_packet(&pkt);
2345 av_free_packet(&pkt);
2347 /* dump report by using the output first video and audio streams */
2348 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2351 /* at the end of stream, we must flush the decoder buffers */
2352 for (i = 0; i < nb_input_streams; i++) {
2353 ist = &input_streams[i];
2354 if (ist->decoding_needed) {
2355 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2358 flush_encoders(output_streams, nb_output_streams);
2362 /* write the trailer if needed and close file */
2363 for(i=0;i<nb_output_files;i++) {
2364 os = output_files[i].ctx;
2365 av_write_trailer(os);
2368 /* dump report by using the first video and audio streams */
2369 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2371 /* close each encoder */
2372 for (i = 0; i < nb_output_streams; i++) {
2373 ost = &output_streams[i];
2374 if (ost->encoding_needed) {
2375 av_freep(&ost->st->codec->stats_in);
2376 avcodec_close(ost->st->codec);
2379 avfilter_graph_free(&ost->graph);
2383 /* close each decoder */
2384 for (i = 0; i < nb_input_streams; i++) {
2385 ist = &input_streams[i];
2386 if (ist->decoding_needed) {
2387 avcodec_close(ist->st->codec);
2395 av_freep(&bit_buffer);
2396 av_freep(&no_packet);
2398 if (output_streams) {
2399 for (i = 0; i < nb_output_streams; i++) {
2400 ost = &output_streams[i];
2402 if (ost->st->stream_copy)
2403 av_freep(&ost->st->codec->extradata);
2405 fclose(ost->logfile);
2406 ost->logfile = NULL;
2408 av_fifo_free(ost->fifo); /* works even if fifo is not
2409 initialized but set to zero */
2410 av_freep(&ost->st->codec->subtitle_header);
2411 av_free(ost->pict_tmp.data[0]);
2412 av_free(ost->forced_kf_pts);
2413 if (ost->video_resample)
2414 sws_freeContext(ost->img_resample_ctx);
2416 audio_resample_close(ost->resample);
2417 if (ost->reformat_ctx)
2418 av_audio_convert_free(ost->reformat_ctx);
2419 av_dict_free(&ost->opts);
2426 static int opt_format(const char *opt, const char *arg)
2428 last_asked_format = arg;
2432 static int opt_video_rc_override_string(const char *opt, const char *arg)
2434 video_rc_override_string = arg;
2438 static int opt_me_threshold(const char *opt, const char *arg)
2440 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2444 static int opt_verbose(const char *opt, const char *arg)
2446 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2450 static int opt_frame_rate(const char *opt, const char *arg)
2452 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2453 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2459 static int opt_frame_size(const char *opt, const char *arg)
2461 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2462 fprintf(stderr, "Incorrect frame size\n");
2463 return AVERROR(EINVAL);
2468 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2470 if (strcmp(arg, "list")) {
2471 frame_pix_fmt = av_get_pix_fmt(arg);
2472 if (frame_pix_fmt == PIX_FMT_NONE) {
2473 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2474 return AVERROR(EINVAL);
2483 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2490 p = strchr(arg, ':');
2492 x = strtol(arg, &end, 10);
2494 y = strtol(end+1, &end, 10);
2496 ar = (double)x / (double)y;
2498 ar = strtod(arg, NULL);
2501 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2502 return AVERROR(EINVAL);
2504 frame_aspect_ratio = ar;
2508 static int opt_metadata(const char *opt, const char *arg)
2510 char *mid= strchr(arg, '=');
2513 fprintf(stderr, "Missing =\n");
2518 av_dict_set(&metadata, arg, mid, 0);
2523 static int opt_qscale(const char *opt, const char *arg)
2525 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2526 if (video_qscale == 0) {
2527 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2528 return AVERROR(EINVAL);
2533 static int opt_top_field_first(const char *opt, const char *arg)
2535 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2539 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2541 if (strcmp(arg, "list")) {
2542 audio_sample_fmt = av_get_sample_fmt(arg);
2543 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2544 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2545 return AVERROR(EINVAL);
2550 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2551 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2557 static int opt_audio_rate(const char *opt, const char *arg)
2559 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2563 static int opt_audio_channels(const char *opt, const char *arg)
2565 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2569 static int opt_codec(const char *opt, const char *arg)
2571 return av_dict_set(&codec_names, opt, arg, 0);
2574 static int opt_audio_codec(const char *opt, const char *arg)
2576 return opt_codec("codec:a", arg);
2579 static int opt_video_codec(const char *opt, const char *arg)
2581 return opt_codec("codec:v", arg);
2584 static int opt_subtitle_codec(const char *opt, const char *arg)
2586 return opt_codec("codec:s", arg);
2589 static int opt_data_codec(const char *opt, const char *arg)
2591 return opt_codec("codec:d", arg);
2594 static int opt_codec_tag(const char *opt, const char *arg)
2597 uint32_t *codec_tag;
2599 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2600 !strcmp(opt, "vtag") ? &video_codec_tag :
2601 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2605 *codec_tag = strtol(arg, &tail, 0);
2607 *codec_tag = AV_RL32(arg);
2612 static int opt_map(const char *opt, const char *arg)
2614 StreamMap *m = NULL;
2615 int i, negative = 0, file_idx;
2616 int sync_file_idx = -1, sync_stream_idx;
2624 map = av_strdup(arg);
2626 /* parse sync stream first, just pick first matching stream */
2627 if (sync = strchr(map, ',')) {
2629 sync_file_idx = strtol(sync + 1, &sync, 0);
2630 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2631 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2636 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2637 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2638 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2639 sync_stream_idx = i;
2642 if (i == input_files[sync_file_idx].nb_streams) {
2643 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2644 "match any streams.\n", arg);
2650 file_idx = strtol(map, &p, 0);
2651 if (file_idx >= nb_input_files || file_idx < 0) {
2652 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2656 /* disable some already defined maps */
2657 for (i = 0; i < nb_stream_maps; i++) {
2658 m = &stream_maps[i];
2659 if (check_stream_specifier(input_files[m->file_index].ctx,
2660 input_files[m->file_index].ctx->streams[m->stream_index],
2661 *p == ':' ? p + 1 : p) > 0)
2665 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2666 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2667 *p == ':' ? p + 1 : p) <= 0)
2669 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2670 m = &stream_maps[nb_stream_maps - 1];
2672 m->file_index = file_idx;
2673 m->stream_index = i;
2675 if (sync_file_idx >= 0) {
2676 m->sync_file_index = sync_file_idx;
2677 m->sync_stream_index = sync_stream_idx;
2679 m->sync_file_index = file_idx;
2680 m->sync_stream_index = i;
2685 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2693 static void parse_meta_type(char *arg, char *type, int *index)
2703 if (*(++arg) == ':')
2704 *index = strtol(++arg, NULL, 0);
2707 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2714 static int opt_map_metadata(const char *opt, const char *arg)
2716 MetadataMap *m, *m1;
2719 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2720 &nb_meta_data_maps, nb_meta_data_maps + 1);
2722 m = &meta_data_maps[nb_meta_data_maps - 1][1];
2723 m->file = strtol(arg, &p, 0);
2724 parse_meta_type(p, &m->type, &m->index);
2726 m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2727 if (p = strchr(opt, ':'))
2728 parse_meta_type(p, &m1->type, &m1->index);
2732 if (m->type == 'g' || m1->type == 'g')
2733 metadata_global_autocopy = 0;
2734 if (m->type == 's' || m1->type == 's')
2735 metadata_streams_autocopy = 0;
2736 if (m->type == 'c' || m1->type == 'c')
2737 metadata_chapters_autocopy = 0;
2742 static int opt_input_ts_scale(const char *opt, const char *arg)
2744 return av_dict_set(&ts_scale, opt, arg, 0);
2747 static int opt_recording_time(const char *opt, const char *arg)
2749 recording_time = parse_time_or_die(opt, arg, 1);
2753 static int opt_start_time(const char *opt, const char *arg)
2755 start_time = parse_time_or_die(opt, arg, 1);
2759 static int opt_input_ts_offset(const char *opt, const char *arg)
2761 input_ts_offset = parse_time_or_die(opt, arg, 1);
2765 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2767 const char *codec_string = encoder ? "encoder" : "decoder";
2771 return CODEC_ID_NONE;
2773 avcodec_find_encoder_by_name(name) :
2774 avcodec_find_decoder_by_name(name);
2776 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2779 if(codec->type != type) {
2780 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2786 static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
2788 AVDictionaryEntry *e = NULL;
2789 char *codec_name = NULL;
2792 while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
2793 char *p = strchr(e->key, ':');
2795 if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
2796 codec_name = e->value;
2803 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2804 return avcodec_find_encoder(st->codec->codec_id);
2806 } else if (!strcmp(codec_name, "copy"))
2807 st->stream_copy = 1;
2809 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2810 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2811 avcodec_find_decoder_by_name(codec_name);
2818 * Add all the streams from the given input file to the global
2819 * list of input streams.
2821 static void add_input_streams(AVFormatContext *ic)
2823 int i, rfps, rfps_base, ret;
2825 for (i = 0; i < ic->nb_streams; i++) {
2826 AVStream *st = ic->streams[i];
2827 AVCodecContext *dec = st->codec;
2828 AVDictionaryEntry *e = NULL;
2832 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2833 ist = &input_streams[nb_input_streams - 1];
2835 ist->file_index = nb_input_files;
2837 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2839 while (e = av_dict_get(ts_scale, "", e, AV_DICT_IGNORE_SUFFIX)) {
2840 char *p = strchr(e->key, ':');
2842 if ((ret = check_stream_specifier(ic, st, p ? p + 1 : "")) > 0)
2848 ist->ts_scale = strtod(scale, NULL);
2850 ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
2852 ist->dec = avcodec_find_decoder(dec->codec_id);
2854 switch (dec->codec_type) {
2855 case AVMEDIA_TYPE_AUDIO:
2857 st->discard= AVDISCARD_ALL;
2859 case AVMEDIA_TYPE_VIDEO:
2860 rfps = ic->streams[i]->r_frame_rate.num;
2861 rfps_base = ic->streams[i]->r_frame_rate.den;
2863 dec->flags |= CODEC_FLAG_EMU_EDGE;
2864 dec->height >>= dec->lowres;
2865 dec->width >>= dec->lowres;
2868 dec->debug |= FF_DEBUG_MV;
2870 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2873 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2874 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2876 (float)rfps / rfps_base, rfps, rfps_base);
2880 st->discard= AVDISCARD_ALL;
2881 else if(video_discard)
2882 st->discard= video_discard;
2884 case AVMEDIA_TYPE_DATA:
2886 case AVMEDIA_TYPE_SUBTITLE:
2887 if(subtitle_disable)
2888 st->discard = AVDISCARD_ALL;
2890 case AVMEDIA_TYPE_ATTACHMENT:
2891 case AVMEDIA_TYPE_UNKNOWN:
2899 static int opt_input_file(const char *opt, const char *filename)
2901 AVFormatContext *ic;
2902 AVInputFormat *file_iformat = NULL;
2906 AVDictionary **opts;
2907 int orig_nb_streams; // number of streams before avformat_find_stream_info
2909 if (last_asked_format) {
2910 if (!(file_iformat = av_find_input_format(last_asked_format))) {
2911 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2914 last_asked_format = NULL;
2917 if (!strcmp(filename, "-"))
2920 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2921 !strcmp(filename, "/dev/stdin");
2923 /* get default parameters from command line */
2924 ic = avformat_alloc_context();
2926 print_error(filename, AVERROR(ENOMEM));
2929 if (audio_sample_rate) {
2930 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
2931 av_dict_set(&format_opts, "sample_rate", buf, 0);
2933 if (audio_channels) {
2934 snprintf(buf, sizeof(buf), "%d", audio_channels);
2935 av_dict_set(&format_opts, "channels", buf, 0);
2937 if (frame_rate.num) {
2938 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
2939 av_dict_set(&format_opts, "framerate", buf, 0);
2941 if (frame_width && frame_height) {
2942 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
2943 av_dict_set(&format_opts, "video_size", buf, 0);
2945 if (frame_pix_fmt != PIX_FMT_NONE)
2946 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
2948 ic->flags |= AVFMT_FLAG_NONBLOCK;
2950 /* open the input file with generic libav function */
2951 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2953 print_error(filename, err);
2956 assert_avoptions(format_opts);
2961 for(i=0; i<ic->nb_streams; i++){
2962 ic->streams[i]->discard= AVDISCARD_ALL;
2964 for(i=0; i<ic->nb_programs; i++){
2965 AVProgram *p= ic->programs[i];
2966 if(p->id != opt_programid){
2967 p->discard = AVDISCARD_ALL;
2970 for(j=0; j<p->nb_stream_indexes; j++){
2971 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
2976 fprintf(stderr, "Specified program id not found\n");
2982 /* apply forced codec ids */
2983 for (i = 0; i < ic->nb_streams; i++)
2984 choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
2986 /* Set AVCodecContext options for avformat_find_stream_info */
2987 opts = setup_find_stream_info_opts(ic, codec_opts);
2988 orig_nb_streams = ic->nb_streams;
2990 /* If not enough info to get the stream parameters, we decode the
2991 first frames to get it. (used in mpeg case for example) */
2992 ret = avformat_find_stream_info(ic, opts);
2993 if (ret < 0 && verbose >= 0) {
2994 fprintf(stderr, "%s: could not find codec parameters\n", filename);
2995 av_close_input_file(ic);
2999 timestamp = start_time;
3000 /* add the stream start time */
3001 if (ic->start_time != AV_NOPTS_VALUE)
3002 timestamp += ic->start_time;
3004 /* if seeking requested, we execute it */
3005 if (start_time != 0) {
3006 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3008 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3009 filename, (double)timestamp / AV_TIME_BASE);
3011 /* reset seek info */
3015 /* update the current parameters so that they match the one of the input stream */
3016 add_input_streams(ic);
3018 /* dump the file content */
3020 av_dump_format(ic, nb_input_files, filename, 0);
3022 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3023 input_files[nb_input_files - 1].ctx = ic;
3024 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3025 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3026 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3028 frame_rate = (AVRational){0, 0};
3029 frame_pix_fmt = PIX_FMT_NONE;
3032 audio_sample_rate = 0;
3034 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3035 av_dict_free(&ts_scale);
3036 input_ts_offset = 0;
3038 for (i = 0; i < orig_nb_streams; i++)
3039 av_dict_free(&opts[i]);
3041 av_dict_free(&codec_names);
3047 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3048 AVCodecContext *avctx)
3054 for (p = kf; *p; p++)
3057 ost->forced_kf_count = n;
3058 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3059 if (!ost->forced_kf_pts) {
3060 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3063 for (i = 0; i < n; i++) {
3064 p = i ? strchr(p, ',') + 1 : kf;
3065 t = parse_time_or_die("force_key_frames", p, 1);
3066 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3070 static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
3073 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3074 int idx = oc->nb_streams - 1;
3077 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3081 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3082 nb_output_streams + 1);
3083 ost = &output_streams[nb_output_streams - 1];
3084 ost->file_index = nb_output_files;
3087 st->codec->codec_type = type;
3088 ost->enc = choose_codec(oc, st, type, codec_names);
3090 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3093 avcodec_get_context_defaults3(st->codec, ost->enc);
3094 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3096 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3100 static OutputStream *new_video_stream(AVFormatContext *oc)
3104 AVCodecContext *video_enc;
3106 ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
3108 if (!st->stream_copy) {
3109 ost->frame_aspect_ratio = frame_aspect_ratio;
3110 frame_aspect_ratio = 0;
3112 ost->avfilter= vfilters;
3117 ost->bitstream_filters = video_bitstream_filters;
3118 video_bitstream_filters= NULL;
3120 video_enc = st->codec;
3123 video_enc->codec_tag= video_codec_tag;
3125 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3126 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3129 if (st->stream_copy) {
3130 video_enc->sample_aspect_ratio =
3131 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3137 ost->frame_rate = frame_rate;
3139 video_enc->width = frame_width;
3140 video_enc->height = frame_height;
3141 video_enc->pix_fmt = frame_pix_fmt;
3142 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3144 if (video_qscale || same_quant) {
3145 video_enc->flags |= CODEC_FLAG_QSCALE;
3146 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3150 video_enc->intra_matrix = intra_matrix;
3152 video_enc->inter_matrix = inter_matrix;
3154 p= video_rc_override_string;
3157 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3159 fprintf(stderr, "error parsing rc_override\n");
3162 video_enc->rc_override=
3163 av_realloc(video_enc->rc_override,
3164 sizeof(RcOverride)*(i+1));
3165 video_enc->rc_override[i].start_frame= start;
3166 video_enc->rc_override[i].end_frame = end;
3168 video_enc->rc_override[i].qscale= q;
3169 video_enc->rc_override[i].quality_factor= 1.0;
3172 video_enc->rc_override[i].qscale= 0;
3173 video_enc->rc_override[i].quality_factor= -q/100.0;
3178 video_enc->rc_override_count=i;
3179 if (!video_enc->rc_initial_buffer_occupancy)
3180 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3181 video_enc->me_threshold= me_threshold;
3182 video_enc->intra_dc_precision= intra_dc_precision - 8;
3185 video_enc->flags|= CODEC_FLAG_PSNR;
3190 video_enc->flags |= CODEC_FLAG_PASS1;
3192 video_enc->flags |= CODEC_FLAG_PASS2;
3196 if (forced_key_frames)
3197 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3199 if (video_language) {
3200 av_dict_set(&st->metadata, "language", video_language, 0);
3201 av_freep(&video_language);
3204 /* reset some key parameters */
3206 av_freep(&forced_key_frames);
3207 frame_pix_fmt = PIX_FMT_NONE;
3211 static OutputStream *new_audio_stream(AVFormatContext *oc)
3215 AVCodecContext *audio_enc;
3217 ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
3220 ost->bitstream_filters = audio_bitstream_filters;
3221 audio_bitstream_filters= NULL;
3223 audio_enc = st->codec;
3224 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3227 audio_enc->codec_tag= audio_codec_tag;
3229 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3230 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3232 if (!st->stream_copy) {
3233 if (audio_qscale > QSCALE_NONE) {
3234 audio_enc->flags |= CODEC_FLAG_QSCALE;
3235 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3238 audio_enc->channels = audio_channels;
3239 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3240 audio_enc->sample_fmt = audio_sample_fmt;
3241 if (audio_sample_rate)
3242 audio_enc->sample_rate = audio_sample_rate;
3244 if (audio_language) {
3245 av_dict_set(&st->metadata, "language", audio_language, 0);
3246 av_freep(&audio_language);
3249 /* reset some key parameters */
3255 static OutputStream *new_data_stream(AVFormatContext *oc)
3259 AVCodecContext *data_enc;
3261 ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
3263 data_enc = st->codec;
3264 if (!st->stream_copy) {
3265 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3270 data_enc->codec_tag= data_codec_tag;
3272 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3273 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3280 static OutputStream *new_subtitle_stream(AVFormatContext *oc)
3284 AVCodecContext *subtitle_enc;
3286 ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
3288 subtitle_enc = st->codec;
3290 ost->bitstream_filters = subtitle_bitstream_filters;
3291 subtitle_bitstream_filters= NULL;
3293 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3295 if(subtitle_codec_tag)
3296 subtitle_enc->codec_tag= subtitle_codec_tag;
3298 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3299 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3302 if (subtitle_language) {
3303 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3304 av_freep(&subtitle_language);
3307 subtitle_disable = 0;
3311 /* arg format is "output-stream-index:streamid-value". */
3312 static int opt_streamid(const char *opt, const char *arg)
3318 av_strlcpy(idx_str, arg, sizeof(idx_str));
3319 p = strchr(idx_str, ':');
3322 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3327 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3328 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3329 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3333 static int copy_chapters(int infile, int outfile)
3335 AVFormatContext *is = input_files[infile].ctx;
3336 AVFormatContext *os = output_files[outfile].ctx;
3339 for (i = 0; i < is->nb_chapters; i++) {
3340 AVChapter *in_ch = is->chapters[i], *out_ch;
3341 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
3342 AV_TIME_BASE_Q, in_ch->time_base);
3343 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
3344 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3347 if (in_ch->end < ts_off)
3349 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3352 out_ch = av_mallocz(sizeof(AVChapter));
3354 return AVERROR(ENOMEM);
3356 out_ch->id = in_ch->id;
3357 out_ch->time_base = in_ch->time_base;
3358 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3359 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3361 if (metadata_chapters_autocopy)
3362 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3365 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3367 return AVERROR(ENOMEM);
3368 os->chapters[os->nb_chapters - 1] = out_ch;
3373 static int read_avserver_streams(AVFormatContext *s, const char *filename)
3376 AVFormatContext *ic = NULL;
3378 err = avformat_open_input(&ic, filename, NULL, NULL);
3381 /* copy stream format */
3382 for(i=0;i<ic->nb_streams;i++) {
3387 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3388 ost = new_output_stream(s, codec->type);
3391 // FIXME: a more elegant solution is needed
3392 memcpy(st, ic->streams[i], sizeof(AVStream));
3394 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3396 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3397 choose_sample_fmt(st, codec);
3398 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3399 choose_pixel_fmt(st, codec);
3402 av_close_input_file(ic);
3406 static void opt_output_file(const char *filename)
3408 AVFormatContext *oc;
3410 AVOutputFormat *file_oformat;
3414 if (!strcmp(filename, "-"))
3417 oc = avformat_alloc_context();
3419 print_error(filename, AVERROR(ENOMEM));
3423 if (last_asked_format) {
3424 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3425 if (!file_oformat) {
3426 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3429 last_asked_format = NULL;
3431 file_oformat = av_guess_format(NULL, filename, NULL);
3432 if (!file_oformat) {
3433 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3439 oc->oformat = file_oformat;
3440 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3442 if (!strcmp(file_oformat->name, "ffm") &&
3443 av_strstart(filename, "http:", NULL)) {
3444 /* special case for files sent to avserver: we get the stream
3445 parameters from avserver */
3446 int err = read_avserver_streams(oc, filename);
3448 print_error(filename, err);
3451 } else if (!nb_stream_maps) {
3452 /* pick the "best" stream of each type */
3453 #define NEW_STREAM(type, index)\
3455 ost = new_ ## type ## _stream(oc);\
3456 ost->source_index = index;\
3457 ost->sync_ist = &input_streams[index];\
3458 input_streams[index].discard = 0;\
3461 /* video: highest resolution */
3462 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3463 int area = 0, idx = -1;
3464 for (i = 0; i < nb_input_streams; i++) {
3465 ist = &input_streams[i];
3466 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3467 ist->st->codec->width * ist->st->codec->height > area) {
3468 area = ist->st->codec->width * ist->st->codec->height;
3472 NEW_STREAM(video, idx);
3475 /* audio: most channels */
3476 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3477 int channels = 0, idx = -1;
3478 for (i = 0; i < nb_input_streams; i++) {
3479 ist = &input_streams[i];
3480 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3481 ist->st->codec->channels > channels) {
3482 channels = ist->st->codec->channels;
3486 NEW_STREAM(audio, idx);
3489 /* subtitles: pick first */
3490 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3491 for (i = 0; i < nb_input_streams; i++)
3492 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3493 NEW_STREAM(subtitle, i);
3497 /* do something with data? */
3499 for (i = 0; i < nb_stream_maps; i++) {
3500 StreamMap *map = &stream_maps[i];
3505 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3506 switch (ist->st->codec->codec_type) {
3507 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(oc); break;
3508 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(oc); break;
3509 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3510 case AVMEDIA_TYPE_DATA: ost = new_data_stream(oc); break;
3512 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3513 map->file_index, map->stream_index);
3517 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3518 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3519 map->sync_stream_index];
3524 av_dict_copy(&oc->metadata, metadata, 0);
3525 av_dict_free(&metadata);
3528 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3529 output_files[nb_output_files - 1].ctx = oc;
3530 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3531 output_files[nb_output_files - 1].recording_time = recording_time;
3532 output_files[nb_output_files - 1].start_time = start_time;
3533 output_files[nb_output_files - 1].limit_filesize = limit_filesize;
3534 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3536 /* check filename in case of an image number is expected */
3537 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3538 if (!av_filename_number_test(oc->filename)) {
3539 print_error(oc->filename, AVERROR(EINVAL));
3544 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3545 /* test if it already exists to avoid loosing precious files */
3546 if (!file_overwrite &&
3547 (strchr(filename, ':') == NULL ||
3548 filename[1] == ':' ||
3549 av_strstart(filename, "file:", NULL))) {
3550 if (avio_check(filename, 0) == 0) {
3552 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3554 if (!read_yesno()) {
3555 fprintf(stderr, "Not overwriting - exiting\n");
3560 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3567 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3568 print_error(filename, err);
3573 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3574 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3575 oc->flags |= AVFMT_FLAG_NONBLOCK;
3578 if (chapters_input_file >= nb_input_files) {
3579 if (chapters_input_file == INT_MAX) {
3580 /* copy chapters from the first input file that has them*/
3581 chapters_input_file = -1;
3582 for (i = 0; i < nb_input_files; i++)
3583 if (input_files[i].ctx->nb_chapters) {
3584 chapters_input_file = i;
3588 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3589 chapters_input_file);
3593 if (chapters_input_file >= 0)
3594 copy_chapters(chapters_input_file, nb_output_files - 1);
3597 for (i = 0; i < nb_meta_data_maps; i++) {
3598 AVFormatContext *files[2];
3599 AVDictionary **meta[2];
3602 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3603 if ((index) < 0 || (index) >= (nb_elems)) {\
3604 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3609 int in_file_index = meta_data_maps[i][1].file;
3610 if (in_file_index < 0)
3612 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3615 files[1] = input_files[in_file_index].ctx;
3617 for (j = 0; j < 2; j++) {
3618 MetadataMap *map = &meta_data_maps[i][j];
3620 switch (map->type) {
3622 meta[j] = &files[j]->metadata;
3625 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3626 meta[j] = &files[j]->streams[map->index]->metadata;
3629 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3630 meta[j] = &files[j]->chapters[map->index]->metadata;
3633 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3634 meta[j] = &files[j]->programs[map->index]->metadata;
3639 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3642 /* copy global metadata by default */
3643 if (metadata_global_autocopy && nb_input_files)
3644 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3645 AV_DICT_DONT_OVERWRITE);
3646 if (metadata_streams_autocopy)
3647 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3648 InputStream *ist = &input_streams[output_streams[i].source_index];
3649 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3652 frame_rate = (AVRational){0, 0};
3655 audio_sample_rate = 0;
3657 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3658 chapters_input_file = INT_MAX;
3659 recording_time = INT64_MAX;
3661 limit_filesize = UINT64_MAX;
3663 av_freep(&meta_data_maps);
3664 nb_meta_data_maps = 0;
3665 metadata_global_autocopy = 1;
3666 metadata_streams_autocopy = 1;
3667 metadata_chapters_autocopy = 1;
3668 av_freep(&stream_maps);
3670 av_freep(&streamid_map);
3671 nb_streamid_map = 0;
3673 av_dict_free(&codec_names);
3675 av_freep(&forced_key_frames);
3680 /* same option as mencoder */
3681 static int opt_pass(const char *opt, const char *arg)
3683 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3687 static int64_t getutime(void)
3690 struct rusage rusage;
3692 getrusage(RUSAGE_SELF, &rusage);
3693 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3694 #elif HAVE_GETPROCESSTIMES
3696 FILETIME c, e, k, u;
3697 proc = GetCurrentProcess();
3698 GetProcessTimes(proc, &c, &e, &k, &u);
3699 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3701 return av_gettime();
3705 static int64_t getmaxrss(void)
3707 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3708 struct rusage rusage;
3709 getrusage(RUSAGE_SELF, &rusage);
3710 return (int64_t)rusage.ru_maxrss * 1024;
3711 #elif HAVE_GETPROCESSMEMORYINFO
3713 PROCESS_MEMORY_COUNTERS memcounters;
3714 proc = GetCurrentProcess();
3715 memcounters.cb = sizeof(memcounters);
3716 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3717 return memcounters.PeakPagefileUsage;
3723 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3726 const char *p = str;
3733 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3740 static void opt_inter_matrix(const char *arg)
3742 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3743 parse_matrix_coeffs(inter_matrix, arg);
3746 static void opt_intra_matrix(const char *arg)
3748 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3749 parse_matrix_coeffs(intra_matrix, arg);
3752 static void show_usage(void)
3754 printf("Hyper fast Audio and Video encoder\n");
3755 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3759 static void show_help(void)
3762 AVOutputFormat *oformat = NULL;
3763 AVInputFormat *iformat = NULL;
3764 const AVClass *class;
3766 av_log_set_callback(log_callback_help);
3768 show_help_options(options, "Main options:\n",
3769 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3770 show_help_options(options, "\nAdvanced options:\n",
3771 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3773 show_help_options(options, "\nVideo options:\n",
3774 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3776 show_help_options(options, "\nAdvanced Video options:\n",
3777 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3778 OPT_VIDEO | OPT_EXPERT);
3779 show_help_options(options, "\nAudio options:\n",
3780 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3782 show_help_options(options, "\nAdvanced Audio options:\n",
3783 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3784 OPT_AUDIO | OPT_EXPERT);
3785 show_help_options(options, "\nSubtitle options:\n",
3786 OPT_SUBTITLE | OPT_GRAB,
3788 show_help_options(options, "\nAudio/Video grab options:\n",
3792 class = avcodec_get_class();
3793 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3796 /* individual codec options */
3798 while ((c = av_codec_next(c))) {
3799 if (c->priv_class) {
3800 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3805 class = avformat_get_class();
3806 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3809 /* individual muxer options */
3810 while ((oformat = av_oformat_next(oformat))) {
3811 if (oformat->priv_class) {
3812 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3817 /* individual demuxer options */
3818 while ((iformat = av_iformat_next(iformat))) {
3819 if (iformat->priv_class) {
3820 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3825 class = sws_get_class();
3826 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3829 static int opt_target(const char *opt, const char *arg)
3831 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3832 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3834 if(!strncmp(arg, "pal-", 4)) {
3837 } else if(!strncmp(arg, "ntsc-", 5)) {
3840 } else if(!strncmp(arg, "film-", 5)) {
3845 /* Calculate FR via float to avoid int overflow */
3846 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3849 } else if((fr == 29970) || (fr == 23976)) {
3852 /* Try to determine PAL/NTSC by peeking in the input files */
3853 if(nb_input_files) {
3855 for (j = 0; j < nb_input_files; j++) {
3856 for (i = 0; i < input_files[j].nb_streams; i++) {
3857 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3858 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3860 fr = c->time_base.den * 1000 / c->time_base.num;
3864 } else if((fr == 29970) || (fr == 23976)) {
3874 if(verbose > 0 && norm != UNKNOWN)
3875 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3878 if(norm == UNKNOWN) {
3879 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3880 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3881 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3885 if(!strcmp(arg, "vcd")) {
3886 opt_codec("c:v", "mpeg1video");
3887 opt_codec("c:a", "mp2");
3888 opt_format("f", "vcd");
3890 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
3891 opt_frame_rate("r", frame_rates[norm]);
3892 opt_default("g", norm == PAL ? "15" : "18");
3894 opt_default("b", "1150000");
3895 opt_default("maxrate", "1150000");
3896 opt_default("minrate", "1150000");
3897 opt_default("bufsize", "327680"); // 40*1024*8;
3899 opt_default("b:a", "224000");
3900 audio_sample_rate = 44100;
3903 opt_default("packetsize", "2324");
3904 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3906 /* We have to offset the PTS, so that it is consistent with the SCR.
3907 SCR starts at 36000, but the first two packs contain only padding
3908 and the first pack from the other stream, respectively, may also have
3909 been written before.
3910 So the real data starts at SCR 36000+3*1200. */
3911 mux_preload= (36000+3*1200) / 90000.0; //0.44
3912 } else if(!strcmp(arg, "svcd")) {
3914 opt_codec("c:v", "mpeg2video");
3915 opt_codec("c:a", "mp2");
3916 opt_format("f", "svcd");
3918 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
3919 opt_frame_rate("r", frame_rates[norm]);
3920 opt_default("g", norm == PAL ? "15" : "18");
3922 opt_default("b", "2040000");
3923 opt_default("maxrate", "2516000");
3924 opt_default("minrate", "0"); //1145000;
3925 opt_default("bufsize", "1835008"); //224*1024*8;
3926 opt_default("flags", "+scan_offset");
3929 opt_default("b:a", "224000");
3930 audio_sample_rate = 44100;
3932 opt_default("packetsize", "2324");
3934 } else if(!strcmp(arg, "dvd")) {
3936 opt_codec("c:v", "mpeg2video");
3937 opt_codec("c:a", "ac3");
3938 opt_format("f", "dvd");
3940 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
3941 opt_frame_rate("r", frame_rates[norm]);
3942 opt_default("g", norm == PAL ? "15" : "18");
3944 opt_default("b", "6000000");
3945 opt_default("maxrate", "9000000");
3946 opt_default("minrate", "0"); //1500000;
3947 opt_default("bufsize", "1835008"); //224*1024*8;
3949 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3950 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3952 opt_default("b:a", "448000");
3953 audio_sample_rate = 48000;
3955 } else if(!strncmp(arg, "dv", 2)) {
3957 opt_format("f", "dv");
3959 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
3960 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3961 norm == PAL ? "yuv420p" : "yuv411p");
3962 opt_frame_rate("r", frame_rates[norm]);
3964 audio_sample_rate = 48000;
3968 fprintf(stderr, "Unknown target: %s\n", arg);
3969 return AVERROR(EINVAL);
3974 static int opt_vstats_file(const char *opt, const char *arg)
3976 av_free (vstats_filename);
3977 vstats_filename=av_strdup (arg);
3981 static int opt_vstats(const char *opt, const char *arg)
3984 time_t today2 = time(NULL);
3985 struct tm *today = localtime(&today2);
3987 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3989 return opt_vstats_file(opt, filename);
3992 static int opt_bsf(const char *opt, const char *arg)
3994 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
3995 AVBitStreamFilterContext **bsfp;
3998 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4002 bsfp= *opt == 'v' ? &video_bitstream_filters :
4003 *opt == 'a' ? &audio_bitstream_filters :
4004 &subtitle_bitstream_filters;
4006 bsfp= &(*bsfp)->next;
4013 static const OptionDef options[] = {
4015 #include "cmdutils_common_opts.h"
4016 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4017 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4018 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4019 { "c", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4020 { "codec", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4021 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4022 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4023 "outfile[,metadata]:infile[,metadata]" },
4024 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file}, "set chapters mapping", "input_file_index" },
4025 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4026 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4027 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4028 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4029 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "scale" },
4030 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4031 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4032 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4033 "add timings for benchmarking" },
4034 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4035 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4036 "dump each input packet" },
4037 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4038 "when dumping packets, also dump the payload" },
4039 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4040 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4041 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4042 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4043 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4044 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4045 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4046 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4047 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4048 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4049 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4050 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4051 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4054 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4055 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4056 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4057 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4058 { "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" },
4059 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4060 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4061 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4062 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4063 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4064 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold", "threshold" },
4065 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4066 "use same quantizer as source (implies VBR)" },
4067 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4068 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4069 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4070 "deinterlace pictures" },
4071 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4072 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4073 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4075 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4077 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4078 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4079 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4080 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4081 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4082 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4083 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4084 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4085 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4086 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4089 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4090 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4091 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4092 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4093 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4094 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4095 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4096 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4097 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4098 { "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" },
4100 /* subtitle options */
4101 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4102 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4103 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4104 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4107 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4110 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4111 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4113 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4114 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4115 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4117 /* data codec support */
4118 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4120 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4124 int main(int argc, char **argv)
4128 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4130 avcodec_register_all();
4132 avdevice_register_all();
4135 avfilter_register_all();
4139 avio_set_interrupt_cb(decode_interrupt_cb);
4146 parse_options(argc, argv, options, opt_output_file);
4148 if(nb_output_files <= 0 && nb_input_files == 0) {
4150 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4154 /* file converter / grab */
4155 if (nb_output_files <= 0) {
4156 fprintf(stderr, "At least one output file must be specified\n");
4160 if (nb_input_files == 0) {
4161 fprintf(stderr, "At least one input file must be specified\n");
4166 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4168 ti = getutime() - ti;
4170 int maxrss = getmaxrss() / 1024;
4171 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);