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 AVDictionary *codec_names;
105 /* first item specifies output metadata, second is input */
106 static MetadataMap (*meta_data_maps)[2] = NULL;
107 static int nb_meta_data_maps;
108 static int metadata_global_autocopy = 1;
109 static int metadata_streams_autocopy = 1;
110 static int metadata_chapters_autocopy = 1;
112 static int chapters_input_file = INT_MAX;
114 /* indexed by output file stream index */
115 static int *streamid_map = NULL;
116 static int nb_streamid_map = 0;
118 static int frame_width = 0;
119 static int frame_height = 0;
120 static float frame_aspect_ratio = 0;
121 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
122 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
123 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
124 static AVRational frame_rate;
125 static float video_qscale = 0;
126 static uint16_t *intra_matrix = NULL;
127 static uint16_t *inter_matrix = NULL;
128 static const char *video_rc_override_string=NULL;
129 static int video_disable = 0;
130 static int video_discard = 0;
131 static unsigned int video_codec_tag = 0;
132 static char *video_language = NULL;
133 static int same_quant = 0;
134 static int do_deinterlace = 0;
135 static int top_field_first = -1;
136 static int me_threshold = 0;
137 static int intra_dc_precision = 8;
138 static int qp_hist = 0;
140 static char *vfilters = NULL;
143 static int audio_sample_rate = 0;
144 #define QSCALE_NONE -99999
145 static float audio_qscale = QSCALE_NONE;
146 static int audio_disable = 0;
147 static int audio_channels = 0;
148 static unsigned int audio_codec_tag = 0;
149 static char *audio_language = NULL;
151 static int subtitle_disable = 0;
152 static char *subtitle_language = NULL;
153 static unsigned int subtitle_codec_tag = 0;
155 static int data_disable = 0;
156 static unsigned int data_codec_tag = 0;
158 static float mux_preload= 0.5;
159 static float mux_max_delay= 0.7;
161 static int file_overwrite = 0;
162 static AVDictionary *metadata;
163 static int do_benchmark = 0;
164 static int do_hex_dump = 0;
165 static int do_pkt_dump = 0;
166 static int do_psnr = 0;
167 static int do_pass = 0;
168 static char *pass_logfilename_prefix = NULL;
169 static int video_sync_method= -1;
170 static int audio_sync_method= 0;
171 static float audio_drift_threshold= 0.1;
172 static int copy_ts= 0;
174 static int opt_shortest = 0;
175 static char *vstats_filename;
176 static FILE *vstats_file;
177 static int opt_programid = 0;
178 static int copy_initial_nonkeyframes = 0;
180 static int rate_emu = 0;
182 static int audio_volume = 256;
184 static int exit_on_error = 0;
185 static int using_stdin = 0;
186 static int verbose = 1;
187 static int64_t video_size = 0;
188 static int64_t audio_size = 0;
189 static int64_t extra_size = 0;
190 static int nb_frames_dup = 0;
191 static int nb_frames_drop = 0;
192 static int input_sync;
193 static int force_fps = 0;
194 static char *forced_key_frames = NULL;
196 static float dts_delta_threshold = 10;
198 static uint8_t *audio_buf;
199 static uint8_t *audio_out;
200 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
202 static short *samples;
204 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
205 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
206 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
208 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
210 typedef struct InputStream {
213 int discard; /* true if stream data should be discarded */
214 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
217 int64_t start; /* time when read started */
218 int64_t next_pts; /* synthetic pts for cases where pkt.pts
220 int64_t pts; /* current pts */
221 PtsCorrectionContext pts_ctx;
223 int is_start; /* is 1 at the start and after a discontinuity */
224 int showed_multi_packet_warning;
228 typedef struct InputFile {
229 AVFormatContext *ctx;
230 int eof_reached; /* true if eof reached */
231 int ist_index; /* index of first stream in ist_table */
232 int buffer_size; /* current total buffer size */
234 int nb_streams; /* number of stream that avconv is aware of; may be different
235 from ctx.nb_streams if new streams appear during av_read_frame() */
238 typedef struct OutputStream {
239 int file_index; /* file index */
240 int index; /* stream index in the output file */
241 int source_index; /* InputStream index */
242 AVStream *st; /* stream in the output file */
243 int encoding_needed; /* true if encoding needed for this stream */
245 /* input pts and corresponding output pts
247 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
248 struct InputStream *sync_ist; /* input stream to sync against */
249 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
250 AVBitStreamFilterContext *bitstream_filters;
255 AVFrame pict_tmp; /* temporary image for resampling */
256 struct SwsContext *img_resample_ctx; /* for image resampling */
259 int resample_pix_fmt;
260 AVRational frame_rate;
262 float frame_aspect_ratio;
264 /* forced key frames */
265 int64_t *forced_kf_pts;
271 ReSampleContext *resample; /* for audio resampling */
272 int resample_sample_fmt;
273 int resample_channels;
274 int resample_sample_rate;
276 AVAudioConvert *reformat_ctx;
277 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
281 AVFilterContext *output_video_filter;
282 AVFilterContext *input_video_filter;
283 AVFilterBufferRef *picref;
285 AVFilterGraph *graph;
290 int is_past_recording_time;
294 typedef struct OutputFile {
295 AVFormatContext *ctx;
297 int ost_index; /* index of the first stream in output_streams */
298 int64_t recording_time; /* desired length of the resulting file in microseconds */
299 int64_t start_time; /* start time in microseconds */
300 uint64_t limit_filesize;
303 static InputStream *input_streams = NULL;
304 static int nb_input_streams = 0;
305 static InputFile *input_files = NULL;
306 static int nb_input_files = 0;
308 static OutputStream *output_streams = NULL;
309 static int nb_output_streams = 0;
310 static OutputFile *output_files = NULL;
311 static int nb_output_files = 0;
313 typedef struct OptionsContext {
314 /* input/output options */
318 int64_t input_ts_offset;
321 StreamMap *stream_maps;
324 int64_t recording_time;
325 uint64_t limit_filesize;
328 static void reset_options(OptionsContext *o)
330 const OptionDef *po = options;
332 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
334 void *dst = (uint8_t*)o + po->u.off;
336 if (po->flags & OPT_SPEC) {
337 SpecifierOpt **so = dst;
338 int i, *count = (int*)(so + 1);
339 for (i = 0; i < *count; i++) {
340 av_freep(&(*so)[i].specifier);
341 if (po->flags & OPT_STRING)
342 av_freep(&(*so)[i].u.str);
346 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
351 av_freep(&o->stream_maps);
353 memset(o, 0, sizeof(*o));
355 o->recording_time = INT64_MAX;
356 o->limit_filesize = UINT64_MAX;
364 static int configure_video_filters(InputStream *ist, OutputStream *ost)
366 AVFilterContext *last_filter, *filter;
367 /** filter graph containing all filters including input & output */
368 AVCodecContext *codec = ost->st->codec;
369 AVCodecContext *icodec = ist->st->codec;
370 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
371 AVRational sample_aspect_ratio;
375 ost->graph = avfilter_graph_alloc();
377 if (ist->st->sample_aspect_ratio.num){
378 sample_aspect_ratio = ist->st->sample_aspect_ratio;
380 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
382 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
383 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
384 sample_aspect_ratio.num, sample_aspect_ratio.den);
386 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
387 "src", args, NULL, ost->graph);
390 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
391 "out", NULL, &ffsink_ctx, ost->graph);
394 last_filter = ost->input_video_filter;
396 if (codec->width != icodec->width || codec->height != icodec->height) {
397 snprintf(args, 255, "%d:%d:flags=0x%X",
401 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
402 NULL, args, NULL, ost->graph)) < 0)
404 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
406 last_filter = filter;
409 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
410 ost->graph->scale_sws_opts = av_strdup(args);
413 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
414 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
416 outputs->name = av_strdup("in");
417 outputs->filter_ctx = last_filter;
418 outputs->pad_idx = 0;
419 outputs->next = NULL;
421 inputs->name = av_strdup("out");
422 inputs->filter_ctx = ost->output_video_filter;
426 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
428 av_freep(&ost->avfilter);
430 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
434 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
437 codec->width = ost->output_video_filter->inputs[0]->w;
438 codec->height = ost->output_video_filter->inputs[0]->h;
439 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
440 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
441 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
442 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
446 #endif /* CONFIG_AVFILTER */
448 static void term_exit(void)
450 av_log(NULL, AV_LOG_QUIET, "");
453 static volatile int received_sigterm = 0;
454 static volatile int received_nb_signals = 0;
457 sigterm_handler(int sig)
459 received_sigterm = sig;
460 received_nb_signals++;
464 static void term_init(void)
466 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
467 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
469 signal(SIGXCPU, sigterm_handler);
473 static int decode_interrupt_cb(void)
475 return received_nb_signals > 1;
478 void exit_program(int ret)
483 for(i=0;i<nb_output_files;i++) {
484 AVFormatContext *s = output_files[i].ctx;
485 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
487 avformat_free_context(s);
488 av_dict_free(&output_files[i].opts);
490 for(i=0;i<nb_input_files;i++) {
491 av_close_input_file(input_files[i].ctx);
493 for (i = 0; i < nb_input_streams; i++)
494 av_dict_free(&input_streams[i].opts);
496 av_free(intra_matrix);
497 av_free(inter_matrix);
501 av_free(vstats_filename);
503 av_free(meta_data_maps);
505 av_freep(&input_streams);
506 av_freep(&input_files);
507 av_freep(&output_streams);
508 av_freep(&output_files);
513 allocated_audio_buf_size= allocated_audio_out_size= 0;
520 if (received_sigterm) {
522 "Received signal %d: terminating.\n",
523 (int) received_sigterm);
527 exit(ret); /* not all OS-es handle main() return value */
530 static void assert_avoptions(AVDictionary *m)
532 AVDictionaryEntry *t;
533 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
534 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
539 static void assert_codec_experimental(AVCodecContext *c, int encoder)
541 const char *codec_string = encoder ? "encoder" : "decoder";
543 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
544 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
545 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
546 "results.\nAdd '-strict experimental' if you want to use it.\n",
547 codec_string, c->codec->name);
548 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
549 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
550 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
551 codec_string, codec->name);
556 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
558 if(codec && codec->sample_fmts){
559 const enum AVSampleFormat *p= codec->sample_fmts;
561 if(*p == st->codec->sample_fmt)
565 av_log(NULL, AV_LOG_WARNING,
566 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
567 av_get_sample_fmt_name(st->codec->sample_fmt),
569 av_get_sample_fmt_name(codec->sample_fmts[0]));
570 st->codec->sample_fmt = codec->sample_fmts[0];
576 * Update the requested input sample format based on the output sample format.
577 * This is currently only used to request float output from decoders which
578 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
579 * Ideally this will be removed in the future when decoders do not do format
580 * conversion and only output in their native format.
582 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
585 /* if sample formats match or a decoder sample format has already been
586 requested, just return */
587 if (enc->sample_fmt == dec->sample_fmt ||
588 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
591 /* if decoder supports more than one output format */
592 if (dec_codec && dec_codec->sample_fmts &&
593 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
594 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
595 const enum AVSampleFormat *p;
596 int min_dec = -1, min_inc = -1;
598 /* find a matching sample format in the encoder */
599 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
600 if (*p == enc->sample_fmt) {
601 dec->request_sample_fmt = *p;
603 } else if (*p > enc->sample_fmt) {
604 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
606 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
609 /* if none match, provide the one that matches quality closest */
610 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
611 enc->sample_fmt - min_dec;
615 static void choose_sample_rate(AVStream *st, AVCodec *codec)
617 if(codec && codec->supported_samplerates){
618 const int *p= codec->supported_samplerates;
620 int best_dist=INT_MAX;
622 int dist= abs(st->codec->sample_rate - *p);
623 if(dist < best_dist){
629 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
631 st->codec->sample_rate= best;
635 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
637 if(codec && codec->pix_fmts){
638 const enum PixelFormat *p= codec->pix_fmts;
639 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
640 if(st->codec->codec_id==CODEC_ID_MJPEG){
641 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
642 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
643 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};
647 if(*p == st->codec->pix_fmt)
651 if(st->codec->pix_fmt != PIX_FMT_NONE)
652 av_log(NULL, AV_LOG_WARNING,
653 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
654 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
656 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
657 st->codec->pix_fmt = codec->pix_fmts[0];
663 get_sync_ipts(const OutputStream *ost)
665 const InputStream *ist = ost->sync_ist;
666 OutputFile *of = &output_files[ost->file_index];
667 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
670 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
674 AVPacket new_pkt= *pkt;
675 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
676 &new_pkt.data, &new_pkt.size,
677 pkt->data, pkt->size,
678 pkt->flags & AV_PKT_FLAG_KEY);
681 new_pkt.destruct= av_destruct_packet;
683 fprintf(stderr, "%s failed for stream %d, codec %s",
684 bsfc->filter->name, pkt->stream_index,
685 avctx->codec ? avctx->codec->name : "copy");
695 ret= av_interleaved_write_frame(s, pkt);
697 print_error("av_interleaved_write_frame()", ret);
702 static void do_audio_out(AVFormatContext *s,
705 unsigned char *buf, int size)
708 int64_t audio_out_size, audio_buf_size;
709 int64_t allocated_for_size= size;
711 int size_out, frame_bytes, ret, resample_changed;
712 AVCodecContext *enc= ost->st->codec;
713 AVCodecContext *dec= ist->st->codec;
714 int osize = av_get_bytes_per_sample(enc->sample_fmt);
715 int isize = av_get_bytes_per_sample(dec->sample_fmt);
716 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
719 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
720 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
721 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
722 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
723 audio_buf_size*= osize*enc->channels;
725 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
726 if(coded_bps > 8*osize)
727 audio_out_size= audio_out_size * coded_bps / (8*osize);
728 audio_out_size += FF_MIN_BUFFER_SIZE;
730 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
731 fprintf(stderr, "Buffer sizes too large\n");
735 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
736 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
737 if (!audio_buf || !audio_out){
738 fprintf(stderr, "Out of memory in do_audio_out\n");
742 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
743 ost->audio_resample = 1;
745 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
746 ost->resample_channels != dec->channels ||
747 ost->resample_sample_rate != dec->sample_rate;
749 if ((ost->audio_resample && !ost->resample) || resample_changed) {
750 if (resample_changed) {
751 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",
752 ist->file_index, ist->st->index,
753 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
754 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
755 ost->resample_sample_fmt = dec->sample_fmt;
756 ost->resample_channels = dec->channels;
757 ost->resample_sample_rate = dec->sample_rate;
759 audio_resample_close(ost->resample);
761 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
762 if (audio_sync_method <= 1 &&
763 ost->resample_sample_fmt == enc->sample_fmt &&
764 ost->resample_channels == enc->channels &&
765 ost->resample_sample_rate == enc->sample_rate) {
766 ost->resample = NULL;
767 ost->audio_resample = 0;
768 } else if (ost->audio_resample) {
769 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
770 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
771 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
772 enc->sample_rate, dec->sample_rate,
773 enc->sample_fmt, dec->sample_fmt,
775 if (!ost->resample) {
776 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
777 dec->channels, dec->sample_rate,
778 enc->channels, enc->sample_rate);
784 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
785 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
786 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
787 if (ost->reformat_ctx)
788 av_audio_convert_free(ost->reformat_ctx);
789 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
790 dec->sample_fmt, 1, NULL, 0);
791 if (!ost->reformat_ctx) {
792 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
793 av_get_sample_fmt_name(dec->sample_fmt),
794 av_get_sample_fmt_name(enc->sample_fmt));
797 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
800 if(audio_sync_method){
801 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
802 - av_fifo_size(ost->fifo)/(enc->channels * 2);
803 double idelta= delta*dec->sample_rate / enc->sample_rate;
804 int byte_delta= ((int)idelta)*2*dec->channels;
806 //FIXME resample delay
807 if(fabs(delta) > 50){
808 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
810 byte_delta= FFMAX(byte_delta, -size);
814 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
819 static uint8_t *input_tmp= NULL;
820 input_tmp= av_realloc(input_tmp, byte_delta + size);
822 if(byte_delta > allocated_for_size - size){
823 allocated_for_size= byte_delta + (int64_t)size;
828 memset(input_tmp, 0, byte_delta);
829 memcpy(input_tmp + byte_delta, buf, size);
833 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
835 }else if(audio_sync_method>1){
836 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
837 av_assert0(ost->audio_resample);
839 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
840 // 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));
841 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
845 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
846 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
848 if (ost->audio_resample) {
850 size_out = audio_resample(ost->resample,
851 (short *)buftmp, (short *)buf,
852 size / (dec->channels * isize));
853 size_out = size_out * enc->channels * osize;
859 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
860 const void *ibuf[6]= {buftmp};
861 void *obuf[6]= {audio_buf};
862 int istride[6]= {isize};
863 int ostride[6]= {osize};
864 int len= size_out/istride[0];
865 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
866 printf("av_audio_convert() failed\n");
872 size_out = len*osize;
875 /* now encode as many frames as possible */
876 if (enc->frame_size > 1) {
877 /* output resampled raw samples */
878 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
879 fprintf(stderr, "av_fifo_realloc2() failed\n");
882 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
884 frame_bytes = enc->frame_size * osize * enc->channels;
886 while (av_fifo_size(ost->fifo) >= frame_bytes) {
888 av_init_packet(&pkt);
890 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
892 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
894 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
897 fprintf(stderr, "Audio encoding failed\n");
901 pkt.stream_index= ost->index;
904 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
905 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
906 pkt.flags |= AV_PKT_FLAG_KEY;
907 write_frame(s, &pkt, enc, ost->bitstream_filters);
909 ost->sync_opts += enc->frame_size;
913 av_init_packet(&pkt);
915 ost->sync_opts += size_out / (osize * enc->channels);
917 /* output a pcm frame */
918 /* determine the size of the coded buffer */
921 size_out = size_out*coded_bps/8;
923 if(size_out > audio_out_size){
924 fprintf(stderr, "Internal error, buffer size too small\n");
928 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
929 ret = avcodec_encode_audio(enc, audio_out, size_out,
932 fprintf(stderr, "Audio encoding failed\n");
936 pkt.stream_index= ost->index;
939 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
940 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
941 pkt.flags |= AV_PKT_FLAG_KEY;
942 write_frame(s, &pkt, enc, ost->bitstream_filters);
946 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
950 AVPicture picture_tmp;
953 dec = ist->st->codec;
955 /* deinterlace : must be done before any resize */
956 if (do_deinterlace) {
959 /* create temporary picture */
960 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
961 buf = av_malloc(size);
965 picture2 = &picture_tmp;
966 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
968 if(avpicture_deinterlace(picture2, picture,
969 dec->pix_fmt, dec->width, dec->height) < 0) {
970 /* if error, do not deinterlace */
971 fprintf(stderr, "Deinterlacing failed\n");
980 if (picture != picture2)
981 *picture = *picture2;
985 static void do_subtitle_out(AVFormatContext *s,
991 static uint8_t *subtitle_out = NULL;
992 int subtitle_out_max_size = 1024 * 1024;
993 int subtitle_out_size, nb, i;
997 if (pts == AV_NOPTS_VALUE) {
998 fprintf(stderr, "Subtitle packets must have a pts\n");
1004 enc = ost->st->codec;
1006 if (!subtitle_out) {
1007 subtitle_out = av_malloc(subtitle_out_max_size);
1010 /* Note: DVB subtitle need one packet to draw them and one other
1011 packet to clear them */
1012 /* XXX: signal it in the codec context ? */
1013 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1018 for(i = 0; i < nb; i++) {
1019 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1020 // start_display_time is required to be 0
1021 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1022 sub->end_display_time -= sub->start_display_time;
1023 sub->start_display_time = 0;
1024 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1025 subtitle_out_max_size, sub);
1026 if (subtitle_out_size < 0) {
1027 fprintf(stderr, "Subtitle encoding failed\n");
1031 av_init_packet(&pkt);
1032 pkt.stream_index = ost->index;
1033 pkt.data = subtitle_out;
1034 pkt.size = subtitle_out_size;
1035 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1036 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1037 /* XXX: the pts correction is handled here. Maybe handling
1038 it in the codec would be better */
1040 pkt.pts += 90 * sub->start_display_time;
1042 pkt.pts += 90 * sub->end_display_time;
1044 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1048 static int bit_buffer_size= 1024*256;
1049 static uint8_t *bit_buffer= NULL;
1051 static void do_video_resample(OutputStream *ost,
1053 AVFrame *in_picture,
1054 AVFrame **out_picture)
1056 int resample_changed = 0;
1057 AVCodecContext *dec = ist->st->codec;
1058 *out_picture = in_picture;
1060 resample_changed = ost->resample_width != dec->width ||
1061 ost->resample_height != dec->height ||
1062 ost->resample_pix_fmt != dec->pix_fmt;
1064 if (resample_changed) {
1065 av_log(NULL, AV_LOG_INFO,
1066 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1067 ist->file_index, ist->st->index,
1068 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1069 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1070 if(!ost->video_resample)
1071 ost->video_resample = 1;
1074 #if !CONFIG_AVFILTER
1075 if (ost->video_resample) {
1076 *out_picture = &ost->pict_tmp;
1077 if (resample_changed) {
1078 /* initialize a new scaler context */
1079 sws_freeContext(ost->img_resample_ctx);
1080 ost->img_resample_ctx = sws_getContext(
1081 ist->st->codec->width,
1082 ist->st->codec->height,
1083 ist->st->codec->pix_fmt,
1084 ost->st->codec->width,
1085 ost->st->codec->height,
1086 ost->st->codec->pix_fmt,
1087 ost->sws_flags, NULL, NULL, NULL);
1088 if (ost->img_resample_ctx == NULL) {
1089 fprintf(stderr, "Cannot get resampling context\n");
1093 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1094 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1097 if (resample_changed) {
1098 avfilter_graph_free(&ost->graph);
1099 if (configure_video_filters(ist, ost)) {
1100 fprintf(stderr, "Error reinitializing filters!\n");
1105 if (resample_changed) {
1106 ost->resample_width = dec->width;
1107 ost->resample_height = dec->height;
1108 ost->resample_pix_fmt = dec->pix_fmt;
1113 static void do_video_out(AVFormatContext *s,
1116 AVFrame *in_picture,
1117 int *frame_size, float quality)
1119 int nb_frames, i, ret, format_video_sync;
1120 AVFrame *final_picture;
1121 AVCodecContext *enc;
1124 enc = ost->st->codec;
1126 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1128 /* by default, we output a single frame */
1133 format_video_sync = video_sync_method;
1134 if (format_video_sync < 0)
1135 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1137 if (format_video_sync) {
1138 double vdelta = sync_ipts - ost->sync_opts;
1139 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1142 else if (format_video_sync == 2) {
1145 }else if(vdelta>0.6)
1146 ost->sync_opts= lrintf(sync_ipts);
1147 }else if (vdelta > 1.1)
1148 nb_frames = lrintf(vdelta);
1149 //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);
1150 if (nb_frames == 0){
1153 fprintf(stderr, "*** drop!\n");
1154 }else if (nb_frames > 1) {
1155 nb_frames_dup += nb_frames - 1;
1157 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1160 ost->sync_opts= lrintf(sync_ipts);
1162 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1166 do_video_resample(ost, ist, in_picture, &final_picture);
1168 /* duplicates frame if needed */
1169 for(i=0;i<nb_frames;i++) {
1171 av_init_packet(&pkt);
1172 pkt.stream_index= ost->index;
1174 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1175 /* raw pictures are written as AVPicture structure to
1176 avoid any copies. We support temporarily the older
1178 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1179 enc->coded_frame->top_field_first = in_picture->top_field_first;
1180 pkt.data= (uint8_t *)final_picture;
1181 pkt.size= sizeof(AVPicture);
1182 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1183 pkt.flags |= AV_PKT_FLAG_KEY;
1185 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1187 AVFrame big_picture;
1189 big_picture= *final_picture;
1190 /* better than nothing: use input picture interlaced
1192 big_picture.interlaced_frame = in_picture->interlaced_frame;
1193 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1194 if(top_field_first == -1)
1195 big_picture.top_field_first = in_picture->top_field_first;
1197 big_picture.top_field_first = top_field_first;
1200 /* handles same_quant here. This is not correct because it may
1201 not be a global option */
1202 big_picture.quality = quality;
1204 big_picture.pict_type = 0;
1205 // big_picture.pts = AV_NOPTS_VALUE;
1206 big_picture.pts= ost->sync_opts;
1207 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1208 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1209 if (ost->forced_kf_index < ost->forced_kf_count &&
1210 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1211 big_picture.pict_type = AV_PICTURE_TYPE_I;
1212 ost->forced_kf_index++;
1214 ret = avcodec_encode_video(enc,
1215 bit_buffer, bit_buffer_size,
1218 fprintf(stderr, "Video encoding failed\n");
1223 pkt.data= bit_buffer;
1225 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1226 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1227 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1228 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1229 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1231 if(enc->coded_frame->key_frame)
1232 pkt.flags |= AV_PKT_FLAG_KEY;
1233 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1236 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1237 // enc->frame_number-1, ret, enc->pict_type);
1238 /* if two pass, output log */
1239 if (ost->logfile && enc->stats_out) {
1240 fprintf(ost->logfile, "%s", enc->stats_out);
1245 ost->frame_number++;
1249 static double psnr(double d){
1250 return -10.0*log(d)/log(10.0);
1253 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1256 AVCodecContext *enc;
1258 double ti1, bitrate, avg_bitrate;
1260 /* this is executed just the first time do_video_stats is called */
1262 vstats_file = fopen(vstats_filename, "w");
1269 enc = ost->st->codec;
1270 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1271 frame_number = ost->frame_number;
1272 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1273 if (enc->flags&CODEC_FLAG_PSNR)
1274 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1276 fprintf(vstats_file,"f_size= %6d ", frame_size);
1277 /* compute pts value */
1278 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1282 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1283 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1284 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1285 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1286 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1290 static void print_report(OutputFile *output_files,
1291 OutputStream *ost_table, int nb_ostreams,
1292 int is_last_report, int64_t timer_start)
1296 AVFormatContext *oc;
1298 AVCodecContext *enc;
1299 int frame_number, vid, i;
1300 double bitrate, ti1, pts;
1301 static int64_t last_time = -1;
1302 static int qp_histogram[52];
1304 if (!is_last_report) {
1306 /* display the report every 0.5 seconds */
1307 cur_time = av_gettime();
1308 if (last_time == -1) {
1309 last_time = cur_time;
1312 if ((cur_time - last_time) < 500000)
1314 last_time = cur_time;
1318 oc = output_files[0].ctx;
1320 total_size = avio_size(oc->pb);
1321 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1322 total_size= avio_tell(oc->pb);
1327 for(i=0;i<nb_ostreams;i++) {
1329 ost = &ost_table[i];
1330 enc = ost->st->codec;
1331 if (!ost->st->stream_copy && enc->coded_frame)
1332 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1333 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1334 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1336 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1337 float t = (av_gettime()-timer_start) / 1000000.0;
1339 frame_number = ost->frame_number;
1340 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1341 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1343 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1347 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1350 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1352 if (enc->flags&CODEC_FLAG_PSNR){
1354 double error, error_sum=0;
1355 double scale, scale_sum=0;
1356 char type[3]= {'Y','U','V'};
1357 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1360 error= enc->error[j];
1361 scale= enc->width*enc->height*255.0*255.0*frame_number;
1363 error= enc->coded_frame->error[j];
1364 scale= enc->width*enc->height*255.0*255.0;
1369 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1371 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1375 /* compute min output value */
1376 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1377 if ((pts < ti1) && (pts > 0))
1383 if (verbose > 0 || is_last_report) {
1384 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1386 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1387 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1388 (double)total_size / 1024, ti1, bitrate);
1390 if (nb_frames_dup || nb_frames_drop)
1391 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1392 nb_frames_dup, nb_frames_drop);
1395 fprintf(stderr, "%s \r", buf);
1400 if (is_last_report && verbose >= 0){
1401 int64_t raw= audio_size + video_size + extra_size;
1402 fprintf(stderr, "\n");
1403 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1407 100.0*(total_size - raw)/raw
1412 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1414 int fill_char = 0x00;
1415 if (sample_fmt == AV_SAMPLE_FMT_U8)
1417 memset(buf, fill_char, size);
1420 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1424 for (i = 0; i < nb_ostreams; i++) {
1425 OutputStream *ost = &ost_table[i];
1426 AVCodecContext *enc = ost->st->codec;
1427 AVFormatContext *os = output_files[ost->file_index].ctx;
1429 if (!ost->encoding_needed)
1432 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1434 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1440 av_init_packet(&pkt);
1441 pkt.stream_index= ost->index;
1443 switch (ost->st->codec->codec_type) {
1444 case AVMEDIA_TYPE_AUDIO:
1445 fifo_bytes = av_fifo_size(ost->fifo);
1447 /* encode any samples remaining in fifo */
1448 if (fifo_bytes > 0) {
1449 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1450 int fs_tmp = enc->frame_size;
1452 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1453 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1454 enc->frame_size = fifo_bytes / (osize * enc->channels);
1456 int frame_bytes = enc->frame_size*osize*enc->channels;
1457 if (allocated_audio_buf_size < frame_bytes)
1459 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1462 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1463 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1464 ost->st->time_base.num, enc->sample_rate);
1465 enc->frame_size = fs_tmp;
1468 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1471 fprintf(stderr, "Audio encoding failed\n");
1475 pkt.flags |= AV_PKT_FLAG_KEY;
1477 case AVMEDIA_TYPE_VIDEO:
1478 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1480 fprintf(stderr, "Video encoding failed\n");
1484 if(enc->coded_frame && enc->coded_frame->key_frame)
1485 pkt.flags |= AV_PKT_FLAG_KEY;
1486 if (ost->logfile && enc->stats_out) {
1487 fprintf(ost->logfile, "%s", enc->stats_out);
1496 pkt.data = bit_buffer;
1498 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1499 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1500 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1505 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1506 static int output_packet(InputStream *ist, int ist_index,
1507 OutputStream *ost_table, int nb_ostreams,
1508 const AVPacket *pkt)
1510 AVFormatContext *os;
1515 void *buffer_to_free = NULL;
1516 static unsigned int samples_size= 0;
1517 AVSubtitle subtitle, *subtitle_to_free;
1518 int64_t pkt_pts = AV_NOPTS_VALUE;
1520 int frame_available;
1525 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1527 if(ist->next_pts == AV_NOPTS_VALUE)
1528 ist->next_pts= ist->pts;
1532 av_init_packet(&avpkt);
1540 if(pkt->dts != AV_NOPTS_VALUE)
1541 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1542 if(pkt->pts != AV_NOPTS_VALUE)
1543 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1545 //while we have more to decode or while the decoder did output something on EOF
1546 while (avpkt.size > 0 || (!pkt && got_output)) {
1547 uint8_t *data_buf, *decoded_data_buf;
1548 int data_size, decoded_data_size;
1550 ist->pts= ist->next_pts;
1552 if(avpkt.size && avpkt.size != pkt->size &&
1553 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1554 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1555 ist->showed_multi_packet_warning=1;
1558 /* decode the packet if needed */
1559 decoded_data_buf = NULL; /* fail safe */
1560 decoded_data_size= 0;
1561 data_buf = avpkt.data;
1562 data_size = avpkt.size;
1563 subtitle_to_free = NULL;
1564 if (ist->decoding_needed) {
1565 switch(ist->st->codec->codec_type) {
1566 case AVMEDIA_TYPE_AUDIO:{
1567 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1568 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1570 samples= av_malloc(samples_size);
1572 decoded_data_size= samples_size;
1573 /* XXX: could avoid copy if PCM 16 bits with same
1574 endianness as CPU */
1575 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1582 got_output = decoded_data_size > 0;
1583 /* Some bug in mpeg audio decoder gives */
1584 /* decoded_data_size < 0, it seems they are overflows */
1586 /* no audio frame */
1589 decoded_data_buf = (uint8_t *)samples;
1590 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1591 (ist->st->codec->sample_rate * ist->st->codec->channels);
1593 case AVMEDIA_TYPE_VIDEO:
1594 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1595 /* XXX: allocate picture correctly */
1596 avcodec_get_frame_defaults(&picture);
1597 avpkt.pts = pkt_pts;
1598 avpkt.dts = ist->pts;
1599 pkt_pts = AV_NOPTS_VALUE;
1601 ret = avcodec_decode_video2(ist->st->codec,
1602 &picture, &got_output, &avpkt);
1603 quality = same_quant ? picture.quality : 0;
1607 /* no picture yet */
1608 goto discard_packet;
1610 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, picture.pkt_pts, picture.pkt_dts);
1611 if (ist->st->codec->time_base.num != 0) {
1612 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1613 ist->next_pts += ((int64_t)AV_TIME_BASE *
1614 ist->st->codec->time_base.num * ticks) /
1615 ist->st->codec->time_base.den;
1618 buffer_to_free = NULL;
1619 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1621 case AVMEDIA_TYPE_SUBTITLE:
1622 ret = avcodec_decode_subtitle2(ist->st->codec,
1623 &subtitle, &got_output, &avpkt);
1627 goto discard_packet;
1629 subtitle_to_free = &subtitle;
1636 switch(ist->st->codec->codec_type) {
1637 case AVMEDIA_TYPE_AUDIO:
1638 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1639 ist->st->codec->sample_rate;
1641 case AVMEDIA_TYPE_VIDEO:
1642 if (ist->st->codec->time_base.num != 0) {
1643 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1644 ist->next_pts += ((int64_t)AV_TIME_BASE *
1645 ist->st->codec->time_base.num * ticks) /
1646 ist->st->codec->time_base.den;
1653 // preprocess audio (volume)
1654 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1655 if (audio_volume != 256) {
1658 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1659 int v = ((*volp) * audio_volume + 128) >> 8;
1660 *volp++ = av_clip_int16(v);
1665 /* frame rate emulation */
1667 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1668 int64_t now = av_gettime() - ist->start;
1672 /* if output time reached then transcode raw format,
1673 encode packets and output them */
1674 for (i = 0; i < nb_ostreams; i++) {
1675 OutputFile *of = &output_files[ost_table[i].file_index];
1678 ost = &ost_table[i];
1679 if (ost->source_index != ist_index)
1682 if (of->start_time && ist->pts < of->start_time)
1685 if (of->recording_time != INT64_MAX &&
1686 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1687 (AVRational){1, 1000000}) >= 0) {
1688 ost->is_past_recording_time = 1;
1693 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1694 ost->input_video_filter) {
1696 if (ist->st->sample_aspect_ratio.num)
1697 sar = ist->st->sample_aspect_ratio;
1699 sar = ist->st->codec->sample_aspect_ratio;
1700 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, ist->pts, sar);
1702 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1703 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1704 while (frame_available) {
1705 AVRational ist_pts_tb;
1706 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1707 get_filtered_video_frame(ost->output_video_filter, &picture, &ost->picref, &ist_pts_tb);
1709 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1711 os = output_files[ost->file_index].ctx;
1713 /* set the input output pts pairs */
1714 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1716 if (ost->encoding_needed) {
1717 av_assert0(ist->decoding_needed);
1718 switch(ost->st->codec->codec_type) {
1719 case AVMEDIA_TYPE_AUDIO:
1720 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1722 case AVMEDIA_TYPE_VIDEO:
1724 if (ost->picref->video && !ost->frame_aspect_ratio)
1725 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1727 do_video_out(os, ost, ist, &picture, &frame_size,
1728 same_quant ? quality : ost->st->codec->global_quality);
1729 if (vstats_filename && frame_size)
1730 do_video_stats(os, ost, frame_size);
1732 case AVMEDIA_TYPE_SUBTITLE:
1733 do_subtitle_out(os, ost, ist, &subtitle,
1740 AVFrame avframe; //FIXME/XXX remove this
1742 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1744 av_init_packet(&opkt);
1746 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1747 #if !CONFIG_AVFILTER
1753 /* no reencoding needed : output the packet directly */
1754 /* force the input stream PTS */
1756 avcodec_get_frame_defaults(&avframe);
1757 ost->st->codec->coded_frame= &avframe;
1758 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1760 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1761 audio_size += data_size;
1762 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1763 video_size += data_size;
1767 opkt.stream_index= ost->index;
1768 if(pkt->pts != AV_NOPTS_VALUE)
1769 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1771 opkt.pts= AV_NOPTS_VALUE;
1773 if (pkt->dts == AV_NOPTS_VALUE)
1774 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1776 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1777 opkt.dts -= ost_tb_start_time;
1779 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1780 opkt.flags= pkt->flags;
1782 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1783 if( ost->st->codec->codec_id != CODEC_ID_H264
1784 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1785 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1787 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1788 opkt.destruct= av_destruct_packet;
1790 opkt.data = data_buf;
1791 opkt.size = data_size;
1794 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1795 ost->st->codec->frame_number++;
1796 ost->frame_number++;
1797 av_free_packet(&opkt);
1801 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1802 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1804 avfilter_unref_buffer(ost->picref);
1809 av_free(buffer_to_free);
1810 /* XXX: allocate the subtitles in the codec ? */
1811 if (subtitle_to_free) {
1812 avsubtitle_free(subtitle_to_free);
1813 subtitle_to_free = NULL;
1821 static void print_sdp(OutputFile *output_files, int n)
1825 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1829 for (i = 0; i < n; i++)
1830 avc[i] = output_files[i].ctx;
1832 av_sdp_create(avc, n, sdp, sizeof(sdp));
1833 printf("SDP:\n%s\n", sdp);
1838 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1839 char *error, int error_len)
1842 InputStream *ist = &input_streams[ist_index];
1843 if (ist->decoding_needed) {
1844 AVCodec *codec = ist->dec;
1846 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1847 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1848 return AVERROR(EINVAL);
1851 /* update requested sample format for the decoder based on the
1852 corresponding encoder sample format */
1853 for (i = 0; i < nb_output_streams; i++) {
1854 OutputStream *ost = &output_streams[i];
1855 if (ost->source_index == ist_index) {
1856 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1861 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1862 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1863 ist->file_index, ist->st->index);
1864 return AVERROR(EINVAL);
1866 assert_codec_experimental(ist->st->codec, 0);
1867 assert_avoptions(ist->opts);
1870 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;
1871 ist->next_pts = AV_NOPTS_VALUE;
1872 init_pts_correction(&ist->pts_ctx);
1878 static int transcode_init(OutputFile *output_files,
1879 int nb_output_files,
1880 InputFile *input_files,
1884 AVFormatContext *os;
1885 AVCodecContext *codec, *icodec;
1892 for (i = 0; i < nb_input_streams; i++)
1893 input_streams[i].start = av_gettime();
1895 /* output stream init */
1896 for(i=0;i<nb_output_files;i++) {
1897 os = output_files[i].ctx;
1898 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1899 av_dump_format(os, i, os->filename, 1);
1900 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1901 return AVERROR(EINVAL);
1905 /* for each output stream, we compute the right encoding parameters */
1906 for (i = 0; i < nb_output_streams; i++) {
1907 ost = &output_streams[i];
1908 os = output_files[ost->file_index].ctx;
1909 ist = &input_streams[ost->source_index];
1911 codec = ost->st->codec;
1912 icodec = ist->st->codec;
1914 ost->st->disposition = ist->st->disposition;
1915 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1916 codec->chroma_sample_location = icodec->chroma_sample_location;
1918 if (ost->st->stream_copy) {
1919 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1921 if (extra_size > INT_MAX) {
1922 return AVERROR(EINVAL);
1925 /* if stream_copy is selected, no need to decode or encode */
1926 codec->codec_id = icodec->codec_id;
1927 codec->codec_type = icodec->codec_type;
1929 if(!codec->codec_tag){
1930 if( !os->oformat->codec_tag
1931 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1932 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1933 codec->codec_tag = icodec->codec_tag;
1936 codec->bit_rate = icodec->bit_rate;
1937 codec->rc_max_rate = icodec->rc_max_rate;
1938 codec->rc_buffer_size = icodec->rc_buffer_size;
1939 codec->extradata= av_mallocz(extra_size);
1940 if (!codec->extradata) {
1941 return AVERROR(ENOMEM);
1943 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1944 codec->extradata_size= icodec->extradata_size;
1945 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){
1946 codec->time_base = icodec->time_base;
1947 codec->time_base.num *= icodec->ticks_per_frame;
1948 av_reduce(&codec->time_base.num, &codec->time_base.den,
1949 codec->time_base.num, codec->time_base.den, INT_MAX);
1951 codec->time_base = ist->st->time_base;
1952 switch(codec->codec_type) {
1953 case AVMEDIA_TYPE_AUDIO:
1954 if(audio_volume != 256) {
1955 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
1958 codec->channel_layout = icodec->channel_layout;
1959 codec->sample_rate = icodec->sample_rate;
1960 codec->channels = icodec->channels;
1961 codec->frame_size = icodec->frame_size;
1962 codec->audio_service_type = icodec->audio_service_type;
1963 codec->block_align= icodec->block_align;
1964 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1965 codec->block_align= 0;
1966 if(codec->codec_id == CODEC_ID_AC3)
1967 codec->block_align= 0;
1969 case AVMEDIA_TYPE_VIDEO:
1970 codec->pix_fmt = icodec->pix_fmt;
1971 codec->width = icodec->width;
1972 codec->height = icodec->height;
1973 codec->has_b_frames = icodec->has_b_frames;
1974 if (!codec->sample_aspect_ratio.num) {
1975 codec->sample_aspect_ratio =
1976 ost->st->sample_aspect_ratio =
1977 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1978 ist->st->codec->sample_aspect_ratio.num ?
1979 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
1982 case AVMEDIA_TYPE_SUBTITLE:
1983 codec->width = icodec->width;
1984 codec->height = icodec->height;
1986 case AVMEDIA_TYPE_DATA:
1993 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
1994 switch(codec->codec_type) {
1995 case AVMEDIA_TYPE_AUDIO:
1996 ost->fifo= av_fifo_alloc(1024);
1998 return AVERROR(ENOMEM);
2000 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2001 if (!codec->sample_rate) {
2002 codec->sample_rate = icodec->sample_rate;
2004 codec->sample_rate >>= icodec->lowres;
2006 choose_sample_rate(ost->st, ost->enc);
2007 codec->time_base = (AVRational){1, codec->sample_rate};
2008 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2009 codec->sample_fmt = icodec->sample_fmt;
2010 choose_sample_fmt(ost->st, ost->enc);
2011 if (!codec->channels)
2012 codec->channels = icodec->channels;
2013 codec->channel_layout = icodec->channel_layout;
2014 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2015 codec->channel_layout = 0;
2016 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2017 icodec->request_channels = codec->channels;
2018 ist->decoding_needed = 1;
2019 ost->encoding_needed = 1;
2020 ost->resample_sample_fmt = icodec->sample_fmt;
2021 ost->resample_sample_rate = icodec->sample_rate;
2022 ost->resample_channels = icodec->channels;
2024 case AVMEDIA_TYPE_VIDEO:
2025 if (codec->pix_fmt == PIX_FMT_NONE)
2026 codec->pix_fmt = icodec->pix_fmt;
2027 choose_pixel_fmt(ost->st, ost->enc);
2029 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2030 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2034 if (!codec->width || !codec->height) {
2035 codec->width = icodec->width;
2036 codec->height = icodec->height;
2039 ost->video_resample = codec->width != icodec->width ||
2040 codec->height != icodec->height ||
2041 codec->pix_fmt != icodec->pix_fmt;
2042 if (ost->video_resample) {
2043 #if !CONFIG_AVFILTER
2044 avcodec_get_frame_defaults(&ost->pict_tmp);
2045 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2046 codec->width, codec->height)) {
2047 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
2050 ost->img_resample_ctx = sws_getContext(
2057 ost->sws_flags, NULL, NULL, NULL);
2058 if (ost->img_resample_ctx == NULL) {
2059 fprintf(stderr, "Cannot get resampling context\n");
2063 codec->bits_per_raw_sample= 0;
2066 ost->resample_height = icodec->height;
2067 ost->resample_width = icodec->width;
2068 ost->resample_pix_fmt= icodec->pix_fmt;
2069 ost->encoding_needed = 1;
2070 ist->decoding_needed = 1;
2072 if (!ost->frame_rate.num)
2073 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2074 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2075 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2076 ost->frame_rate = ost->enc->supported_framerates[idx];
2078 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2081 if (configure_video_filters(ist, ost)) {
2082 fprintf(stderr, "Error opening filters!\n");
2087 case AVMEDIA_TYPE_SUBTITLE:
2088 ost->encoding_needed = 1;
2089 ist->decoding_needed = 1;
2096 if (ost->encoding_needed &&
2097 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2098 char logfilename[1024];
2101 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2102 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2104 if (codec->flags & CODEC_FLAG_PASS1) {
2105 f = fopen(logfilename, "wb");
2107 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2113 size_t logbuffer_size;
2114 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2115 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2118 codec->stats_in = logbuffer;
2122 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2123 int size= codec->width * codec->height;
2124 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2129 bit_buffer = av_malloc(bit_buffer_size);
2131 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2133 return AVERROR(ENOMEM);
2136 /* open each encoder */
2137 for (i = 0; i < nb_output_streams; i++) {
2138 ost = &output_streams[i];
2139 if (ost->encoding_needed) {
2140 AVCodec *codec = ost->enc;
2141 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2143 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2144 ost->st->codec->codec_id, ost->file_index, ost->index);
2145 ret = AVERROR(EINVAL);
2148 if (dec->subtitle_header) {
2149 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2150 if (!ost->st->codec->subtitle_header) {
2151 ret = AVERROR(ENOMEM);
2154 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2155 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2157 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2158 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2159 ost->file_index, ost->index);
2160 ret = AVERROR(EINVAL);
2163 assert_codec_experimental(ost->st->codec, 1);
2164 assert_avoptions(ost->opts);
2165 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2166 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2167 "It takes bits/s as argument, not kbits/s\n");
2168 extra_size += ost->st->codec->extradata_size;
2172 /* init input streams */
2173 for (i = 0; i < nb_input_streams; i++)
2174 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2177 /* open files and write file headers */
2178 for (i = 0; i < nb_output_files; i++) {
2179 os = output_files[i].ctx;
2180 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2181 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2182 ret = AVERROR(EINVAL);
2185 assert_avoptions(output_files[i].opts);
2186 if (strcmp(os->oformat->name, "rtp")) {
2192 /* dump the file output parameters - cannot be done before in case
2194 for(i=0;i<nb_output_files;i++) {
2195 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2198 /* dump the stream mapping */
2200 fprintf(stderr, "Stream mapping:\n");
2201 for (i = 0; i < nb_output_streams;i ++) {
2202 ost = &output_streams[i];
2203 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2204 input_streams[ost->source_index].file_index,
2205 input_streams[ost->source_index].st->index,
2208 if (ost->sync_ist != &input_streams[ost->source_index])
2209 fprintf(stderr, " [sync #%d.%d]",
2210 ost->sync_ist->file_index,
2211 ost->sync_ist->st->index);
2212 if (ost->st->stream_copy)
2213 fprintf(stderr, " (copy)");
2215 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2216 input_streams[ost->source_index].dec->name : "?",
2217 ost->enc ? ost->enc->name : "?");
2218 fprintf(stderr, "\n");
2223 fprintf(stderr, "%s\n", error);
2228 print_sdp(output_files, nb_output_files);
2235 * The following code is the main loop of the file converter
2237 static int transcode(OutputFile *output_files,
2238 int nb_output_files,
2239 InputFile *input_files,
2243 AVFormatContext *is, *os;
2247 int no_packet_count=0;
2248 int64_t timer_start;
2250 if (!(no_packet = av_mallocz(nb_input_files)))
2253 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2258 fprintf(stderr, "Press ctrl-c to stop encoding\n");
2261 timer_start = av_gettime();
2263 for(; received_sigterm == 0;) {
2264 int file_index, ist_index;
2269 ipts_min = INT64_MAX;
2272 /* select the stream that we must read now by looking at the
2273 smallest output pts */
2275 for (i = 0; i < nb_output_streams; i++) {
2279 ost = &output_streams[i];
2280 of = &output_files[ost->file_index];
2281 os = output_files[ost->file_index].ctx;
2282 ist = &input_streams[ost->source_index];
2283 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2284 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2286 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2288 if (!input_files[ist->file_index].eof_reached){
2289 if(ipts < ipts_min) {
2291 if(input_sync ) file_index = ist->file_index;
2293 if(opts < opts_min) {
2295 if(!input_sync) file_index = ist->file_index;
2298 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2303 /* if none, if is finished */
2304 if (file_index < 0) {
2305 if(no_packet_count){
2307 memset(no_packet, 0, nb_input_files);
2314 /* read a frame from it and output it in the fifo */
2315 is = input_files[file_index].ctx;
2316 ret= av_read_frame(is, &pkt);
2317 if(ret == AVERROR(EAGAIN)){
2318 no_packet[file_index]=1;
2323 input_files[file_index].eof_reached = 1;
2331 memset(no_packet, 0, nb_input_files);
2334 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2335 is->streams[pkt.stream_index]);
2337 /* the following test is needed in case new streams appear
2338 dynamically in stream : we ignore them */
2339 if (pkt.stream_index >= input_files[file_index].nb_streams)
2340 goto discard_packet;
2341 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2342 ist = &input_streams[ist_index];
2344 goto discard_packet;
2346 if (pkt.dts != AV_NOPTS_VALUE)
2347 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2348 if (pkt.pts != AV_NOPTS_VALUE)
2349 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2351 if (ist->ts_scale) {
2352 if(pkt.pts != AV_NOPTS_VALUE)
2353 pkt.pts *= ist->ts_scale;
2354 if(pkt.dts != AV_NOPTS_VALUE)
2355 pkt.dts *= ist->ts_scale;
2358 // 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);
2359 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2360 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2361 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2362 int64_t delta= pkt_dts - ist->next_pts;
2363 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2364 input_files[ist->file_index].ts_offset -= delta;
2366 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2367 delta, input_files[ist->file_index].ts_offset);
2368 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2369 if(pkt.pts != AV_NOPTS_VALUE)
2370 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2374 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2375 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2378 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2379 ist->file_index, ist->st->index);
2382 av_free_packet(&pkt);
2387 av_free_packet(&pkt);
2389 /* dump report by using the output first video and audio streams */
2390 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2393 /* at the end of stream, we must flush the decoder buffers */
2394 for (i = 0; i < nb_input_streams; i++) {
2395 ist = &input_streams[i];
2396 if (ist->decoding_needed) {
2397 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2400 flush_encoders(output_streams, nb_output_streams);
2404 /* write the trailer if needed and close file */
2405 for(i=0;i<nb_output_files;i++) {
2406 os = output_files[i].ctx;
2407 av_write_trailer(os);
2410 /* dump report by using the first video and audio streams */
2411 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2413 /* close each encoder */
2414 for (i = 0; i < nb_output_streams; i++) {
2415 ost = &output_streams[i];
2416 if (ost->encoding_needed) {
2417 av_freep(&ost->st->codec->stats_in);
2418 avcodec_close(ost->st->codec);
2421 avfilter_graph_free(&ost->graph);
2425 /* close each decoder */
2426 for (i = 0; i < nb_input_streams; i++) {
2427 ist = &input_streams[i];
2428 if (ist->decoding_needed) {
2429 avcodec_close(ist->st->codec);
2437 av_freep(&bit_buffer);
2438 av_freep(&no_packet);
2440 if (output_streams) {
2441 for (i = 0; i < nb_output_streams; i++) {
2442 ost = &output_streams[i];
2444 if (ost->st->stream_copy)
2445 av_freep(&ost->st->codec->extradata);
2447 fclose(ost->logfile);
2448 ost->logfile = NULL;
2450 av_fifo_free(ost->fifo); /* works even if fifo is not
2451 initialized but set to zero */
2452 av_freep(&ost->st->codec->subtitle_header);
2453 av_free(ost->pict_tmp.data[0]);
2454 av_free(ost->forced_kf_pts);
2455 if (ost->video_resample)
2456 sws_freeContext(ost->img_resample_ctx);
2458 audio_resample_close(ost->resample);
2459 if (ost->reformat_ctx)
2460 av_audio_convert_free(ost->reformat_ctx);
2461 av_dict_free(&ost->opts);
2468 static int opt_format(const char *opt, const char *arg)
2470 last_asked_format = arg;
2474 static int opt_video_rc_override_string(const char *opt, const char *arg)
2476 video_rc_override_string = arg;
2480 static int opt_me_threshold(const char *opt, const char *arg)
2482 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2486 static int opt_verbose(const char *opt, const char *arg)
2488 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2492 static int opt_frame_rate(const char *opt, const char *arg)
2494 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2495 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2501 static int opt_frame_size(const char *opt, const char *arg)
2503 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2504 fprintf(stderr, "Incorrect frame size\n");
2505 return AVERROR(EINVAL);
2510 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2512 if (strcmp(arg, "list")) {
2513 frame_pix_fmt = av_get_pix_fmt(arg);
2514 if (frame_pix_fmt == PIX_FMT_NONE) {
2515 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2516 return AVERROR(EINVAL);
2525 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2532 p = strchr(arg, ':');
2534 x = strtol(arg, &end, 10);
2536 y = strtol(end+1, &end, 10);
2538 ar = (double)x / (double)y;
2540 ar = strtod(arg, NULL);
2543 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2544 return AVERROR(EINVAL);
2546 frame_aspect_ratio = ar;
2550 static int opt_metadata(const char *opt, const char *arg)
2552 char *mid= strchr(arg, '=');
2555 fprintf(stderr, "Missing =\n");
2560 av_dict_set(&metadata, arg, mid, 0);
2565 static int opt_qscale(const char *opt, const char *arg)
2567 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2568 if (video_qscale == 0) {
2569 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2570 return AVERROR(EINVAL);
2575 static int opt_top_field_first(const char *opt, const char *arg)
2577 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2581 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2583 if (strcmp(arg, "list")) {
2584 audio_sample_fmt = av_get_sample_fmt(arg);
2585 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2586 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2587 return AVERROR(EINVAL);
2592 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2593 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2599 static int opt_audio_rate(const char *opt, const char *arg)
2601 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2605 static int opt_audio_channels(const char *opt, const char *arg)
2607 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2611 static int opt_codec(const char *opt, const char *arg)
2613 return av_dict_set(&codec_names, opt, arg, 0);
2616 static int opt_audio_codec(const char *opt, const char *arg)
2618 return opt_codec("codec:a", arg);
2621 static int opt_video_codec(const char *opt, const char *arg)
2623 return opt_codec("codec:v", arg);
2626 static int opt_subtitle_codec(const char *opt, const char *arg)
2628 return opt_codec("codec:s", arg);
2631 static int opt_data_codec(const char *opt, const char *arg)
2633 return opt_codec("codec:d", arg);
2636 static int opt_codec_tag(const char *opt, const char *arg)
2639 uint32_t *codec_tag;
2641 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2642 !strcmp(opt, "vtag") ? &video_codec_tag :
2643 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2647 *codec_tag = strtol(arg, &tail, 0);
2649 *codec_tag = AV_RL32(arg);
2654 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2656 StreamMap *m = NULL;
2657 int i, negative = 0, file_idx;
2658 int sync_file_idx = -1, sync_stream_idx;
2666 map = av_strdup(arg);
2668 /* parse sync stream first, just pick first matching stream */
2669 if (sync = strchr(map, ',')) {
2671 sync_file_idx = strtol(sync + 1, &sync, 0);
2672 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2673 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2678 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2679 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2680 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2681 sync_stream_idx = i;
2684 if (i == input_files[sync_file_idx].nb_streams) {
2685 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2686 "match any streams.\n", arg);
2692 file_idx = strtol(map, &p, 0);
2693 if (file_idx >= nb_input_files || file_idx < 0) {
2694 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2698 /* disable some already defined maps */
2699 for (i = 0; i < o->nb_stream_maps; i++) {
2700 m = &o->stream_maps[i];
2701 if (check_stream_specifier(input_files[m->file_index].ctx,
2702 input_files[m->file_index].ctx->streams[m->stream_index],
2703 *p == ':' ? p + 1 : p) > 0)
2707 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2708 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2709 *p == ':' ? p + 1 : p) <= 0)
2711 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2712 &o->nb_stream_maps, o->nb_stream_maps + 1);
2713 m = &o->stream_maps[o->nb_stream_maps - 1];
2715 m->file_index = file_idx;
2716 m->stream_index = i;
2718 if (sync_file_idx >= 0) {
2719 m->sync_file_index = sync_file_idx;
2720 m->sync_stream_index = sync_stream_idx;
2722 m->sync_file_index = file_idx;
2723 m->sync_stream_index = i;
2728 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2736 static void parse_meta_type(char *arg, char *type, int *index)
2746 if (*(++arg) == ':')
2747 *index = strtol(++arg, NULL, 0);
2750 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2757 static int opt_map_metadata(const char *opt, const char *arg)
2759 MetadataMap *m, *m1;
2762 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2763 &nb_meta_data_maps, nb_meta_data_maps + 1);
2765 m = &meta_data_maps[nb_meta_data_maps - 1][1];
2766 m->file = strtol(arg, &p, 0);
2767 parse_meta_type(p, &m->type, &m->index);
2769 m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2770 if (p = strchr(opt, ':'))
2771 parse_meta_type(p, &m1->type, &m1->index);
2775 if (m->type == 'g' || m1->type == 'g')
2776 metadata_global_autocopy = 0;
2777 if (m->type == 's' || m1->type == 's')
2778 metadata_streams_autocopy = 0;
2779 if (m->type == 'c' || m1->type == 'c')
2780 metadata_chapters_autocopy = 0;
2785 static int opt_input_ts_scale(const char *opt, const char *arg)
2787 return av_dict_set(&ts_scale, opt, arg, 0);
2790 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2792 const char *codec_string = encoder ? "encoder" : "decoder";
2796 return CODEC_ID_NONE;
2798 avcodec_find_encoder_by_name(name) :
2799 avcodec_find_decoder_by_name(name);
2801 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2804 if(codec->type != type) {
2805 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2811 static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
2813 AVDictionaryEntry *e = NULL;
2814 char *codec_name = NULL;
2817 while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
2818 char *p = strchr(e->key, ':');
2820 if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
2821 codec_name = e->value;
2828 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2829 return avcodec_find_encoder(st->codec->codec_id);
2831 } else if (!strcmp(codec_name, "copy"))
2832 st->stream_copy = 1;
2834 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2835 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2836 avcodec_find_decoder_by_name(codec_name);
2843 * Add all the streams from the given input file to the global
2844 * list of input streams.
2846 static void add_input_streams(AVFormatContext *ic)
2848 int i, rfps, rfps_base, ret;
2850 for (i = 0; i < ic->nb_streams; i++) {
2851 AVStream *st = ic->streams[i];
2852 AVCodecContext *dec = st->codec;
2853 AVDictionaryEntry *e = NULL;
2857 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2858 ist = &input_streams[nb_input_streams - 1];
2860 ist->file_index = nb_input_files;
2862 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2864 while (e = av_dict_get(ts_scale, "", e, AV_DICT_IGNORE_SUFFIX)) {
2865 char *p = strchr(e->key, ':');
2867 if ((ret = check_stream_specifier(ic, st, p ? p + 1 : "")) > 0)
2873 ist->ts_scale = strtod(scale, NULL);
2875 ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
2877 ist->dec = avcodec_find_decoder(dec->codec_id);
2879 switch (dec->codec_type) {
2880 case AVMEDIA_TYPE_AUDIO:
2882 st->discard= AVDISCARD_ALL;
2884 case AVMEDIA_TYPE_VIDEO:
2885 rfps = ic->streams[i]->r_frame_rate.num;
2886 rfps_base = ic->streams[i]->r_frame_rate.den;
2888 dec->flags |= CODEC_FLAG_EMU_EDGE;
2889 dec->height >>= dec->lowres;
2890 dec->width >>= dec->lowres;
2893 dec->debug |= FF_DEBUG_MV;
2895 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2898 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2899 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2901 (float)rfps / rfps_base, rfps, rfps_base);
2905 st->discard= AVDISCARD_ALL;
2906 else if(video_discard)
2907 st->discard= video_discard;
2909 case AVMEDIA_TYPE_DATA:
2911 case AVMEDIA_TYPE_SUBTITLE:
2912 if(subtitle_disable)
2913 st->discard = AVDISCARD_ALL;
2915 case AVMEDIA_TYPE_ATTACHMENT:
2916 case AVMEDIA_TYPE_UNKNOWN:
2924 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2926 AVFormatContext *ic;
2927 AVInputFormat *file_iformat = NULL;
2931 AVDictionary **opts;
2932 int orig_nb_streams; // number of streams before avformat_find_stream_info
2934 if (last_asked_format) {
2935 if (!(file_iformat = av_find_input_format(last_asked_format))) {
2936 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
2939 last_asked_format = NULL;
2942 if (!strcmp(filename, "-"))
2945 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2946 !strcmp(filename, "/dev/stdin");
2948 /* get default parameters from command line */
2949 ic = avformat_alloc_context();
2951 print_error(filename, AVERROR(ENOMEM));
2954 if (audio_sample_rate) {
2955 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
2956 av_dict_set(&format_opts, "sample_rate", buf, 0);
2958 if (audio_channels) {
2959 snprintf(buf, sizeof(buf), "%d", audio_channels);
2960 av_dict_set(&format_opts, "channels", buf, 0);
2962 if (frame_rate.num) {
2963 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
2964 av_dict_set(&format_opts, "framerate", buf, 0);
2966 if (frame_width && frame_height) {
2967 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
2968 av_dict_set(&format_opts, "video_size", buf, 0);
2970 if (frame_pix_fmt != PIX_FMT_NONE)
2971 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
2973 ic->flags |= AVFMT_FLAG_NONBLOCK;
2975 /* open the input file with generic libav function */
2976 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2978 print_error(filename, err);
2981 assert_avoptions(format_opts);
2986 for(i=0; i<ic->nb_streams; i++){
2987 ic->streams[i]->discard= AVDISCARD_ALL;
2989 for(i=0; i<ic->nb_programs; i++){
2990 AVProgram *p= ic->programs[i];
2991 if(p->id != opt_programid){
2992 p->discard = AVDISCARD_ALL;
2995 for(j=0; j<p->nb_stream_indexes; j++){
2996 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3001 fprintf(stderr, "Specified program id not found\n");
3007 /* apply forced codec ids */
3008 for (i = 0; i < ic->nb_streams; i++)
3009 choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
3011 /* Set AVCodecContext options for avformat_find_stream_info */
3012 opts = setup_find_stream_info_opts(ic, codec_opts);
3013 orig_nb_streams = ic->nb_streams;
3015 /* If not enough info to get the stream parameters, we decode the
3016 first frames to get it. (used in mpeg case for example) */
3017 ret = avformat_find_stream_info(ic, opts);
3018 if (ret < 0 && verbose >= 0) {
3019 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3020 av_close_input_file(ic);
3024 timestamp = o->start_time;
3025 /* add the stream start time */
3026 if (ic->start_time != AV_NOPTS_VALUE)
3027 timestamp += ic->start_time;
3029 /* if seeking requested, we execute it */
3030 if (o->start_time != 0) {
3031 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3033 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3034 filename, (double)timestamp / AV_TIME_BASE);
3038 /* update the current parameters so that they match the one of the input stream */
3039 add_input_streams(ic);
3041 /* dump the file content */
3043 av_dump_format(ic, nb_input_files, filename, 0);
3045 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3046 input_files[nb_input_files - 1].ctx = ic;
3047 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3048 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3049 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3051 frame_rate = (AVRational){0, 0};
3052 frame_pix_fmt = PIX_FMT_NONE;
3055 audio_sample_rate = 0;
3057 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3058 av_dict_free(&ts_scale);
3060 for (i = 0; i < orig_nb_streams; i++)
3061 av_dict_free(&opts[i]);
3063 av_dict_free(&codec_names);
3069 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3070 AVCodecContext *avctx)
3076 for (p = kf; *p; p++)
3079 ost->forced_kf_count = n;
3080 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3081 if (!ost->forced_kf_pts) {
3082 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3085 for (i = 0; i < n; i++) {
3086 p = i ? strchr(p, ',') + 1 : kf;
3087 t = parse_time_or_die("force_key_frames", p, 1);
3088 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3092 static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
3095 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3096 int idx = oc->nb_streams - 1;
3099 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3103 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3104 nb_output_streams + 1);
3105 ost = &output_streams[nb_output_streams - 1];
3106 ost->file_index = nb_output_files;
3109 st->codec->codec_type = type;
3110 ost->enc = choose_codec(oc, st, type, codec_names);
3112 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3115 avcodec_get_context_defaults3(st->codec, ost->enc);
3116 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3118 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3122 static OutputStream *new_video_stream(AVFormatContext *oc)
3126 AVCodecContext *video_enc;
3128 ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
3130 if (!st->stream_copy) {
3131 ost->frame_aspect_ratio = frame_aspect_ratio;
3132 frame_aspect_ratio = 0;
3134 ost->avfilter= vfilters;
3139 ost->bitstream_filters = video_bitstream_filters;
3140 video_bitstream_filters= NULL;
3142 video_enc = st->codec;
3145 video_enc->codec_tag= video_codec_tag;
3147 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3148 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3151 if (st->stream_copy) {
3152 video_enc->sample_aspect_ratio =
3153 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3159 ost->frame_rate = frame_rate;
3161 video_enc->width = frame_width;
3162 video_enc->height = frame_height;
3163 video_enc->pix_fmt = frame_pix_fmt;
3164 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3166 if (video_qscale || same_quant) {
3167 video_enc->flags |= CODEC_FLAG_QSCALE;
3168 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3172 video_enc->intra_matrix = intra_matrix;
3174 video_enc->inter_matrix = inter_matrix;
3176 p= video_rc_override_string;
3179 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3181 fprintf(stderr, "error parsing rc_override\n");
3184 video_enc->rc_override=
3185 av_realloc(video_enc->rc_override,
3186 sizeof(RcOverride)*(i+1));
3187 video_enc->rc_override[i].start_frame= start;
3188 video_enc->rc_override[i].end_frame = end;
3190 video_enc->rc_override[i].qscale= q;
3191 video_enc->rc_override[i].quality_factor= 1.0;
3194 video_enc->rc_override[i].qscale= 0;
3195 video_enc->rc_override[i].quality_factor= -q/100.0;
3200 video_enc->rc_override_count=i;
3201 if (!video_enc->rc_initial_buffer_occupancy)
3202 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3203 video_enc->me_threshold= me_threshold;
3204 video_enc->intra_dc_precision= intra_dc_precision - 8;
3207 video_enc->flags|= CODEC_FLAG_PSNR;
3212 video_enc->flags |= CODEC_FLAG_PASS1;
3214 video_enc->flags |= CODEC_FLAG_PASS2;
3218 if (forced_key_frames)
3219 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3221 if (video_language) {
3222 av_dict_set(&st->metadata, "language", video_language, 0);
3223 av_freep(&video_language);
3226 /* reset some key parameters */
3228 av_freep(&forced_key_frames);
3229 frame_pix_fmt = PIX_FMT_NONE;
3233 static OutputStream *new_audio_stream(AVFormatContext *oc)
3237 AVCodecContext *audio_enc;
3239 ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
3242 ost->bitstream_filters = audio_bitstream_filters;
3243 audio_bitstream_filters= NULL;
3245 audio_enc = st->codec;
3246 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3249 audio_enc->codec_tag= audio_codec_tag;
3251 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3252 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3254 if (!st->stream_copy) {
3255 if (audio_qscale > QSCALE_NONE) {
3256 audio_enc->flags |= CODEC_FLAG_QSCALE;
3257 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3260 audio_enc->channels = audio_channels;
3261 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3262 audio_enc->sample_fmt = audio_sample_fmt;
3263 if (audio_sample_rate)
3264 audio_enc->sample_rate = audio_sample_rate;
3266 if (audio_language) {
3267 av_dict_set(&st->metadata, "language", audio_language, 0);
3268 av_freep(&audio_language);
3271 /* reset some key parameters */
3277 static OutputStream *new_data_stream(AVFormatContext *oc)
3281 AVCodecContext *data_enc;
3283 ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
3285 data_enc = st->codec;
3286 if (!st->stream_copy) {
3287 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3292 data_enc->codec_tag= data_codec_tag;
3294 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3295 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3302 static OutputStream *new_subtitle_stream(AVFormatContext *oc)
3306 AVCodecContext *subtitle_enc;
3308 ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
3310 subtitle_enc = st->codec;
3312 ost->bitstream_filters = subtitle_bitstream_filters;
3313 subtitle_bitstream_filters= NULL;
3315 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3317 if(subtitle_codec_tag)
3318 subtitle_enc->codec_tag= subtitle_codec_tag;
3320 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3321 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3324 if (subtitle_language) {
3325 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3326 av_freep(&subtitle_language);
3329 subtitle_disable = 0;
3333 /* arg format is "output-stream-index:streamid-value". */
3334 static int opt_streamid(const char *opt, const char *arg)
3340 av_strlcpy(idx_str, arg, sizeof(idx_str));
3341 p = strchr(idx_str, ':');
3344 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3349 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3350 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3351 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3355 static int copy_chapters(InputFile *ifile, OutputFile *ofile)
3357 AVFormatContext *is = ifile->ctx;
3358 AVFormatContext *os = ofile->ctx;
3361 for (i = 0; i < is->nb_chapters; i++) {
3362 AVChapter *in_ch = is->chapters[i], *out_ch;
3363 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3364 AV_TIME_BASE_Q, in_ch->time_base);
3365 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3366 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3369 if (in_ch->end < ts_off)
3371 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3374 out_ch = av_mallocz(sizeof(AVChapter));
3376 return AVERROR(ENOMEM);
3378 out_ch->id = in_ch->id;
3379 out_ch->time_base = in_ch->time_base;
3380 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3381 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3383 if (metadata_chapters_autocopy)
3384 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3387 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3389 return AVERROR(ENOMEM);
3390 os->chapters[os->nb_chapters - 1] = out_ch;
3395 static int read_avserver_streams(AVFormatContext *s, const char *filename)
3398 AVFormatContext *ic = NULL;
3400 err = avformat_open_input(&ic, filename, NULL, NULL);
3403 /* copy stream format */
3404 for(i=0;i<ic->nb_streams;i++) {
3409 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3410 ost = new_output_stream(s, codec->type);
3413 // FIXME: a more elegant solution is needed
3414 memcpy(st, ic->streams[i], sizeof(AVStream));
3416 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3418 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3419 choose_sample_fmt(st, codec);
3420 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3421 choose_pixel_fmt(st, codec);
3424 av_close_input_file(ic);
3428 static void opt_output_file(void *optctx, const char *filename)
3430 OptionsContext *o = optctx;
3431 AVFormatContext *oc;
3433 AVOutputFormat *file_oformat;
3437 if (!strcmp(filename, "-"))
3440 oc = avformat_alloc_context();
3442 print_error(filename, AVERROR(ENOMEM));
3446 if (last_asked_format) {
3447 file_oformat = av_guess_format(last_asked_format, NULL, NULL);
3448 if (!file_oformat) {
3449 fprintf(stderr, "Requested output format '%s' is not a suitable output format\n", last_asked_format);
3452 last_asked_format = NULL;
3454 file_oformat = av_guess_format(NULL, filename, NULL);
3455 if (!file_oformat) {
3456 fprintf(stderr, "Unable to find a suitable output format for '%s'\n",
3462 oc->oformat = file_oformat;
3463 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3465 if (!strcmp(file_oformat->name, "ffm") &&
3466 av_strstart(filename, "http:", NULL)) {
3467 /* special case for files sent to avserver: we get the stream
3468 parameters from avserver */
3469 int err = read_avserver_streams(oc, filename);
3471 print_error(filename, err);
3474 } else if (!o->nb_stream_maps) {
3475 /* pick the "best" stream of each type */
3476 #define NEW_STREAM(type, index)\
3478 ost = new_ ## type ## _stream(oc);\
3479 ost->source_index = index;\
3480 ost->sync_ist = &input_streams[index];\
3481 input_streams[index].discard = 0;\
3484 /* video: highest resolution */
3485 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3486 int area = 0, idx = -1;
3487 for (i = 0; i < nb_input_streams; i++) {
3488 ist = &input_streams[i];
3489 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3490 ist->st->codec->width * ist->st->codec->height > area) {
3491 area = ist->st->codec->width * ist->st->codec->height;
3495 NEW_STREAM(video, idx);
3498 /* audio: most channels */
3499 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3500 int channels = 0, idx = -1;
3501 for (i = 0; i < nb_input_streams; i++) {
3502 ist = &input_streams[i];
3503 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3504 ist->st->codec->channels > channels) {
3505 channels = ist->st->codec->channels;
3509 NEW_STREAM(audio, idx);
3512 /* subtitles: pick first */
3513 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3514 for (i = 0; i < nb_input_streams; i++)
3515 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3516 NEW_STREAM(subtitle, i);
3520 /* do something with data? */
3522 for (i = 0; i < o->nb_stream_maps; i++) {
3523 StreamMap *map = &o->stream_maps[i];
3528 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3529 switch (ist->st->codec->codec_type) {
3530 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(oc); break;
3531 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(oc); break;
3532 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3533 case AVMEDIA_TYPE_DATA: ost = new_data_stream(oc); break;
3535 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3536 map->file_index, map->stream_index);
3540 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3541 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3542 map->sync_stream_index];
3547 av_dict_copy(&oc->metadata, metadata, 0);
3548 av_dict_free(&metadata);
3551 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3552 output_files[nb_output_files - 1].ctx = oc;
3553 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3554 output_files[nb_output_files - 1].recording_time = o->recording_time;
3555 output_files[nb_output_files - 1].start_time = o->start_time;
3556 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3557 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3559 /* check filename in case of an image number is expected */
3560 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3561 if (!av_filename_number_test(oc->filename)) {
3562 print_error(oc->filename, AVERROR(EINVAL));
3567 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3568 /* test if it already exists to avoid loosing precious files */
3569 if (!file_overwrite &&
3570 (strchr(filename, ':') == NULL ||
3571 filename[1] == ':' ||
3572 av_strstart(filename, "file:", NULL))) {
3573 if (avio_check(filename, 0) == 0) {
3575 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3577 if (!read_yesno()) {
3578 fprintf(stderr, "Not overwriting - exiting\n");
3583 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3590 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3591 print_error(filename, err);
3596 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3597 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3598 oc->flags |= AVFMT_FLAG_NONBLOCK;
3601 if (chapters_input_file >= nb_input_files) {
3602 if (chapters_input_file == INT_MAX) {
3603 /* copy chapters from the first input file that has them*/
3604 chapters_input_file = -1;
3605 for (i = 0; i < nb_input_files; i++)
3606 if (input_files[i].ctx->nb_chapters) {
3607 chapters_input_file = i;
3611 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3612 chapters_input_file);
3616 if (chapters_input_file >= 0)
3617 copy_chapters(&input_files[chapters_input_file], &output_files[nb_output_files - 1]);
3620 for (i = 0; i < nb_meta_data_maps; i++) {
3621 AVFormatContext *files[2];
3622 AVDictionary **meta[2];
3625 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3626 if ((index) < 0 || (index) >= (nb_elems)) {\
3627 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3632 int in_file_index = meta_data_maps[i][1].file;
3633 if (in_file_index < 0)
3635 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3638 files[1] = input_files[in_file_index].ctx;
3640 for (j = 0; j < 2; j++) {
3641 MetadataMap *map = &meta_data_maps[i][j];
3643 switch (map->type) {
3645 meta[j] = &files[j]->metadata;
3648 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3649 meta[j] = &files[j]->streams[map->index]->metadata;
3652 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3653 meta[j] = &files[j]->chapters[map->index]->metadata;
3656 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3657 meta[j] = &files[j]->programs[map->index]->metadata;
3662 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3665 /* copy global metadata by default */
3666 if (metadata_global_autocopy && nb_input_files)
3667 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3668 AV_DICT_DONT_OVERWRITE);
3669 if (metadata_streams_autocopy)
3670 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3671 InputStream *ist = &input_streams[output_streams[i].source_index];
3672 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3675 frame_rate = (AVRational){0, 0};
3678 audio_sample_rate = 0;
3680 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3681 chapters_input_file = INT_MAX;
3683 av_freep(&meta_data_maps);
3684 nb_meta_data_maps = 0;
3685 metadata_global_autocopy = 1;
3686 metadata_streams_autocopy = 1;
3687 metadata_chapters_autocopy = 1;
3688 av_freep(&streamid_map);
3689 nb_streamid_map = 0;
3691 av_dict_free(&codec_names);
3693 av_freep(&forced_key_frames);
3697 /* same option as mencoder */
3698 static int opt_pass(const char *opt, const char *arg)
3700 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3704 static int64_t getutime(void)
3707 struct rusage rusage;
3709 getrusage(RUSAGE_SELF, &rusage);
3710 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3711 #elif HAVE_GETPROCESSTIMES
3713 FILETIME c, e, k, u;
3714 proc = GetCurrentProcess();
3715 GetProcessTimes(proc, &c, &e, &k, &u);
3716 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3718 return av_gettime();
3722 static int64_t getmaxrss(void)
3724 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3725 struct rusage rusage;
3726 getrusage(RUSAGE_SELF, &rusage);
3727 return (int64_t)rusage.ru_maxrss * 1024;
3728 #elif HAVE_GETPROCESSMEMORYINFO
3730 PROCESS_MEMORY_COUNTERS memcounters;
3731 proc = GetCurrentProcess();
3732 memcounters.cb = sizeof(memcounters);
3733 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3734 return memcounters.PeakPagefileUsage;
3740 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3743 const char *p = str;
3750 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3757 static void opt_inter_matrix(const char *arg)
3759 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3760 parse_matrix_coeffs(inter_matrix, arg);
3763 static void opt_intra_matrix(const char *arg)
3765 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3766 parse_matrix_coeffs(intra_matrix, arg);
3769 static void show_usage(void)
3771 printf("Hyper fast Audio and Video encoder\n");
3772 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3776 static void show_help(void)
3779 AVOutputFormat *oformat = NULL;
3780 AVInputFormat *iformat = NULL;
3781 const AVClass *class;
3783 av_log_set_callback(log_callback_help);
3785 show_help_options(options, "Main options:\n",
3786 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3787 show_help_options(options, "\nAdvanced options:\n",
3788 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3790 show_help_options(options, "\nVideo options:\n",
3791 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3793 show_help_options(options, "\nAdvanced Video options:\n",
3794 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3795 OPT_VIDEO | OPT_EXPERT);
3796 show_help_options(options, "\nAudio options:\n",
3797 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3799 show_help_options(options, "\nAdvanced Audio options:\n",
3800 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3801 OPT_AUDIO | OPT_EXPERT);
3802 show_help_options(options, "\nSubtitle options:\n",
3803 OPT_SUBTITLE | OPT_GRAB,
3805 show_help_options(options, "\nAudio/Video grab options:\n",
3809 class = avcodec_get_class();
3810 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3813 /* individual codec options */
3815 while ((c = av_codec_next(c))) {
3816 if (c->priv_class) {
3817 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3822 class = avformat_get_class();
3823 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3826 /* individual muxer options */
3827 while ((oformat = av_oformat_next(oformat))) {
3828 if (oformat->priv_class) {
3829 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3834 /* individual demuxer options */
3835 while ((iformat = av_iformat_next(iformat))) {
3836 if (iformat->priv_class) {
3837 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3842 class = sws_get_class();
3843 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3846 static int opt_target(const char *opt, const char *arg)
3848 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3849 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3851 if(!strncmp(arg, "pal-", 4)) {
3854 } else if(!strncmp(arg, "ntsc-", 5)) {
3857 } else if(!strncmp(arg, "film-", 5)) {
3862 /* Calculate FR via float to avoid int overflow */
3863 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3866 } else if((fr == 29970) || (fr == 23976)) {
3869 /* Try to determine PAL/NTSC by peeking in the input files */
3870 if(nb_input_files) {
3872 for (j = 0; j < nb_input_files; j++) {
3873 for (i = 0; i < input_files[j].nb_streams; i++) {
3874 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3875 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3877 fr = c->time_base.den * 1000 / c->time_base.num;
3881 } else if((fr == 29970) || (fr == 23976)) {
3891 if(verbose > 0 && norm != UNKNOWN)
3892 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3895 if(norm == UNKNOWN) {
3896 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3897 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3898 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3902 if(!strcmp(arg, "vcd")) {
3903 opt_codec("c:v", "mpeg1video");
3904 opt_codec("c:a", "mp2");
3905 opt_format("f", "vcd");
3907 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
3908 opt_frame_rate("r", frame_rates[norm]);
3909 opt_default("g", norm == PAL ? "15" : "18");
3911 opt_default("b", "1150000");
3912 opt_default("maxrate", "1150000");
3913 opt_default("minrate", "1150000");
3914 opt_default("bufsize", "327680"); // 40*1024*8;
3916 opt_default("b:a", "224000");
3917 audio_sample_rate = 44100;
3920 opt_default("packetsize", "2324");
3921 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3923 /* We have to offset the PTS, so that it is consistent with the SCR.
3924 SCR starts at 36000, but the first two packs contain only padding
3925 and the first pack from the other stream, respectively, may also have
3926 been written before.
3927 So the real data starts at SCR 36000+3*1200. */
3928 mux_preload= (36000+3*1200) / 90000.0; //0.44
3929 } else if(!strcmp(arg, "svcd")) {
3931 opt_codec("c:v", "mpeg2video");
3932 opt_codec("c:a", "mp2");
3933 opt_format("f", "svcd");
3935 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
3936 opt_frame_rate("r", frame_rates[norm]);
3937 opt_default("g", norm == PAL ? "15" : "18");
3939 opt_default("b", "2040000");
3940 opt_default("maxrate", "2516000");
3941 opt_default("minrate", "0"); //1145000;
3942 opt_default("bufsize", "1835008"); //224*1024*8;
3943 opt_default("flags", "+scan_offset");
3946 opt_default("b:a", "224000");
3947 audio_sample_rate = 44100;
3949 opt_default("packetsize", "2324");
3951 } else if(!strcmp(arg, "dvd")) {
3953 opt_codec("c:v", "mpeg2video");
3954 opt_codec("c:a", "ac3");
3955 opt_format("f", "dvd");
3957 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
3958 opt_frame_rate("r", frame_rates[norm]);
3959 opt_default("g", norm == PAL ? "15" : "18");
3961 opt_default("b", "6000000");
3962 opt_default("maxrate", "9000000");
3963 opt_default("minrate", "0"); //1500000;
3964 opt_default("bufsize", "1835008"); //224*1024*8;
3966 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3967 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3969 opt_default("b:a", "448000");
3970 audio_sample_rate = 48000;
3972 } else if(!strncmp(arg, "dv", 2)) {
3974 opt_format("f", "dv");
3976 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
3977 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3978 norm == PAL ? "yuv420p" : "yuv411p");
3979 opt_frame_rate("r", frame_rates[norm]);
3981 audio_sample_rate = 48000;
3985 fprintf(stderr, "Unknown target: %s\n", arg);
3986 return AVERROR(EINVAL);
3991 static int opt_vstats_file(const char *opt, const char *arg)
3993 av_free (vstats_filename);
3994 vstats_filename=av_strdup (arg);
3998 static int opt_vstats(const char *opt, const char *arg)
4001 time_t today2 = time(NULL);
4002 struct tm *today = localtime(&today2);
4004 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4006 return opt_vstats_file(opt, filename);
4009 static int opt_bsf(const char *opt, const char *arg)
4011 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4012 AVBitStreamFilterContext **bsfp;
4015 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4019 bsfp= *opt == 'v' ? &video_bitstream_filters :
4020 *opt == 'a' ? &audio_bitstream_filters :
4021 &subtitle_bitstream_filters;
4023 bsfp= &(*bsfp)->next;
4030 #define OFFSET(x) offsetof(OptionsContext, x)
4031 static const OptionDef options[] = {
4033 #include "cmdutils_common_opts.h"
4034 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4035 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4036 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4037 { "c", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4038 { "codec", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4039 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4040 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4041 "outfile[,metadata]:infile[,metadata]" },
4042 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file}, "set chapters mapping", "input_file_index" },
4043 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4044 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4045 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4046 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4047 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "scale" },
4048 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4049 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4050 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4051 "add timings for benchmarking" },
4052 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4053 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4054 "dump each input packet" },
4055 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4056 "when dumping packets, also dump the payload" },
4057 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4058 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4059 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4060 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4061 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4062 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4063 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4064 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4065 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4066 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4067 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4068 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4069 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4072 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4073 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4074 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4075 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4076 { "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" },
4077 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4078 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4079 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4080 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4081 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4082 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold", "threshold" },
4083 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4084 "use same quantizer as source (implies VBR)" },
4085 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4086 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4087 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4088 "deinterlace pictures" },
4089 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4090 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4091 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4093 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4095 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4096 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4097 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4098 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4099 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4100 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4101 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4102 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4103 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4104 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4107 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4108 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4109 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4110 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4111 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4112 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4113 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4114 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4115 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4116 { "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" },
4118 /* subtitle options */
4119 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4120 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4121 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4122 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4125 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4128 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4129 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4131 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4132 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4133 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4135 /* data codec support */
4136 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4138 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4142 int main(int argc, char **argv)
4144 OptionsContext o = { 0 };
4149 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4151 avcodec_register_all();
4153 avdevice_register_all();
4156 avfilter_register_all();
4160 avio_set_interrupt_cb(decode_interrupt_cb);
4165 parse_options(&o, argc, argv, options, opt_output_file);
4167 if(nb_output_files <= 0 && nb_input_files == 0) {
4169 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4173 /* file converter / grab */
4174 if (nb_output_files <= 0) {
4175 fprintf(stderr, "At least one output file must be specified\n");
4179 if (nb_input_files == 0) {
4180 fprintf(stderr, "At least one input file must be specified\n");
4185 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4187 ti = getutime() - ti;
4189 int maxrss = getmaxrss() / 1024;
4190 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);