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 int thread_count= 1;
194 static int64_t video_size = 0;
195 static int64_t audio_size = 0;
196 static int64_t extra_size = 0;
197 static int nb_frames_dup = 0;
198 static int nb_frames_drop = 0;
199 static int input_sync;
200 static uint64_t limit_filesize = UINT64_MAX;
201 static int force_fps = 0;
202 static char *forced_key_frames = NULL;
204 static float dts_delta_threshold = 10;
206 static uint8_t *audio_buf;
207 static uint8_t *audio_out;
208 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
210 static short *samples;
212 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
213 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
214 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
216 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
218 typedef struct InputStream {
221 int discard; /* true if stream data should be discarded */
222 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
225 int64_t start; /* time when read started */
226 int64_t next_pts; /* synthetic pts for cases where pkt.pts
228 int64_t pts; /* current pts */
229 PtsCorrectionContext pts_ctx;
231 int is_start; /* is 1 at the start and after a discontinuity */
232 int showed_multi_packet_warning;
236 typedef struct InputFile {
237 AVFormatContext *ctx;
238 int eof_reached; /* true if eof reached */
239 int ist_index; /* index of first stream in ist_table */
240 int buffer_size; /* current total buffer size */
244 typedef struct OutputStream {
245 int file_index; /* file index */
246 int index; /* stream index in the output file */
247 int source_index; /* InputStream index */
248 AVStream *st; /* stream in the output file */
249 int encoding_needed; /* true if encoding needed for this stream */
251 /* input pts and corresponding output pts
253 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
254 struct InputStream *sync_ist; /* input stream to sync against */
255 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
256 AVBitStreamFilterContext *bitstream_filters;
261 AVFrame pict_tmp; /* temporary image for resampling */
262 struct SwsContext *img_resample_ctx; /* for image resampling */
265 int resample_pix_fmt;
266 AVRational frame_rate;
268 float frame_aspect_ratio;
270 /* forced key frames */
271 int64_t *forced_kf_pts;
277 ReSampleContext *resample; /* for audio resampling */
278 int resample_sample_fmt;
279 int resample_channels;
280 int resample_sample_rate;
282 AVAudioConvert *reformat_ctx;
283 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
287 AVFilterContext *output_video_filter;
288 AVFilterContext *input_video_filter;
289 AVFilterBufferRef *picref;
291 AVFilterGraph *graph;
296 int is_past_recording_time;
300 typedef struct OutputFile {
301 AVFormatContext *ctx;
303 int ost_index; /* index of the first stream in output_streams */
304 int64_t recording_time; /* desired length of the resulting file in microseconds */
305 int64_t start_time; /* start time in microseconds */
306 uint64_t limit_filesize;
309 static InputStream *input_streams = NULL;
310 static int nb_input_streams = 0;
311 static InputFile *input_files = NULL;
312 static int nb_input_files = 0;
314 static OutputStream *output_streams = NULL;
315 static int nb_output_streams = 0;
316 static OutputFile *output_files = NULL;
317 static int nb_output_files = 0;
321 static int configure_video_filters(InputStream *ist, OutputStream *ost)
323 AVFilterContext *last_filter, *filter;
324 /** filter graph containing all filters including input & output */
325 AVCodecContext *codec = ost->st->codec;
326 AVCodecContext *icodec = ist->st->codec;
327 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
328 AVRational sample_aspect_ratio;
332 ost->graph = avfilter_graph_alloc();
334 if (ist->st->sample_aspect_ratio.num){
335 sample_aspect_ratio = ist->st->sample_aspect_ratio;
337 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
339 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
340 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
341 sample_aspect_ratio.num, sample_aspect_ratio.den);
343 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
344 "src", args, NULL, ost->graph);
347 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
348 "out", NULL, &ffsink_ctx, ost->graph);
351 last_filter = ost->input_video_filter;
353 if (codec->width != icodec->width || codec->height != icodec->height) {
354 snprintf(args, 255, "%d:%d:flags=0x%X",
358 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
359 NULL, args, NULL, ost->graph)) < 0)
361 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
363 last_filter = filter;
366 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
367 ost->graph->scale_sws_opts = av_strdup(args);
370 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
371 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
373 outputs->name = av_strdup("in");
374 outputs->filter_ctx = last_filter;
375 outputs->pad_idx = 0;
376 outputs->next = NULL;
378 inputs->name = av_strdup("out");
379 inputs->filter_ctx = ost->output_video_filter;
383 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
385 av_freep(&ost->avfilter);
387 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
391 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
394 codec->width = ost->output_video_filter->inputs[0]->w;
395 codec->height = ost->output_video_filter->inputs[0]->h;
396 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
397 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
398 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
399 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
403 #endif /* CONFIG_AVFILTER */
405 static void term_exit(void)
407 av_log(NULL, AV_LOG_QUIET, "");
410 static volatile int received_sigterm = 0;
411 static volatile int received_nb_signals = 0;
414 sigterm_handler(int sig)
416 received_sigterm = sig;
417 received_nb_signals++;
421 static void term_init(void)
423 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
424 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
426 signal(SIGXCPU, sigterm_handler);
430 static int decode_interrupt_cb(void)
432 return received_nb_signals > 1;
435 static int exit_program(int ret)
440 for(i=0;i<nb_output_files;i++) {
441 AVFormatContext *s = output_files[i].ctx;
442 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
444 avformat_free_context(s);
445 av_dict_free(&output_files[i].opts);
447 for(i=0;i<nb_input_files;i++) {
448 av_close_input_file(input_files[i].ctx);
450 for (i = 0; i < nb_input_streams; i++)
451 av_dict_free(&input_streams[i].opts);
453 av_free(intra_matrix);
454 av_free(inter_matrix);
458 av_free(vstats_filename);
460 av_free(meta_data_maps);
462 av_freep(&input_streams);
463 av_freep(&input_files);
464 av_freep(&output_streams);
465 av_freep(&output_files);
470 allocated_audio_buf_size= allocated_audio_out_size= 0;
477 if (received_sigterm) {
479 "Received signal %d: terminating.\n",
480 (int) received_sigterm);
484 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 /* similar to ff_dynarray_add() and av_fast_realloc() */
515 static void *grow_array(void *array, int elem_size, int *size, int new_size)
517 if (new_size >= INT_MAX / elem_size) {
518 fprintf(stderr, "Array too big.\n");
521 if (*size < new_size) {
522 uint8_t *tmp = av_realloc(array, new_size*elem_size);
524 fprintf(stderr, "Could not alloc buffer.\n");
527 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
534 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
536 if(codec && codec->sample_fmts){
537 const enum AVSampleFormat *p= codec->sample_fmts;
539 if(*p == st->codec->sample_fmt)
543 av_log(NULL, AV_LOG_WARNING,
544 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
545 av_get_sample_fmt_name(st->codec->sample_fmt),
547 av_get_sample_fmt_name(codec->sample_fmts[0]));
548 st->codec->sample_fmt = codec->sample_fmts[0];
554 * Update the requested input sample format based on the output sample format.
555 * This is currently only used to request float output from decoders which
556 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
557 * Ideally this will be removed in the future when decoders do not do format
558 * conversion and only output in their native format.
560 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
563 /* if sample formats match or a decoder sample format has already been
564 requested, just return */
565 if (enc->sample_fmt == dec->sample_fmt ||
566 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
569 /* if decoder supports more than one output format */
570 if (dec_codec && dec_codec->sample_fmts &&
571 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
572 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
573 const enum AVSampleFormat *p;
574 int min_dec = -1, min_inc = -1;
576 /* find a matching sample format in the encoder */
577 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
578 if (*p == enc->sample_fmt) {
579 dec->request_sample_fmt = *p;
581 } else if (*p > enc->sample_fmt) {
582 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
584 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
587 /* if none match, provide the one that matches quality closest */
588 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
589 enc->sample_fmt - min_dec;
593 static void choose_sample_rate(AVStream *st, AVCodec *codec)
595 if(codec && codec->supported_samplerates){
596 const int *p= codec->supported_samplerates;
598 int best_dist=INT_MAX;
600 int dist= abs(st->codec->sample_rate - *p);
601 if(dist < best_dist){
607 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
609 st->codec->sample_rate= best;
613 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
615 if(codec && codec->pix_fmts){
616 const enum PixelFormat *p= codec->pix_fmts;
617 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
618 if(st->codec->codec_id==CODEC_ID_MJPEG){
619 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
620 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
621 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};
625 if(*p == st->codec->pix_fmt)
629 if(st->codec->pix_fmt != PIX_FMT_NONE)
630 av_log(NULL, AV_LOG_WARNING,
631 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
632 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
634 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
635 st->codec->pix_fmt = codec->pix_fmts[0];
641 get_sync_ipts(const OutputStream *ost)
643 const InputStream *ist = ost->sync_ist;
644 OutputFile *of = &output_files[ost->file_index];
645 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
648 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
652 AVPacket new_pkt= *pkt;
653 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
654 &new_pkt.data, &new_pkt.size,
655 pkt->data, pkt->size,
656 pkt->flags & AV_PKT_FLAG_KEY);
659 new_pkt.destruct= av_destruct_packet;
661 fprintf(stderr, "%s failed for stream %d, codec %s",
662 bsfc->filter->name, pkt->stream_index,
663 avctx->codec ? avctx->codec->name : "copy");
673 ret= av_interleaved_write_frame(s, pkt);
675 print_error("av_interleaved_write_frame()", ret);
680 static void do_audio_out(AVFormatContext *s,
683 unsigned char *buf, int size)
686 int64_t audio_out_size, audio_buf_size;
687 int64_t allocated_for_size= size;
689 int size_out, frame_bytes, ret, resample_changed;
690 AVCodecContext *enc= ost->st->codec;
691 AVCodecContext *dec= ist->st->codec;
692 int osize = av_get_bytes_per_sample(enc->sample_fmt);
693 int isize = av_get_bytes_per_sample(dec->sample_fmt);
694 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
697 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
698 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
699 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
700 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
701 audio_buf_size*= osize*enc->channels;
703 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
704 if(coded_bps > 8*osize)
705 audio_out_size= audio_out_size * coded_bps / (8*osize);
706 audio_out_size += FF_MIN_BUFFER_SIZE;
708 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
709 fprintf(stderr, "Buffer sizes too large\n");
713 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
714 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
715 if (!audio_buf || !audio_out){
716 fprintf(stderr, "Out of memory in do_audio_out\n");
720 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
721 ost->audio_resample = 1;
723 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
724 ost->resample_channels != dec->channels ||
725 ost->resample_sample_rate != dec->sample_rate;
727 if ((ost->audio_resample && !ost->resample) || resample_changed) {
728 if (resample_changed) {
729 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",
730 ist->file_index, ist->st->index,
731 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
732 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
733 ost->resample_sample_fmt = dec->sample_fmt;
734 ost->resample_channels = dec->channels;
735 ost->resample_sample_rate = dec->sample_rate;
737 audio_resample_close(ost->resample);
739 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
740 if (audio_sync_method <= 1 &&
741 ost->resample_sample_fmt == enc->sample_fmt &&
742 ost->resample_channels == enc->channels &&
743 ost->resample_sample_rate == enc->sample_rate) {
744 ost->resample = NULL;
745 ost->audio_resample = 0;
746 } else if (ost->audio_resample) {
747 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
748 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
749 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
750 enc->sample_rate, dec->sample_rate,
751 enc->sample_fmt, dec->sample_fmt,
753 if (!ost->resample) {
754 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
755 dec->channels, dec->sample_rate,
756 enc->channels, enc->sample_rate);
762 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
763 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
764 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
765 if (ost->reformat_ctx)
766 av_audio_convert_free(ost->reformat_ctx);
767 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
768 dec->sample_fmt, 1, NULL, 0);
769 if (!ost->reformat_ctx) {
770 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
771 av_get_sample_fmt_name(dec->sample_fmt),
772 av_get_sample_fmt_name(enc->sample_fmt));
775 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
778 if(audio_sync_method){
779 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
780 - av_fifo_size(ost->fifo)/(enc->channels * 2);
781 double idelta= delta*dec->sample_rate / enc->sample_rate;
782 int byte_delta= ((int)idelta)*2*dec->channels;
784 //FIXME resample delay
785 if(fabs(delta) > 50){
786 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
788 byte_delta= FFMAX(byte_delta, -size);
792 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
797 static uint8_t *input_tmp= NULL;
798 input_tmp= av_realloc(input_tmp, byte_delta + size);
800 if(byte_delta > allocated_for_size - size){
801 allocated_for_size= byte_delta + (int64_t)size;
806 memset(input_tmp, 0, byte_delta);
807 memcpy(input_tmp + byte_delta, buf, size);
811 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
813 }else if(audio_sync_method>1){
814 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
815 av_assert0(ost->audio_resample);
817 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
818 // 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));
819 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
823 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
824 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
826 if (ost->audio_resample) {
828 size_out = audio_resample(ost->resample,
829 (short *)buftmp, (short *)buf,
830 size / (dec->channels * isize));
831 size_out = size_out * enc->channels * osize;
837 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
838 const void *ibuf[6]= {buftmp};
839 void *obuf[6]= {audio_buf};
840 int istride[6]= {isize};
841 int ostride[6]= {osize};
842 int len= size_out/istride[0];
843 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
844 printf("av_audio_convert() failed\n");
850 size_out = len*osize;
853 /* now encode as many frames as possible */
854 if (enc->frame_size > 1) {
855 /* output resampled raw samples */
856 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
857 fprintf(stderr, "av_fifo_realloc2() failed\n");
860 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
862 frame_bytes = enc->frame_size * osize * enc->channels;
864 while (av_fifo_size(ost->fifo) >= frame_bytes) {
866 av_init_packet(&pkt);
868 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
870 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
872 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
875 fprintf(stderr, "Audio encoding failed\n");
879 pkt.stream_index= ost->index;
882 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
883 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
884 pkt.flags |= AV_PKT_FLAG_KEY;
885 write_frame(s, &pkt, enc, ost->bitstream_filters);
887 ost->sync_opts += enc->frame_size;
891 av_init_packet(&pkt);
893 ost->sync_opts += size_out / (osize * enc->channels);
895 /* output a pcm frame */
896 /* determine the size of the coded buffer */
899 size_out = size_out*coded_bps/8;
901 if(size_out > audio_out_size){
902 fprintf(stderr, "Internal error, buffer size too small\n");
906 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
907 ret = avcodec_encode_audio(enc, audio_out, size_out,
910 fprintf(stderr, "Audio encoding failed\n");
914 pkt.stream_index= ost->index;
917 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
918 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
919 pkt.flags |= AV_PKT_FLAG_KEY;
920 write_frame(s, &pkt, enc, ost->bitstream_filters);
924 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
928 AVPicture picture_tmp;
931 dec = ist->st->codec;
933 /* deinterlace : must be done before any resize */
934 if (do_deinterlace) {
937 /* create temporary picture */
938 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
939 buf = av_malloc(size);
943 picture2 = &picture_tmp;
944 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
946 if(avpicture_deinterlace(picture2, picture,
947 dec->pix_fmt, dec->width, dec->height) < 0) {
948 /* if error, do not deinterlace */
949 fprintf(stderr, "Deinterlacing failed\n");
958 if (picture != picture2)
959 *picture = *picture2;
963 static void do_subtitle_out(AVFormatContext *s,
969 static uint8_t *subtitle_out = NULL;
970 int subtitle_out_max_size = 1024 * 1024;
971 int subtitle_out_size, nb, i;
975 if (pts == AV_NOPTS_VALUE) {
976 fprintf(stderr, "Subtitle packets must have a pts\n");
982 enc = ost->st->codec;
985 subtitle_out = av_malloc(subtitle_out_max_size);
988 /* Note: DVB subtitle need one packet to draw them and one other
989 packet to clear them */
990 /* XXX: signal it in the codec context ? */
991 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
996 for(i = 0; i < nb; i++) {
997 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
998 // start_display_time is required to be 0
999 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1000 sub->end_display_time -= sub->start_display_time;
1001 sub->start_display_time = 0;
1002 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1003 subtitle_out_max_size, sub);
1004 if (subtitle_out_size < 0) {
1005 fprintf(stderr, "Subtitle encoding failed\n");
1009 av_init_packet(&pkt);
1010 pkt.stream_index = ost->index;
1011 pkt.data = subtitle_out;
1012 pkt.size = subtitle_out_size;
1013 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1014 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1015 /* XXX: the pts correction is handled here. Maybe handling
1016 it in the codec would be better */
1018 pkt.pts += 90 * sub->start_display_time;
1020 pkt.pts += 90 * sub->end_display_time;
1022 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1026 static int bit_buffer_size= 1024*256;
1027 static uint8_t *bit_buffer= NULL;
1029 static void do_video_resample(OutputStream *ost,
1031 AVFrame *in_picture,
1032 AVFrame **out_picture)
1034 int resample_changed = 0;
1035 AVCodecContext *dec = ist->st->codec;
1036 *out_picture = in_picture;
1038 resample_changed = ost->resample_width != dec->width ||
1039 ost->resample_height != dec->height ||
1040 ost->resample_pix_fmt != dec->pix_fmt;
1042 if (resample_changed) {
1043 av_log(NULL, AV_LOG_INFO,
1044 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1045 ist->file_index, ist->st->index,
1046 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1047 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1048 if(!ost->video_resample)
1049 ost->video_resample = 1;
1052 #if !CONFIG_AVFILTER
1053 if (ost->video_resample) {
1054 *out_picture = &ost->pict_tmp;
1055 if (resample_changed) {
1056 /* initialize a new scaler context */
1057 sws_freeContext(ost->img_resample_ctx);
1058 ost->img_resample_ctx = sws_getContext(
1059 ist->st->codec->width,
1060 ist->st->codec->height,
1061 ist->st->codec->pix_fmt,
1062 ost->st->codec->width,
1063 ost->st->codec->height,
1064 ost->st->codec->pix_fmt,
1065 ost->sws_flags, NULL, NULL, NULL);
1066 if (ost->img_resample_ctx == NULL) {
1067 fprintf(stderr, "Cannot get resampling context\n");
1071 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1072 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1075 if (resample_changed) {
1076 avfilter_graph_free(&ost->graph);
1077 if (configure_video_filters(ist, ost)) {
1078 fprintf(stderr, "Error reinitializing filters!\n");
1083 if (resample_changed) {
1084 ost->resample_width = dec->width;
1085 ost->resample_height = dec->height;
1086 ost->resample_pix_fmt = dec->pix_fmt;
1091 static void do_video_out(AVFormatContext *s,
1094 AVFrame *in_picture,
1095 int *frame_size, float quality)
1097 int nb_frames, i, ret, format_video_sync;
1098 AVFrame *final_picture;
1099 AVCodecContext *enc, *dec;
1102 enc = ost->st->codec;
1103 dec = ist->st->codec;
1105 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1107 /* by default, we output a single frame */
1112 format_video_sync = video_sync_method;
1113 if (format_video_sync < 0)
1114 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1116 if (format_video_sync) {
1117 double vdelta = sync_ipts - ost->sync_opts;
1118 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1121 else if (format_video_sync == 2) {
1124 }else if(vdelta>0.6)
1125 ost->sync_opts= lrintf(sync_ipts);
1126 }else if (vdelta > 1.1)
1127 nb_frames = lrintf(vdelta);
1128 //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);
1129 if (nb_frames == 0){
1132 fprintf(stderr, "*** drop!\n");
1133 }else if (nb_frames > 1) {
1134 nb_frames_dup += nb_frames - 1;
1136 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1139 ost->sync_opts= lrintf(sync_ipts);
1141 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1145 do_video_resample(ost, ist, in_picture, &final_picture);
1147 /* duplicates frame if needed */
1148 for(i=0;i<nb_frames;i++) {
1150 av_init_packet(&pkt);
1151 pkt.stream_index= ost->index;
1153 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1154 /* raw pictures are written as AVPicture structure to
1155 avoid any copies. We support temporarily the older
1157 AVFrame* old_frame = enc->coded_frame;
1158 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1159 pkt.data= (uint8_t *)final_picture;
1160 pkt.size= sizeof(AVPicture);
1161 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1162 pkt.flags |= AV_PKT_FLAG_KEY;
1164 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1165 enc->coded_frame = old_frame;
1167 AVFrame big_picture;
1169 big_picture= *final_picture;
1170 /* better than nothing: use input picture interlaced
1172 big_picture.interlaced_frame = in_picture->interlaced_frame;
1173 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1174 if(top_field_first == -1)
1175 big_picture.top_field_first = in_picture->top_field_first;
1177 big_picture.top_field_first = top_field_first;
1180 /* handles same_quant here. This is not correct because it may
1181 not be a global option */
1182 big_picture.quality = quality;
1184 big_picture.pict_type = 0;
1185 // big_picture.pts = AV_NOPTS_VALUE;
1186 big_picture.pts= ost->sync_opts;
1187 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1188 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1189 if (ost->forced_kf_index < ost->forced_kf_count &&
1190 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1191 big_picture.pict_type = AV_PICTURE_TYPE_I;
1192 ost->forced_kf_index++;
1194 ret = avcodec_encode_video(enc,
1195 bit_buffer, bit_buffer_size,
1198 fprintf(stderr, "Video encoding failed\n");
1203 pkt.data= bit_buffer;
1205 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1206 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1207 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1208 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1209 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1211 if(enc->coded_frame->key_frame)
1212 pkt.flags |= AV_PKT_FLAG_KEY;
1213 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1216 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1217 // enc->frame_number-1, ret, enc->pict_type);
1218 /* if two pass, output log */
1219 if (ost->logfile && enc->stats_out) {
1220 fprintf(ost->logfile, "%s", enc->stats_out);
1225 ost->frame_number++;
1229 static double psnr(double d){
1230 return -10.0*log(d)/log(10.0);
1233 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1236 AVCodecContext *enc;
1238 double ti1, bitrate, avg_bitrate;
1240 /* this is executed just the first time do_video_stats is called */
1242 vstats_file = fopen(vstats_filename, "w");
1249 enc = ost->st->codec;
1250 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1251 frame_number = ost->frame_number;
1252 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1253 if (enc->flags&CODEC_FLAG_PSNR)
1254 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1256 fprintf(vstats_file,"f_size= %6d ", frame_size);
1257 /* compute pts value */
1258 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1262 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1263 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1264 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1265 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1266 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1270 static void print_report(OutputFile *output_files,
1271 OutputStream *ost_table, int nb_ostreams,
1272 int is_last_report, int64_t timer_start)
1276 AVFormatContext *oc;
1278 AVCodecContext *enc;
1279 int frame_number, vid, i;
1280 double bitrate, ti1, pts;
1281 static int64_t last_time = -1;
1282 static int qp_histogram[52];
1284 if (!is_last_report) {
1286 /* display the report every 0.5 seconds */
1287 cur_time = av_gettime();
1288 if (last_time == -1) {
1289 last_time = cur_time;
1292 if ((cur_time - last_time) < 500000)
1294 last_time = cur_time;
1298 oc = output_files[0].ctx;
1300 total_size = avio_size(oc->pb);
1301 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1302 total_size= avio_tell(oc->pb);
1307 for(i=0;i<nb_ostreams;i++) {
1309 ost = &ost_table[i];
1310 enc = ost->st->codec;
1311 if (!ost->st->stream_copy && enc->coded_frame)
1312 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1313 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1314 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1316 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1317 float t = (av_gettime()-timer_start) / 1000000.0;
1319 frame_number = ost->frame_number;
1320 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1321 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1323 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1327 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1330 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1332 if (enc->flags&CODEC_FLAG_PSNR){
1334 double error, error_sum=0;
1335 double scale, scale_sum=0;
1336 char type[3]= {'Y','U','V'};
1337 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1340 error= enc->error[j];
1341 scale= enc->width*enc->height*255.0*255.0*frame_number;
1343 error= enc->coded_frame->error[j];
1344 scale= enc->width*enc->height*255.0*255.0;
1349 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1351 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1355 /* compute min output value */
1356 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1357 if ((pts < ti1) && (pts > 0))
1363 if (verbose > 0 || is_last_report) {
1364 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1366 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1367 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1368 (double)total_size / 1024, ti1, bitrate);
1370 if (nb_frames_dup || nb_frames_drop)
1371 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1372 nb_frames_dup, nb_frames_drop);
1375 fprintf(stderr, "%s \r", buf);
1380 if (is_last_report && verbose >= 0){
1381 int64_t raw= audio_size + video_size + extra_size;
1382 fprintf(stderr, "\n");
1383 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1387 100.0*(total_size - raw)/raw
1392 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1394 int fill_char = 0x00;
1395 if (sample_fmt == AV_SAMPLE_FMT_U8)
1397 memset(buf, fill_char, size);
1400 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1404 for (i = 0; i < nb_ostreams; i++) {
1405 OutputStream *ost = &ost_table[i];
1406 AVCodecContext *enc = ost->st->codec;
1407 AVFormatContext *os = output_files[ost->file_index].ctx;
1409 if (!ost->encoding_needed)
1412 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1414 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1420 av_init_packet(&pkt);
1421 pkt.stream_index= ost->index;
1423 switch (ost->st->codec->codec_type) {
1424 case AVMEDIA_TYPE_AUDIO:
1425 fifo_bytes = av_fifo_size(ost->fifo);
1427 /* encode any samples remaining in fifo */
1428 if (fifo_bytes > 0) {
1429 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1430 int fs_tmp = enc->frame_size;
1432 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1433 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1434 enc->frame_size = fifo_bytes / (osize * enc->channels);
1436 int frame_bytes = enc->frame_size*osize*enc->channels;
1437 if (allocated_audio_buf_size < frame_bytes)
1439 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1442 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1443 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1444 ost->st->time_base.num, enc->sample_rate);
1445 enc->frame_size = fs_tmp;
1448 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1451 fprintf(stderr, "Audio encoding failed\n");
1455 pkt.flags |= AV_PKT_FLAG_KEY;
1457 case AVMEDIA_TYPE_VIDEO:
1458 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1460 fprintf(stderr, "Video encoding failed\n");
1464 if(enc->coded_frame && enc->coded_frame->key_frame)
1465 pkt.flags |= AV_PKT_FLAG_KEY;
1466 if (ost->logfile && enc->stats_out) {
1467 fprintf(ost->logfile, "%s", enc->stats_out);
1476 pkt.data = bit_buffer;
1478 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1479 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1480 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1485 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1486 static int output_packet(InputStream *ist, int ist_index,
1487 OutputStream *ost_table, int nb_ostreams,
1488 const AVPacket *pkt)
1490 AVFormatContext *os;
1495 void *buffer_to_free = NULL;
1496 static unsigned int samples_size= 0;
1497 AVSubtitle subtitle, *subtitle_to_free;
1498 int64_t pkt_pts = AV_NOPTS_VALUE;
1500 int frame_available;
1505 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1507 if(ist->next_pts == AV_NOPTS_VALUE)
1508 ist->next_pts= ist->pts;
1512 av_init_packet(&avpkt);
1520 if(pkt->dts != AV_NOPTS_VALUE)
1521 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1522 if(pkt->pts != AV_NOPTS_VALUE)
1523 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1525 //while we have more to decode or while the decoder did output something on EOF
1526 while (avpkt.size > 0 || (!pkt && got_output)) {
1527 uint8_t *data_buf, *decoded_data_buf;
1528 int data_size, decoded_data_size;
1530 ist->pts= ist->next_pts;
1532 if(avpkt.size && avpkt.size != pkt->size &&
1533 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1534 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1535 ist->showed_multi_packet_warning=1;
1538 /* decode the packet if needed */
1539 decoded_data_buf = NULL; /* fail safe */
1540 decoded_data_size= 0;
1541 data_buf = avpkt.data;
1542 data_size = avpkt.size;
1543 subtitle_to_free = NULL;
1544 if (ist->decoding_needed) {
1545 switch(ist->st->codec->codec_type) {
1546 case AVMEDIA_TYPE_AUDIO:{
1547 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1548 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1550 samples= av_malloc(samples_size);
1552 decoded_data_size= samples_size;
1553 /* XXX: could avoid copy if PCM 16 bits with same
1554 endianness as CPU */
1555 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1562 got_output = decoded_data_size > 0;
1563 /* Some bug in mpeg audio decoder gives */
1564 /* decoded_data_size < 0, it seems they are overflows */
1566 /* no audio frame */
1569 decoded_data_buf = (uint8_t *)samples;
1570 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1571 (ist->st->codec->sample_rate * ist->st->codec->channels);
1573 case AVMEDIA_TYPE_VIDEO:
1574 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1575 /* XXX: allocate picture correctly */
1576 avcodec_get_frame_defaults(&picture);
1577 avpkt.pts = pkt_pts;
1578 avpkt.dts = ist->pts;
1579 pkt_pts = AV_NOPTS_VALUE;
1581 ret = avcodec_decode_video2(ist->st->codec,
1582 &picture, &got_output, &avpkt);
1583 quality = same_quant ? picture.quality : 0;
1587 /* no picture yet */
1588 goto discard_packet;
1590 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1591 if (ist->st->codec->time_base.num != 0) {
1592 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1593 ist->next_pts += ((int64_t)AV_TIME_BASE *
1594 ist->st->codec->time_base.num * ticks) /
1595 ist->st->codec->time_base.den;
1598 buffer_to_free = NULL;
1599 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1601 case AVMEDIA_TYPE_SUBTITLE:
1602 ret = avcodec_decode_subtitle2(ist->st->codec,
1603 &subtitle, &got_output, &avpkt);
1607 goto discard_packet;
1609 subtitle_to_free = &subtitle;
1616 switch(ist->st->codec->codec_type) {
1617 case AVMEDIA_TYPE_AUDIO:
1618 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1619 ist->st->codec->sample_rate;
1621 case AVMEDIA_TYPE_VIDEO:
1622 if (ist->st->codec->time_base.num != 0) {
1623 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1624 ist->next_pts += ((int64_t)AV_TIME_BASE *
1625 ist->st->codec->time_base.num * ticks) /
1626 ist->st->codec->time_base.den;
1634 // preprocess audio (volume)
1635 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1636 if (audio_volume != 256) {
1639 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1640 int v = ((*volp) * audio_volume + 128) >> 8;
1641 if (v < -32768) v = -32768;
1642 if (v > 32767) v = 32767;
1648 /* frame rate emulation */
1650 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1651 int64_t now = av_gettime() - ist->start;
1655 /* if output time reached then transcode raw format,
1656 encode packets and output them */
1657 for (i = 0; i < nb_ostreams; i++) {
1658 OutputFile *of = &output_files[ost_table[i].file_index];
1661 ost = &ost_table[i];
1662 if (ost->source_index != ist_index)
1665 if (of->start_time && ist->pts < of->start_time)
1668 if (of->recording_time != INT64_MAX &&
1669 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1670 (AVRational){1, 1000000}) >= 0) {
1671 ost->is_past_recording_time = 1;
1676 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1677 ost->input_video_filter) {
1679 if (ist->st->sample_aspect_ratio.num)
1680 sar = ist->st->sample_aspect_ratio;
1682 sar = ist->st->codec->sample_aspect_ratio;
1683 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, ist->pts, sar);
1685 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1686 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1687 while (frame_available) {
1688 AVRational ist_pts_tb;
1689 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1690 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1692 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1694 os = output_files[ost->file_index].ctx;
1696 /* set the input output pts pairs */
1697 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1699 if (ost->encoding_needed) {
1700 av_assert0(ist->decoding_needed);
1701 switch(ost->st->codec->codec_type) {
1702 case AVMEDIA_TYPE_AUDIO:
1703 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1705 case AVMEDIA_TYPE_VIDEO:
1707 if (ost->picref->video && !ost->frame_aspect_ratio)
1708 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1710 do_video_out(os, ost, ist, &picture, &frame_size,
1711 same_quant ? quality : ost->st->codec->global_quality);
1712 if (vstats_filename && frame_size)
1713 do_video_stats(os, ost, frame_size);
1715 case AVMEDIA_TYPE_SUBTITLE:
1716 do_subtitle_out(os, ost, ist, &subtitle,
1723 AVFrame avframe; //FIXME/XXX remove this
1725 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1727 av_init_packet(&opkt);
1729 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1730 #if !CONFIG_AVFILTER
1736 /* no reencoding needed : output the packet directly */
1737 /* force the input stream PTS */
1739 avcodec_get_frame_defaults(&avframe);
1740 ost->st->codec->coded_frame= &avframe;
1741 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1743 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1744 audio_size += data_size;
1745 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1746 video_size += data_size;
1750 opkt.stream_index= ost->index;
1751 if(pkt->pts != AV_NOPTS_VALUE)
1752 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1754 opkt.pts= AV_NOPTS_VALUE;
1756 if (pkt->dts == AV_NOPTS_VALUE)
1757 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1759 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1760 opkt.dts -= ost_tb_start_time;
1762 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1763 opkt.flags= pkt->flags;
1765 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1766 if( ost->st->codec->codec_id != CODEC_ID_H264
1767 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1768 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1770 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1771 opkt.destruct= av_destruct_packet;
1773 opkt.data = data_buf;
1774 opkt.size = data_size;
1777 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1778 ost->st->codec->frame_number++;
1779 ost->frame_number++;
1780 av_free_packet(&opkt);
1784 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1785 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1787 avfilter_unref_buffer(ost->picref);
1792 av_free(buffer_to_free);
1793 /* XXX: allocate the subtitles in the codec ? */
1794 if (subtitle_to_free) {
1795 avsubtitle_free(subtitle_to_free);
1796 subtitle_to_free = NULL;
1804 static void print_sdp(OutputFile *output_files, int n)
1808 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1812 for (i = 0; i < n; i++)
1813 avc[i] = output_files[i].ctx;
1815 av_sdp_create(avc, n, sdp, sizeof(sdp));
1816 printf("SDP:\n%s\n", sdp);
1821 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1822 char *error, int error_len)
1825 InputStream *ist = &input_streams[ist_index];
1826 if (ist->decoding_needed) {
1827 AVCodec *codec = ist->dec;
1829 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1831 snprintf(error, sizeof(error), "Decoder (codec id %d) not found for input stream #%d.%d",
1832 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1833 return AVERROR(EINVAL);
1836 /* update requested sample format for the decoder based on the
1837 corresponding encoder sample format */
1838 for (i = 0; i < nb_output_streams; i++) {
1839 OutputStream *ost = &output_streams[i];
1840 if (ost->source_index == ist_index) {
1841 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1846 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1847 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
1848 ist->file_index, ist->st->index);
1849 return AVERROR(EINVAL);
1851 assert_codec_experimental(ist->st->codec, 0);
1852 assert_avoptions(ist->opts);
1855 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;
1856 ist->next_pts = AV_NOPTS_VALUE;
1857 init_pts_correction(&ist->pts_ctx);
1864 * The following code is the main loop of the file converter
1866 static int transcode(OutputFile *output_files,
1867 int nb_output_files,
1868 InputFile *input_files,
1872 AVFormatContext *is, *os;
1873 AVCodecContext *codec, *icodec;
1879 int no_packet_count=0;
1880 int64_t timer_start;
1882 if (!(no_packet = av_mallocz(nb_input_files)))
1886 for (i = 0; i < nb_input_streams; i++)
1887 input_streams[i].start = av_gettime();
1889 /* output stream init */
1890 for(i=0;i<nb_output_files;i++) {
1891 os = output_files[i].ctx;
1892 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1893 av_dump_format(os, i, os->filename, 1);
1894 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1895 ret = AVERROR(EINVAL);
1900 /* for each output stream, we compute the right encoding parameters */
1901 for (i = 0; i < nb_output_streams; i++) {
1902 ost = &output_streams[i];
1903 os = output_files[ost->file_index].ctx;
1904 ist = &input_streams[ost->source_index];
1906 codec = ost->st->codec;
1907 icodec = ist->st->codec;
1909 ost->st->disposition = ist->st->disposition;
1910 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1911 codec->chroma_sample_location = icodec->chroma_sample_location;
1913 if (ost->st->stream_copy) {
1914 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1916 if (extra_size > INT_MAX) {
1917 ret = AVERROR(EINVAL);
1921 /* if stream_copy is selected, no need to decode or encode */
1922 codec->codec_id = icodec->codec_id;
1923 codec->codec_type = icodec->codec_type;
1925 if(!codec->codec_tag){
1926 if( !os->oformat->codec_tag
1927 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1928 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1929 codec->codec_tag = icodec->codec_tag;
1932 codec->bit_rate = icodec->bit_rate;
1933 codec->rc_max_rate = icodec->rc_max_rate;
1934 codec->rc_buffer_size = icodec->rc_buffer_size;
1935 codec->extradata= av_mallocz(extra_size);
1936 if (!codec->extradata) {
1937 ret = AVERROR(ENOMEM);
1940 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1941 codec->extradata_size= icodec->extradata_size;
1942 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){
1943 codec->time_base = icodec->time_base;
1944 codec->time_base.num *= icodec->ticks_per_frame;
1945 av_reduce(&codec->time_base.num, &codec->time_base.den,
1946 codec->time_base.num, codec->time_base.den, INT_MAX);
1948 codec->time_base = ist->st->time_base;
1949 switch(codec->codec_type) {
1950 case AVMEDIA_TYPE_AUDIO:
1951 if(audio_volume != 256) {
1952 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1955 codec->channel_layout = icodec->channel_layout;
1956 codec->sample_rate = icodec->sample_rate;
1957 codec->channels = icodec->channels;
1958 codec->frame_size = icodec->frame_size;
1959 codec->audio_service_type = icodec->audio_service_type;
1960 codec->block_align= icodec->block_align;
1961 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1962 codec->block_align= 0;
1963 if(codec->codec_id == CODEC_ID_AC3)
1964 codec->block_align= 0;
1966 case AVMEDIA_TYPE_VIDEO:
1967 codec->pix_fmt = icodec->pix_fmt;
1968 codec->width = icodec->width;
1969 codec->height = icodec->height;
1970 codec->has_b_frames = icodec->has_b_frames;
1971 if (!codec->sample_aspect_ratio.num) {
1972 codec->sample_aspect_ratio =
1973 ost->st->sample_aspect_ratio =
1974 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1975 ist->st->codec->sample_aspect_ratio.num ?
1976 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
1979 case AVMEDIA_TYPE_SUBTITLE:
1980 codec->width = icodec->width;
1981 codec->height = icodec->height;
1983 case AVMEDIA_TYPE_DATA:
1990 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1991 switch(codec->codec_type) {
1992 case AVMEDIA_TYPE_AUDIO:
1993 ost->fifo= av_fifo_alloc(1024);
1995 ret = AVERROR(ENOMEM);
1998 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
1999 if (!codec->sample_rate) {
2000 codec->sample_rate = icodec->sample_rate;
2002 codec->sample_rate >>= icodec->lowres;
2004 choose_sample_rate(ost->st, ost->enc);
2005 codec->time_base = (AVRational){1, codec->sample_rate};
2006 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2007 codec->sample_fmt = icodec->sample_fmt;
2008 choose_sample_fmt(ost->st, ost->enc);
2009 if (!codec->channels)
2010 codec->channels = icodec->channels;
2011 codec->channel_layout = icodec->channel_layout;
2012 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2013 codec->channel_layout = 0;
2014 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2015 icodec->request_channels = codec->channels;
2016 ist->decoding_needed = 1;
2017 ost->encoding_needed = 1;
2018 ost->resample_sample_fmt = icodec->sample_fmt;
2019 ost->resample_sample_rate = icodec->sample_rate;
2020 ost->resample_channels = icodec->channels;
2022 case AVMEDIA_TYPE_VIDEO:
2023 if (codec->pix_fmt == PIX_FMT_NONE)
2024 codec->pix_fmt = icodec->pix_fmt;
2025 choose_pixel_fmt(ost->st, ost->enc);
2027 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2028 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2032 if (!codec->width || !codec->height) {
2033 codec->width = icodec->width;
2034 codec->height = icodec->height;
2037 ost->video_resample = codec->width != icodec->width ||
2038 codec->height != icodec->height ||
2039 codec->pix_fmt != icodec->pix_fmt;
2040 if (ost->video_resample) {
2041 #if !CONFIG_AVFILTER
2042 avcodec_get_frame_defaults(&ost->pict_tmp);
2043 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2044 codec->width, codec->height)) {
2045 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2048 ost->img_resample_ctx = sws_getContext(
2055 ost->sws_flags, NULL, NULL, NULL);
2056 if (ost->img_resample_ctx == NULL) {
2057 fprintf(stderr, "Cannot get resampling context\n");
2061 codec->bits_per_raw_sample= 0;
2064 ost->resample_height = icodec->height;
2065 ost->resample_width = icodec->width;
2066 ost->resample_pix_fmt= icodec->pix_fmt;
2067 ost->encoding_needed = 1;
2068 ist->decoding_needed = 1;
2070 if (!ost->frame_rate.num)
2071 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2072 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2073 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2074 ost->frame_rate = ost->enc->supported_framerates[idx];
2076 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2079 if (configure_video_filters(ist, ost)) {
2080 fprintf(stderr, "Error opening filters!\n");
2085 case AVMEDIA_TYPE_SUBTITLE:
2086 ost->encoding_needed = 1;
2087 ist->decoding_needed = 1;
2094 if (ost->encoding_needed &&
2095 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2096 char logfilename[1024];
2099 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2100 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2102 if (codec->flags & CODEC_FLAG_PASS1) {
2103 f = fopen(logfilename, "wb");
2105 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2111 size_t logbuffer_size;
2112 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2113 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2116 codec->stats_in = logbuffer;
2120 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2121 int size= codec->width * codec->height;
2122 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2127 bit_buffer = av_malloc(bit_buffer_size);
2129 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2131 ret = AVERROR(ENOMEM);
2135 /* open each encoder */
2136 for (i = 0; i < nb_output_streams; i++) {
2137 ost = &output_streams[i];
2138 if (ost->encoding_needed) {
2139 AVCodec *codec = ost->enc;
2140 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2142 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2143 ost->st->codec->codec_id, ost->file_index, ost->index);
2144 ret = AVERROR(EINVAL);
2147 if (dec->subtitle_header) {
2148 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2149 if (!ost->st->codec->subtitle_header) {
2150 ret = AVERROR(ENOMEM);
2153 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2154 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2156 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2157 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2158 ost->file_index, ost->index);
2159 ret = AVERROR(EINVAL);
2162 assert_codec_experimental(ost->st->codec, 1);
2163 assert_avoptions(ost->opts);
2164 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2165 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2166 "It takes bits/s as argument, not kbits/s\n");
2167 extra_size += ost->st->codec->extradata_size;
2171 /* init input streams */
2172 for (i = 0; i < nb_input_streams; i++)
2173 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error)) < 0))
2176 /* open files and write file headers */
2177 for (i = 0; i < nb_output_files; i++) {
2178 os = output_files[i].ctx;
2179 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2180 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2181 ret = AVERROR(EINVAL);
2184 assert_avoptions(output_files[i].opts);
2185 if (strcmp(os->oformat->name, "rtp")) {
2191 /* dump the file output parameters - cannot be done before in case
2193 for(i=0;i<nb_output_files;i++) {
2194 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2197 /* dump the stream mapping */
2199 fprintf(stderr, "Stream mapping:\n");
2200 for (i = 0; i < nb_output_streams;i ++) {
2201 ost = &output_streams[i];
2202 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2203 input_streams[ost->source_index].file_index,
2204 input_streams[ost->source_index].st->index,
2207 if (ost->sync_ist != &input_streams[ost->source_index])
2208 fprintf(stderr, " [sync #%d.%d]",
2209 ost->sync_ist->file_index,
2210 ost->sync_ist->st->index);
2211 if (ost->st->stream_copy)
2212 fprintf(stderr, " (copy)");
2213 fprintf(stderr, "\n");
2218 fprintf(stderr, "%s\n", error);
2223 print_sdp(output_files, nb_output_files);
2227 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2230 timer_start = av_gettime();
2232 for(; received_sigterm == 0;) {
2233 int file_index, ist_index;
2239 ipts_min = INT64_MAX;
2242 /* select the stream that we must read now by looking at the
2243 smallest output pts */
2245 for (i = 0; i < nb_output_streams; i++) {
2249 ost = &output_streams[i];
2250 of = &output_files[ost->file_index];
2251 os = output_files[ost->file_index].ctx;
2252 ist = &input_streams[ost->source_index];
2253 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2254 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2256 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2258 if (!input_files[ist->file_index].eof_reached){
2259 if(ipts < ipts_min) {
2261 if(input_sync ) file_index = ist->file_index;
2263 if(opts < opts_min) {
2265 if(!input_sync) file_index = ist->file_index;
2268 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2273 /* if none, if is finished */
2274 if (file_index < 0) {
2275 if(no_packet_count){
2277 memset(no_packet, 0, nb_input_files);
2284 /* read a frame from it and output it in the fifo */
2285 is = input_files[file_index].ctx;
2286 ret= av_read_frame(is, &pkt);
2287 if(ret == AVERROR(EAGAIN)){
2288 no_packet[file_index]=1;
2293 input_files[file_index].eof_reached = 1;
2301 memset(no_packet, 0, nb_input_files);
2304 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2305 is->streams[pkt.stream_index]);
2307 /* the following test is needed in case new streams appear
2308 dynamically in stream : we ignore them */
2309 if (pkt.stream_index >= input_files[file_index].ctx->nb_streams)
2310 goto discard_packet;
2311 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2312 ist = &input_streams[ist_index];
2314 goto discard_packet;
2316 if (pkt.dts != AV_NOPTS_VALUE)
2317 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2318 if (pkt.pts != AV_NOPTS_VALUE)
2319 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2321 if (ist->ts_scale) {
2322 if(pkt.pts != AV_NOPTS_VALUE)
2323 pkt.pts *= ist->ts_scale;
2324 if(pkt.dts != AV_NOPTS_VALUE)
2325 pkt.dts *= ist->ts_scale;
2328 // 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);
2329 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2330 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2331 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2332 int64_t delta= pkt_dts - ist->next_pts;
2333 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2334 input_files[ist->file_index].ts_offset -= delta;
2336 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2337 delta, input_files[ist->file_index].ts_offset);
2338 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2339 if(pkt.pts != AV_NOPTS_VALUE)
2340 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2344 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2345 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2348 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2349 ist->file_index, ist->st->index);
2352 av_free_packet(&pkt);
2357 av_free_packet(&pkt);
2359 /* dump report by using the output first video and audio streams */
2360 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2363 /* at the end of stream, we must flush the decoder buffers */
2364 for (i = 0; i < nb_input_streams; i++) {
2365 ist = &input_streams[i];
2366 if (ist->decoding_needed) {
2367 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2370 flush_encoders(output_streams, nb_output_streams);
2374 /* write the trailer if needed and close file */
2375 for(i=0;i<nb_output_files;i++) {
2376 os = output_files[i].ctx;
2377 av_write_trailer(os);
2380 /* dump report by using the first video and audio streams */
2381 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2383 /* close each encoder */
2384 for (i = 0; i < nb_output_streams; i++) {
2385 ost = &output_streams[i];
2386 if (ost->encoding_needed) {
2387 av_freep(&ost->st->codec->stats_in);
2388 avcodec_close(ost->st->codec);
2391 avfilter_graph_free(&ost->graph);
2395 /* close each decoder */
2396 for (i = 0; i < nb_input_streams; i++) {
2397 ist = &input_streams[i];
2398 if (ist->decoding_needed) {
2399 avcodec_close(ist->st->codec);
2407 av_freep(&bit_buffer);
2408 av_freep(&no_packet);
2410 if (output_streams) {
2411 for (i = 0; i < nb_output_streams; i++) {
2412 ost = &output_streams[i];
2414 if (ost->st->stream_copy)
2415 av_freep(&ost->st->codec->extradata);
2417 fclose(ost->logfile);
2418 ost->logfile = NULL;
2420 av_fifo_free(ost->fifo); /* works even if fifo is not
2421 initialized but set to zero */
2422 av_freep(&ost->st->codec->subtitle_header);
2423 av_free(ost->pict_tmp.data[0]);
2424 av_free(ost->forced_kf_pts);
2425 if (ost->video_resample)
2426 sws_freeContext(ost->img_resample_ctx);
2428 audio_resample_close(ost->resample);
2429 if (ost->reformat_ctx)
2430 av_audio_convert_free(ost->reformat_ctx);
2431 av_dict_free(&ost->opts);
2438 static int opt_format(const char *opt, const char *arg)
2440 last_asked_format = arg;
2444 static int opt_video_rc_override_string(const char *opt, const char *arg)
2446 video_rc_override_string = arg;
2450 static int opt_me_threshold(const char *opt, const char *arg)
2452 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2456 static int opt_verbose(const char *opt, const char *arg)
2458 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2462 static int opt_frame_rate(const char *opt, const char *arg)
2464 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2465 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2471 static int opt_frame_crop(const char *opt, const char *arg)
2473 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2474 return AVERROR(EINVAL);
2477 static int opt_frame_size(const char *opt, const char *arg)
2479 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2480 fprintf(stderr, "Incorrect frame size\n");
2481 return AVERROR(EINVAL);
2486 static int opt_pad(const char *opt, const char *arg) {
2487 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2491 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2493 if (strcmp(arg, "list")) {
2494 frame_pix_fmt = av_get_pix_fmt(arg);
2495 if (frame_pix_fmt == PIX_FMT_NONE) {
2496 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2497 return AVERROR(EINVAL);
2506 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2513 p = strchr(arg, ':');
2515 x = strtol(arg, &end, 10);
2517 y = strtol(end+1, &end, 10);
2519 ar = (double)x / (double)y;
2521 ar = strtod(arg, NULL);
2524 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2525 return AVERROR(EINVAL);
2527 frame_aspect_ratio = ar;
2531 static int opt_metadata(const char *opt, const char *arg)
2533 char *mid= strchr(arg, '=');
2536 fprintf(stderr, "Missing =\n");
2541 av_dict_set(&metadata, arg, mid, 0);
2546 static int opt_qscale(const char *opt, const char *arg)
2548 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2549 if (video_qscale == 0) {
2550 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2551 return AVERROR(EINVAL);
2556 static int opt_top_field_first(const char *opt, const char *arg)
2558 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2562 static int opt_thread_count(const char *opt, const char *arg)
2564 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2567 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2572 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2574 if (strcmp(arg, "list")) {
2575 audio_sample_fmt = av_get_sample_fmt(arg);
2576 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2577 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2578 return AVERROR(EINVAL);
2583 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2584 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2590 static int opt_audio_rate(const char *opt, const char *arg)
2592 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2596 static int opt_audio_channels(const char *opt, const char *arg)
2598 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2602 static int opt_codec(const char *opt, const char *arg)
2604 return av_dict_set(&codec_names, opt, arg, 0);
2607 static int opt_audio_codec(const char *opt, const char *arg)
2609 return opt_codec("codec:a", arg);
2612 static int opt_video_codec(const char *opt, const char *arg)
2614 return opt_codec("codec:v", arg);
2617 static int opt_subtitle_codec(const char *opt, const char *arg)
2619 return opt_codec("codec:s", arg);
2622 static int opt_data_codec(const char *opt, const char *arg)
2624 return opt_codec("codec:d", arg);
2627 static int opt_codec_tag(const char *opt, const char *arg)
2630 uint32_t *codec_tag;
2632 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2633 !strcmp(opt, "vtag") ? &video_codec_tag :
2634 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2638 *codec_tag = strtol(arg, &tail, 0);
2640 *codec_tag = AV_RL32(arg);
2645 static int opt_map(const char *opt, const char *arg)
2647 StreamMap *m = NULL;
2648 int i, negative = 0, file_idx;
2649 int sync_file_idx = -1, sync_stream_idx;
2657 map = av_strdup(arg);
2659 /* parse sync stream first, just pick first matching stream */
2660 if (sync = strchr(map, ',')) {
2662 sync_file_idx = strtol(sync + 1, &sync, 0);
2663 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2664 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2669 for (i = 0; i < input_files[sync_file_idx].ctx->nb_streams; i++)
2670 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2671 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2672 sync_stream_idx = i;
2675 if (i == input_files[sync_file_idx].ctx->nb_streams) {
2676 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2677 "match any streams.\n", arg);
2683 file_idx = strtol(map, &p, 0);
2684 if (file_idx >= nb_input_files || file_idx < 0) {
2685 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2689 /* disable some already defined maps */
2690 for (i = 0; i < nb_stream_maps; i++) {
2691 m = &stream_maps[i];
2692 if (check_stream_specifier(input_files[m->file_index].ctx,
2693 input_files[m->file_index].ctx->streams[m->stream_index],
2694 *p == ':' ? p + 1 : p) > 0)
2698 for (i = 0; i < input_files[file_idx].ctx->nb_streams; i++) {
2699 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2700 *p == ':' ? p + 1 : p) <= 0)
2702 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2703 m = &stream_maps[nb_stream_maps - 1];
2705 m->file_index = file_idx;
2706 m->stream_index = i;
2708 if (sync_file_idx >= 0) {
2709 m->sync_file_index = sync_file_idx;
2710 m->sync_stream_index = sync_stream_idx;
2712 m->sync_file_index = file_idx;
2713 m->sync_stream_index = i;
2718 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2726 static void parse_meta_type(char *arg, char *type, int *index)
2736 if (*(++arg) == ':')
2737 *index = strtol(++arg, NULL, 0);
2740 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2747 static int opt_map_metadata(const char *opt, const char *arg)
2749 MetadataMap *m, *m1;
2752 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2753 &nb_meta_data_maps, nb_meta_data_maps + 1);
2755 m = &meta_data_maps[nb_meta_data_maps - 1][1];
2756 m->file = strtol(arg, &p, 0);
2757 parse_meta_type(p, &m->type, &m->index);
2759 m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2760 if (p = strchr(opt, ':'))
2761 parse_meta_type(p, &m1->type, &m1->index);
2765 if (m->type == 'g' || m1->type == 'g')
2766 metadata_global_autocopy = 0;
2767 if (m->type == 's' || m1->type == 's')
2768 metadata_streams_autocopy = 0;
2769 if (m->type == 'c' || m1->type == 'c')
2770 metadata_chapters_autocopy = 0;
2775 static int opt_input_ts_scale(const char *opt, const char *arg)
2777 return av_dict_set(&ts_scale, opt, arg, 0);
2780 static int opt_recording_time(const char *opt, const char *arg)
2782 recording_time = parse_time_or_die(opt, arg, 1);
2786 static int opt_start_time(const char *opt, const char *arg)
2788 start_time = parse_time_or_die(opt, arg, 1);
2792 static int opt_input_ts_offset(const char *opt, const char *arg)
2794 input_ts_offset = parse_time_or_die(opt, arg, 1);
2798 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2800 const char *codec_string = encoder ? "encoder" : "decoder";
2804 return CODEC_ID_NONE;
2806 avcodec_find_encoder_by_name(name) :
2807 avcodec_find_decoder_by_name(name);
2809 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2812 if(codec->type != type) {
2813 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2819 static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
2821 AVDictionaryEntry *e = NULL;
2822 char *codec_name = NULL;
2825 while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
2826 char *p = strchr(e->key, ':');
2828 if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
2829 codec_name = e->value;
2836 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2837 return avcodec_find_encoder(st->codec->codec_id);
2839 } else if (!strcmp(codec_name, "copy"))
2840 st->stream_copy = 1;
2842 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2843 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2844 avcodec_find_decoder_by_name(codec_name);
2851 * Add all the streams from the given input file to the global
2852 * list of input streams.
2854 static void add_input_streams(AVFormatContext *ic)
2856 int i, rfps, rfps_base, ret;
2858 for (i = 0; i < ic->nb_streams; i++) {
2859 AVStream *st = ic->streams[i];
2860 AVCodecContext *dec = st->codec;
2861 AVDictionaryEntry *e = NULL;
2865 dec->thread_count = thread_count;
2867 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2868 ist = &input_streams[nb_input_streams - 1];
2870 ist->file_index = nb_input_files;
2872 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2874 while (e = av_dict_get(ts_scale, "", e, AV_DICT_IGNORE_SUFFIX)) {
2875 char *p = strchr(e->key, ':');
2877 if ((ret = check_stream_specifier(ic, st, p ? p + 1 : "")) > 0)
2883 ist->ts_scale = strtod(scale, NULL);
2885 ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
2887 switch (dec->codec_type) {
2888 case AVMEDIA_TYPE_AUDIO:
2890 st->discard= AVDISCARD_ALL;
2892 case AVMEDIA_TYPE_VIDEO:
2893 rfps = ic->streams[i]->r_frame_rate.num;
2894 rfps_base = ic->streams[i]->r_frame_rate.den;
2896 dec->flags |= CODEC_FLAG_EMU_EDGE;
2897 dec->height >>= dec->lowres;
2898 dec->width >>= dec->lowres;
2901 dec->debug |= FF_DEBUG_MV;
2903 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2906 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2907 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2909 (float)rfps / rfps_base, rfps, rfps_base);
2913 st->discard= AVDISCARD_ALL;
2914 else if(video_discard)
2915 st->discard= video_discard;
2917 case AVMEDIA_TYPE_DATA:
2919 case AVMEDIA_TYPE_SUBTITLE:
2920 if(subtitle_disable)
2921 st->discard = AVDISCARD_ALL;
2923 case AVMEDIA_TYPE_ATTACHMENT:
2924 case AVMEDIA_TYPE_UNKNOWN:
2932 static int opt_input_file(const char *opt, const char *filename)
2934 AVFormatContext *ic;
2935 AVInputFormat *file_iformat = NULL;
2939 AVDictionary **opts;
2940 int orig_nb_streams; // number of streams before avformat_find_stream_info
2942 if (last_asked_format) {
2943 if (!(file_iformat = av_find_input_format(last_asked_format))) {
2944 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2947 last_asked_format = NULL;
2950 if (!strcmp(filename, "-"))
2953 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2954 !strcmp(filename, "/dev/stdin");
2956 /* get default parameters from command line */
2957 ic = avformat_alloc_context();
2959 print_error(filename, AVERROR(ENOMEM));
2962 if (audio_sample_rate) {
2963 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
2964 av_dict_set(&format_opts, "sample_rate", buf, 0);
2966 if (audio_channels) {
2967 snprintf(buf, sizeof(buf), "%d", audio_channels);
2968 av_dict_set(&format_opts, "channels", buf, 0);
2970 if (frame_rate.num) {
2971 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
2972 av_dict_set(&format_opts, "framerate", buf, 0);
2974 if (frame_width && frame_height) {
2975 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
2976 av_dict_set(&format_opts, "video_size", buf, 0);
2978 if (frame_pix_fmt != PIX_FMT_NONE)
2979 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
2981 ic->flags |= AVFMT_FLAG_NONBLOCK;
2983 /* open the input file with generic libav function */
2984 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2986 print_error(filename, err);
2989 assert_avoptions(format_opts);
2994 for(i=0; i<ic->nb_streams; i++){
2995 ic->streams[i]->discard= AVDISCARD_ALL;
2997 for(i=0; i<ic->nb_programs; i++){
2998 AVProgram *p= ic->programs[i];
2999 if(p->id != opt_programid){
3000 p->discard = AVDISCARD_ALL;
3003 for(j=0; j<p->nb_stream_indexes; j++){
3004 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3009 fprintf(stderr, "Specified program id not found\n");
3015 /* apply forced codec ids */
3016 for (i = 0; i < ic->nb_streams; i++)
3017 choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
3019 /* Set AVCodecContext options for avformat_find_stream_info */
3020 opts = setup_find_stream_info_opts(ic, codec_opts);
3021 orig_nb_streams = ic->nb_streams;
3023 /* If not enough info to get the stream parameters, we decode the
3024 first frames to get it. (used in mpeg case for example) */
3025 ret = avformat_find_stream_info(ic, opts);
3026 if (ret < 0 && verbose >= 0) {
3027 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3028 av_close_input_file(ic);
3032 timestamp = start_time;
3033 /* add the stream start time */
3034 if (ic->start_time != AV_NOPTS_VALUE)
3035 timestamp += ic->start_time;
3037 /* if seeking requested, we execute it */
3038 if (start_time != 0) {
3039 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3041 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3042 filename, (double)timestamp / AV_TIME_BASE);
3044 /* reset seek info */
3048 /* update the current parameters so that they match the one of the input stream */
3049 add_input_streams(ic);
3051 /* dump the file content */
3053 av_dump_format(ic, nb_input_files, filename, 0);
3055 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3056 input_files[nb_input_files - 1].ctx = ic;
3057 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3058 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3060 frame_rate = (AVRational){0, 0};
3061 frame_pix_fmt = PIX_FMT_NONE;
3064 audio_sample_rate = 0;
3066 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3067 av_dict_free(&ts_scale);
3069 for (i = 0; i < orig_nb_streams; i++)
3070 av_dict_free(&opts[i]);
3072 av_dict_free(&codec_names);
3078 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3079 AVCodecContext *avctx)
3085 for (p = kf; *p; p++)
3088 ost->forced_kf_count = n;
3089 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3090 if (!ost->forced_kf_pts) {
3091 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3094 for (i = 0; i < n; i++) {
3095 p = i ? strchr(p, ',') + 1 : kf;
3096 t = parse_time_or_die("force_key_frames", p, 1);
3097 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3101 static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
3104 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3105 int idx = oc->nb_streams - 1;
3108 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3112 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3113 nb_output_streams + 1);
3114 ost = &output_streams[nb_output_streams - 1];
3115 ost->file_index = nb_output_files;
3118 st->codec->codec_type = type;
3119 ost->enc = choose_codec(oc, st, type, codec_names);
3121 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3124 avcodec_get_context_defaults3(st->codec, ost->enc);
3125 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3127 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3131 static OutputStream *new_video_stream(AVFormatContext *oc)
3135 AVCodecContext *video_enc;
3137 ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
3139 if (!st->stream_copy) {
3140 ost->frame_aspect_ratio = frame_aspect_ratio;
3141 frame_aspect_ratio = 0;
3143 ost->avfilter= vfilters;
3148 ost->bitstream_filters = video_bitstream_filters;
3149 video_bitstream_filters= NULL;
3151 st->codec->thread_count= thread_count;
3153 video_enc = st->codec;
3156 video_enc->codec_tag= video_codec_tag;
3158 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3159 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3162 if (st->stream_copy) {
3163 video_enc->sample_aspect_ratio =
3164 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3170 ost->frame_rate = frame_rate;
3172 video_enc->width = frame_width;
3173 video_enc->height = frame_height;
3174 video_enc->pix_fmt = frame_pix_fmt;
3175 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3177 if (video_qscale || same_quant) {
3178 video_enc->flags |= CODEC_FLAG_QSCALE;
3179 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3183 video_enc->intra_matrix = intra_matrix;
3185 video_enc->inter_matrix = inter_matrix;
3187 p= video_rc_override_string;
3190 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3192 fprintf(stderr, "error parsing rc_override\n");
3195 video_enc->rc_override=
3196 av_realloc(video_enc->rc_override,
3197 sizeof(RcOverride)*(i+1));
3198 video_enc->rc_override[i].start_frame= start;
3199 video_enc->rc_override[i].end_frame = end;
3201 video_enc->rc_override[i].qscale= q;
3202 video_enc->rc_override[i].quality_factor= 1.0;
3205 video_enc->rc_override[i].qscale= 0;
3206 video_enc->rc_override[i].quality_factor= -q/100.0;
3211 video_enc->rc_override_count=i;
3212 if (!video_enc->rc_initial_buffer_occupancy)
3213 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3214 video_enc->me_threshold= me_threshold;
3215 video_enc->intra_dc_precision= intra_dc_precision - 8;
3218 video_enc->flags|= CODEC_FLAG_PSNR;
3223 video_enc->flags |= CODEC_FLAG_PASS1;
3225 video_enc->flags |= CODEC_FLAG_PASS2;
3229 if (forced_key_frames)
3230 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3232 if (video_language) {
3233 av_dict_set(&st->metadata, "language", video_language, 0);
3234 av_freep(&video_language);
3237 /* reset some key parameters */
3239 av_freep(&forced_key_frames);
3240 frame_pix_fmt = PIX_FMT_NONE;
3244 static OutputStream *new_audio_stream(AVFormatContext *oc)
3248 AVCodecContext *audio_enc;
3250 ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
3253 ost->bitstream_filters = audio_bitstream_filters;
3254 audio_bitstream_filters= NULL;
3256 st->codec->thread_count= thread_count;
3258 audio_enc = st->codec;
3259 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3262 audio_enc->codec_tag= audio_codec_tag;
3264 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3265 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3267 if (!st->stream_copy) {
3268 if (audio_qscale > QSCALE_NONE) {
3269 audio_enc->flags |= CODEC_FLAG_QSCALE;
3270 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3273 audio_enc->channels = audio_channels;
3274 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3275 audio_enc->sample_fmt = audio_sample_fmt;
3276 if (audio_sample_rate)
3277 audio_enc->sample_rate = audio_sample_rate;
3279 if (audio_language) {
3280 av_dict_set(&st->metadata, "language", audio_language, 0);
3281 av_freep(&audio_language);
3284 /* reset some key parameters */
3290 static OutputStream *new_data_stream(AVFormatContext *oc)
3294 AVCodecContext *data_enc;
3296 ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
3298 data_enc = st->codec;
3299 if (!st->stream_copy) {
3300 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3305 data_enc->codec_tag= data_codec_tag;
3307 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3308 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3315 static OutputStream *new_subtitle_stream(AVFormatContext *oc)
3319 AVCodecContext *subtitle_enc;
3321 ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
3323 subtitle_enc = st->codec;
3325 ost->bitstream_filters = subtitle_bitstream_filters;
3326 subtitle_bitstream_filters= NULL;
3328 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3330 if(subtitle_codec_tag)
3331 subtitle_enc->codec_tag= subtitle_codec_tag;
3333 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3334 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3337 if (subtitle_language) {
3338 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3339 av_freep(&subtitle_language);
3342 subtitle_disable = 0;
3346 /* arg format is "output-stream-index:streamid-value". */
3347 static int opt_streamid(const char *opt, const char *arg)
3353 av_strlcpy(idx_str, arg, sizeof(idx_str));
3354 p = strchr(idx_str, ':');
3357 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3362 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3363 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3364 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3368 static int copy_chapters(int infile, int outfile)
3370 AVFormatContext *is = input_files[infile].ctx;
3371 AVFormatContext *os = output_files[outfile].ctx;
3374 for (i = 0; i < is->nb_chapters; i++) {
3375 AVChapter *in_ch = is->chapters[i], *out_ch;
3376 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
3377 AV_TIME_BASE_Q, in_ch->time_base);
3378 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
3379 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3382 if (in_ch->end < ts_off)
3384 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3387 out_ch = av_mallocz(sizeof(AVChapter));
3389 return AVERROR(ENOMEM);
3391 out_ch->id = in_ch->id;
3392 out_ch->time_base = in_ch->time_base;
3393 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3394 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3396 if (metadata_chapters_autocopy)
3397 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3400 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3402 return AVERROR(ENOMEM);
3403 os->chapters[os->nb_chapters - 1] = out_ch;
3408 static int read_avserver_streams(AVFormatContext *s, const char *filename)
3411 AVFormatContext *ic = NULL;
3413 err = avformat_open_input(&ic, filename, NULL, NULL);
3416 /* copy stream format */
3417 for(i=0;i<ic->nb_streams;i++) {
3422 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3423 ost = new_output_stream(s, codec->type);
3426 // FIXME: a more elegant solution is needed
3427 memcpy(st, ic->streams[i], sizeof(AVStream));
3429 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3431 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3432 choose_sample_fmt(st, codec);
3433 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3434 choose_pixel_fmt(st, codec);
3437 av_close_input_file(ic);
3441 static void opt_output_file(const char *filename)
3443 AVFormatContext *oc;
3445 AVOutputFormat *file_oformat;
3449 if (!strcmp(filename, "-"))
3452 oc = avformat_alloc_context();
3454 print_error(filename, AVERROR(ENOMEM));
3458 if (last_asked_format) {
3459 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3460 if (!file_oformat) {
3461 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3464 last_asked_format = NULL;
3466 file_oformat = av_guess_format(NULL, filename, NULL);
3467 if (!file_oformat) {
3468 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3474 oc->oformat = file_oformat;
3475 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3477 if (!strcmp(file_oformat->name, "ffm") &&
3478 av_strstart(filename, "http:", NULL)) {
3479 /* special case for files sent to avserver: we get the stream
3480 parameters from avserver */
3481 int err = read_avserver_streams(oc, filename);
3483 print_error(filename, err);
3486 } else if (!nb_stream_maps) {
3487 /* pick the "best" stream of each type */
3488 #define NEW_STREAM(type, index)\
3490 ost = new_ ## type ## _stream(oc);\
3491 ost->source_index = index;\
3492 ost->sync_ist = &input_streams[index];\
3493 input_streams[index].discard = 0;\
3496 /* video: highest resolution */
3497 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3498 int area = 0, idx = -1;
3499 for (i = 0; i < nb_input_streams; i++) {
3500 ist = &input_streams[i];
3501 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3502 ist->st->codec->width * ist->st->codec->height > area) {
3503 area = ist->st->codec->width * ist->st->codec->height;
3507 NEW_STREAM(video, idx);
3510 /* audio: most channels */
3511 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3512 int channels = 0, idx = -1;
3513 for (i = 0; i < nb_input_streams; i++) {
3514 ist = &input_streams[i];
3515 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3516 ist->st->codec->channels > channels) {
3517 channels = ist->st->codec->channels;
3521 NEW_STREAM(audio, idx);
3524 /* subtitles: pick first */
3525 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3526 for (i = 0; i < nb_input_streams; i++)
3527 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3528 NEW_STREAM(subtitle, i);
3532 /* do something with data? */
3534 for (i = 0; i < nb_stream_maps; i++) {
3535 StreamMap *map = &stream_maps[i];
3540 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3541 switch (ist->st->codec->codec_type) {
3542 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(oc); break;
3543 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(oc); break;
3544 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3545 case AVMEDIA_TYPE_DATA: ost = new_data_stream(oc); break;
3547 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3548 map->file_index, map->stream_index);
3552 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3553 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3554 map->sync_stream_index];
3559 av_dict_copy(&oc->metadata, metadata, 0);
3560 av_dict_free(&metadata);
3563 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3564 output_files[nb_output_files - 1].ctx = oc;
3565 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3566 output_files[nb_output_files - 1].recording_time = recording_time;
3567 output_files[nb_output_files - 1].start_time = start_time;
3568 output_files[nb_output_files - 1].limit_filesize = limit_filesize;
3569 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3571 /* check filename in case of an image number is expected */
3572 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3573 if (!av_filename_number_test(oc->filename)) {
3574 print_error(oc->filename, AVERROR(EINVAL));
3579 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3580 /* test if it already exists to avoid loosing precious files */
3581 if (!file_overwrite &&
3582 (strchr(filename, ':') == NULL ||
3583 filename[1] == ':' ||
3584 av_strstart(filename, "file:", NULL))) {
3585 if (avio_check(filename, 0) == 0) {
3587 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3589 if (!read_yesno()) {
3590 fprintf(stderr, "Not overwriting - exiting\n");
3595 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3602 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3603 print_error(filename, err);
3608 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3609 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3610 oc->flags |= AVFMT_FLAG_NONBLOCK;
3613 if (chapters_input_file >= nb_input_files) {
3614 if (chapters_input_file == INT_MAX) {
3615 /* copy chapters from the first input file that has them*/
3616 chapters_input_file = -1;
3617 for (i = 0; i < nb_input_files; i++)
3618 if (input_files[i].ctx->nb_chapters) {
3619 chapters_input_file = i;
3623 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3624 chapters_input_file);
3628 if (chapters_input_file >= 0)
3629 copy_chapters(chapters_input_file, nb_output_files - 1);
3632 for (i = 0; i < nb_meta_data_maps; i++) {
3633 AVFormatContext *files[2];
3634 AVDictionary **meta[2];
3637 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3638 if ((index) < 0 || (index) >= (nb_elems)) {\
3639 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3644 int in_file_index = meta_data_maps[i][1].file;
3645 if (in_file_index < 0)
3647 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3650 files[1] = input_files[in_file_index].ctx;
3652 for (j = 0; j < 2; j++) {
3653 MetadataMap *map = &meta_data_maps[i][j];
3655 switch (map->type) {
3657 meta[j] = &files[j]->metadata;
3660 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3661 meta[j] = &files[j]->streams[map->index]->metadata;
3664 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3665 meta[j] = &files[j]->chapters[map->index]->metadata;
3668 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3669 meta[j] = &files[j]->programs[map->index]->metadata;
3674 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3677 /* copy global metadata by default */
3678 if (metadata_global_autocopy && nb_input_files)
3679 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3680 AV_DICT_DONT_OVERWRITE);
3681 if (metadata_streams_autocopy)
3682 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3683 InputStream *ist = &input_streams[output_streams[i].source_index];
3684 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3687 frame_rate = (AVRational){0, 0};
3690 audio_sample_rate = 0;
3692 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3693 chapters_input_file = INT_MAX;
3694 recording_time = INT64_MAX;
3696 limit_filesize = UINT64_MAX;
3698 av_freep(&meta_data_maps);
3699 nb_meta_data_maps = 0;
3700 metadata_global_autocopy = 1;
3701 metadata_streams_autocopy = 1;
3702 metadata_chapters_autocopy = 1;
3703 av_freep(&stream_maps);
3705 av_freep(&streamid_map);
3706 nb_streamid_map = 0;
3708 av_dict_free(&codec_names);
3710 av_freep(&forced_key_frames);
3715 /* same option as mencoder */
3716 static int opt_pass(const char *opt, const char *arg)
3718 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3722 static int64_t getutime(void)
3725 struct rusage rusage;
3727 getrusage(RUSAGE_SELF, &rusage);
3728 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3729 #elif HAVE_GETPROCESSTIMES
3731 FILETIME c, e, k, u;
3732 proc = GetCurrentProcess();
3733 GetProcessTimes(proc, &c, &e, &k, &u);
3734 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3736 return av_gettime();
3740 static int64_t getmaxrss(void)
3742 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3743 struct rusage rusage;
3744 getrusage(RUSAGE_SELF, &rusage);
3745 return (int64_t)rusage.ru_maxrss * 1024;
3746 #elif HAVE_GETPROCESSMEMORYINFO
3748 PROCESS_MEMORY_COUNTERS memcounters;
3749 proc = GetCurrentProcess();
3750 memcounters.cb = sizeof(memcounters);
3751 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3752 return memcounters.PeakPagefileUsage;
3758 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3761 const char *p = str;
3768 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3775 static void opt_inter_matrix(const char *arg)
3777 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3778 parse_matrix_coeffs(inter_matrix, arg);
3781 static void opt_intra_matrix(const char *arg)
3783 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3784 parse_matrix_coeffs(intra_matrix, arg);
3787 static void show_usage(void)
3789 printf("Hyper fast Audio and Video encoder\n");
3790 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3794 static void show_help(void)
3797 AVOutputFormat *oformat = NULL;
3798 AVInputFormat *iformat = NULL;
3800 av_log_set_callback(log_callback_help);
3802 show_help_options(options, "Main options:\n",
3803 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3804 show_help_options(options, "\nAdvanced options:\n",
3805 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3807 show_help_options(options, "\nVideo options:\n",
3808 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3810 show_help_options(options, "\nAdvanced Video options:\n",
3811 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3812 OPT_VIDEO | OPT_EXPERT);
3813 show_help_options(options, "\nAudio options:\n",
3814 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3816 show_help_options(options, "\nAdvanced Audio options:\n",
3817 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3818 OPT_AUDIO | OPT_EXPERT);
3819 show_help_options(options, "\nSubtitle options:\n",
3820 OPT_SUBTITLE | OPT_GRAB,
3822 show_help_options(options, "\nAudio/Video grab options:\n",
3826 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3829 /* individual codec options */
3831 while ((c = av_codec_next(c))) {
3832 if (c->priv_class) {
3833 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3838 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3841 /* individual muxer options */
3842 while ((oformat = av_oformat_next(oformat))) {
3843 if (oformat->priv_class) {
3844 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3849 /* individual demuxer options */
3850 while ((iformat = av_iformat_next(iformat))) {
3851 if (iformat->priv_class) {
3852 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3857 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3860 static int opt_target(const char *opt, const char *arg)
3862 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3863 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3865 if(!strncmp(arg, "pal-", 4)) {
3868 } else if(!strncmp(arg, "ntsc-", 5)) {
3871 } else if(!strncmp(arg, "film-", 5)) {
3876 /* Calculate FR via float to avoid int overflow */
3877 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3880 } else if((fr == 29970) || (fr == 23976)) {
3883 /* Try to determine PAL/NTSC by peeking in the input files */
3884 if(nb_input_files) {
3886 for (j = 0; j < nb_input_files; j++) {
3887 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
3888 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3889 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3891 fr = c->time_base.den * 1000 / c->time_base.num;
3895 } else if((fr == 29970) || (fr == 23976)) {
3905 if(verbose > 0 && norm != UNKNOWN)
3906 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3909 if(norm == UNKNOWN) {
3910 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3911 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3912 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3916 if(!strcmp(arg, "vcd")) {
3917 opt_codec("c:v", "mpeg1video");
3918 opt_codec("c:a", "mp2");
3919 opt_format("f", "vcd");
3921 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
3922 opt_frame_rate("r", frame_rates[norm]);
3923 opt_default("g", norm == PAL ? "15" : "18");
3925 opt_default("b", "1150000");
3926 opt_default("maxrate", "1150000");
3927 opt_default("minrate", "1150000");
3928 opt_default("bufsize", "327680"); // 40*1024*8;
3930 opt_default("b:a", "224000");
3931 audio_sample_rate = 44100;
3934 opt_default("packetsize", "2324");
3935 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3937 /* We have to offset the PTS, so that it is consistent with the SCR.
3938 SCR starts at 36000, but the first two packs contain only padding
3939 and the first pack from the other stream, respectively, may also have
3940 been written before.
3941 So the real data starts at SCR 36000+3*1200. */
3942 mux_preload= (36000+3*1200) / 90000.0; //0.44
3943 } else if(!strcmp(arg, "svcd")) {
3945 opt_codec("c:v", "mpeg2video");
3946 opt_codec("c:a", "mp2");
3947 opt_format("f", "svcd");
3949 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
3950 opt_frame_rate("r", frame_rates[norm]);
3951 opt_default("g", norm == PAL ? "15" : "18");
3953 opt_default("b", "2040000");
3954 opt_default("maxrate", "2516000");
3955 opt_default("minrate", "0"); //1145000;
3956 opt_default("bufsize", "1835008"); //224*1024*8;
3957 opt_default("flags", "+scan_offset");
3960 opt_default("b:a", "224000");
3961 audio_sample_rate = 44100;
3963 opt_default("packetsize", "2324");
3965 } else if(!strcmp(arg, "dvd")) {
3967 opt_codec("c:v", "mpeg2video");
3968 opt_codec("c:a", "ac3");
3969 opt_format("f", "dvd");
3971 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
3972 opt_frame_rate("r", frame_rates[norm]);
3973 opt_default("g", norm == PAL ? "15" : "18");
3975 opt_default("b", "6000000");
3976 opt_default("maxrate", "9000000");
3977 opt_default("minrate", "0"); //1500000;
3978 opt_default("bufsize", "1835008"); //224*1024*8;
3980 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3981 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3983 opt_default("b:a", "448000");
3984 audio_sample_rate = 48000;
3986 } else if(!strncmp(arg, "dv", 2)) {
3988 opt_format("f", "dv");
3990 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
3991 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3992 norm == PAL ? "yuv420p" : "yuv411p");
3993 opt_frame_rate("r", frame_rates[norm]);
3995 audio_sample_rate = 48000;
3999 fprintf(stderr, "Unknown target: %s\n", arg);
4000 return AVERROR(EINVAL);
4005 static int opt_vstats_file(const char *opt, const char *arg)
4007 av_free (vstats_filename);
4008 vstats_filename=av_strdup (arg);
4012 static int opt_vstats(const char *opt, const char *arg)
4015 time_t today2 = time(NULL);
4016 struct tm *today = localtime(&today2);
4018 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4020 return opt_vstats_file(opt, filename);
4023 static int opt_bsf(const char *opt, const char *arg)
4025 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4026 AVBitStreamFilterContext **bsfp;
4029 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4033 bsfp= *opt == 'v' ? &video_bitstream_filters :
4034 *opt == 'a' ? &audio_bitstream_filters :
4035 &subtitle_bitstream_filters;
4037 bsfp= &(*bsfp)->next;
4044 static const OptionDef options[] = {
4046 #include "cmdutils_common_opts.h"
4047 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4048 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4049 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4050 { "c", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4051 { "codec", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4052 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4053 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4054 "outfile[,metadata]:infile[,metadata]" },
4055 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file}, "set chapters mapping", "input_file_index" },
4056 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4057 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4058 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4059 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4060 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "scale" },
4061 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4062 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4063 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4064 "add timings for benchmarking" },
4065 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4066 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4067 "dump each input packet" },
4068 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4069 "when dumping packets, also dump the payload" },
4070 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4071 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4072 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4073 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4074 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4075 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4076 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4077 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4078 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4079 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4080 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4081 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4082 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4083 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4086 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4087 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4088 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4089 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4090 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
4091 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4092 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4093 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4094 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4095 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4096 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4097 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4098 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4099 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4100 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4101 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4102 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4103 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4104 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4105 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold", "threshold" },
4106 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4107 "use same quantizer as source (implies VBR)" },
4108 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4109 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4110 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4111 "deinterlace pictures" },
4112 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4113 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4114 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4116 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4118 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4119 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4120 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4121 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4122 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4123 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4124 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4125 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4126 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4127 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4130 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4131 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4132 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4133 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4134 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4135 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4136 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4137 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4138 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4139 { "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" },
4141 /* subtitle options */
4142 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4143 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4144 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4145 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4148 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4151 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4152 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4154 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4155 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4156 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4158 /* data codec support */
4159 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4161 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4165 int main(int argc, char **argv)
4169 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4171 avcodec_register_all();
4173 avdevice_register_all();
4176 avfilter_register_all();
4180 avio_set_interrupt_cb(decode_interrupt_cb);
4187 parse_options(argc, argv, options, opt_output_file);
4189 if(nb_output_files <= 0 && nb_input_files == 0) {
4191 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4195 /* file converter / grab */
4196 if (nb_output_files <= 0) {
4197 fprintf(stderr, "At least one output file must be specified\n");
4201 if (nb_input_files == 0) {
4202 fprintf(stderr, "At least one input file must be specified\n");
4207 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4209 ti = getutime() - ti;
4211 int maxrss = getmaxrss() / 1024;
4212 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4215 return exit_program(0);