3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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"
49 #include "libavformat/ffm.h" // not public API
52 # include "libavfilter/avcodec.h"
53 # include "libavfilter/avfilter.h"
54 # include "libavfilter/avfiltergraph.h"
55 # include "libavfilter/buffersink.h"
56 # include "libavfilter/vsrc_buffer.h"
59 #if HAVE_SYS_RESOURCE_H
60 #include <sys/types.h>
62 #include <sys/resource.h>
63 #elif HAVE_GETPROCESSTIMES
66 #if HAVE_GETPROCESSMEMORYINFO
72 #include <sys/select.h>
77 #include <sys/ioctl.h>
87 #include "libavutil/avassert.h"
89 const char program_name[] = "avconv";
90 const int program_birth_year = 2000;
92 /* select an input stream for an output stream */
93 typedef struct StreamMap {
94 int disabled; /** 1 is this mapping is disabled by a negative map */
98 int sync_stream_index;
102 * select an input file for an output file
104 typedef struct MetadataMap {
105 int file; ///< file index
106 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
107 int index; ///< stream/chapter/program number
110 static const OptionDef options[];
112 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
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 int frame_bits_per_raw_sample = 0;
123 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
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 int file_overwrite = 0;
159 static int do_benchmark = 0;
160 static int do_hex_dump = 0;
161 static int do_pkt_dump = 0;
162 static int do_psnr = 0;
163 static int do_pass = 0;
164 static const char *pass_logfilename_prefix;
165 static int video_sync_method= -1;
166 static int audio_sync_method= 0;
167 static float audio_drift_threshold= 0.1;
168 static int copy_ts= 0;
169 static int copy_tb= 0;
170 static int opt_shortest = 0;
171 static char *vstats_filename;
172 static FILE *vstats_file;
173 static int opt_programid = 0;
174 static int copy_initial_nonkeyframes = 0;
176 static int audio_volume = 256;
178 static int exit_on_error = 0;
179 static int using_stdin = 0;
180 static int verbose = 1;
181 static int run_as_daemon = 0;
182 static int q_pressed = 0;
183 static int64_t video_size = 0;
184 static int64_t audio_size = 0;
185 static int64_t extra_size = 0;
186 static int nb_frames_dup = 0;
187 static int nb_frames_drop = 0;
188 static int input_sync;
189 static int force_fps = 0;
190 static char *forced_key_frames = NULL;
192 static float dts_delta_threshold = 10;
194 static uint8_t *audio_buf;
195 static uint8_t *audio_out;
196 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
198 static short *samples;
200 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
202 typedef struct InputStream {
205 int discard; /* true if stream data should be discarded */
206 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
209 int64_t start; /* time when read started */
210 int64_t next_pts; /* synthetic pts for cases where pkt.pts
212 int64_t pts; /* current pts */
214 int is_start; /* is 1 at the start and after a discontinuity */
215 int showed_multi_packet_warning;
219 typedef struct InputFile {
220 AVFormatContext *ctx;
221 int eof_reached; /* true if eof reached */
222 int ist_index; /* index of first stream in ist_table */
223 int buffer_size; /* current total buffer size */
225 int nb_streams; /* number of stream that avconv is aware of; may be different
226 from ctx.nb_streams if new streams appear during av_read_frame() */
230 typedef struct OutputStream {
231 int file_index; /* file index */
232 int index; /* stream index in the output file */
233 int source_index; /* InputStream index */
234 AVStream *st; /* stream in the output file */
235 int encoding_needed; /* true if encoding needed for this stream */
237 /* input pts and corresponding output pts
239 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
240 struct InputStream *sync_ist; /* input stream to sync against */
241 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
242 AVBitStreamFilterContext *bitstream_filters;
248 AVFrame resample_frame; /* temporary frame for image resampling */
249 struct SwsContext *img_resample_ctx; /* for image resampling */
252 int resample_pix_fmt;
253 AVRational frame_rate;
255 float frame_aspect_ratio;
257 /* forced key frames */
258 int64_t *forced_kf_pts;
264 ReSampleContext *resample; /* for audio resampling */
265 int resample_sample_fmt;
266 int resample_channels;
267 int resample_sample_rate;
269 AVAudioConvert *reformat_ctx;
270 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
274 AVFilterContext *output_video_filter;
275 AVFilterContext *input_video_filter;
276 AVFilterBufferRef *picref;
278 AVFilterGraph *graph;
283 int is_past_recording_time;
288 /* init terminal so that we can grab keys */
289 static struct termios oldtty;
292 typedef struct OutputFile {
293 AVFormatContext *ctx;
295 int ost_index; /* index of the first stream in output_streams */
296 int64_t recording_time; /* desired length of the resulting file in microseconds */
297 int64_t start_time; /* start time in microseconds */
298 uint64_t limit_filesize;
301 static InputStream *input_streams = NULL;
302 static int nb_input_streams = 0;
303 static InputFile *input_files = NULL;
304 static int nb_input_files = 0;
306 static OutputStream *output_streams = NULL;
307 static int nb_output_streams = 0;
308 static OutputFile *output_files = NULL;
309 static int nb_output_files = 0;
311 typedef struct OptionsContext {
312 /* input/output options */
316 SpecifierOpt *codec_names;
320 int64_t input_ts_offset;
323 SpecifierOpt *ts_scale;
327 StreamMap *stream_maps;
329 /* first item specifies output metadata, second is input */
330 MetadataMap (*meta_data_maps)[2];
331 int nb_meta_data_maps;
332 int metadata_global_manual;
333 int metadata_streams_manual;
334 int metadata_chapters_manual;
336 int chapters_input_file;
338 int64_t recording_time;
339 uint64_t limit_filesize;
343 SpecifierOpt *metadata;
345 SpecifierOpt *max_frames;
347 SpecifierOpt *bitstream_filters;
348 int nb_bitstream_filters;
351 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
354 for (i = 0; i < o->nb_ ## name; i++) {\
355 char *spec = o->name[i].specifier;\
356 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
357 outvar = o->name[i].u.type;\
363 static void reset_options(OptionsContext *o)
365 const OptionDef *po = options;
367 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
369 void *dst = (uint8_t*)o + po->u.off;
371 if (po->flags & OPT_SPEC) {
372 SpecifierOpt **so = dst;
373 int i, *count = (int*)(so + 1);
374 for (i = 0; i < *count; i++) {
375 av_freep(&(*so)[i].specifier);
376 if (po->flags & OPT_STRING)
377 av_freep(&(*so)[i].u.str);
381 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
386 av_freep(&o->stream_maps);
387 av_freep(&o->meta_data_maps);
389 memset(o, 0, sizeof(*o));
391 o->mux_preload = 0.5;
392 o->mux_max_delay = 0.7;
393 o->recording_time = INT64_MAX;
394 o->limit_filesize = UINT64_MAX;
395 o->chapters_input_file = INT_MAX;
403 static int configure_video_filters(InputStream *ist, OutputStream *ost)
405 AVFilterContext *last_filter, *filter;
406 /** filter graph containing all filters including input & output */
407 AVCodecContext *codec = ost->st->codec;
408 AVCodecContext *icodec = ist->st->codec;
409 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
410 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
411 AVRational sample_aspect_ratio;
415 ost->graph = avfilter_graph_alloc();
417 if (ist->st->sample_aspect_ratio.num){
418 sample_aspect_ratio = ist->st->sample_aspect_ratio;
420 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
422 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
423 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
424 sample_aspect_ratio.num, sample_aspect_ratio.den);
426 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
427 "src", args, NULL, ost->graph);
430 #if FF_API_OLD_VSINK_API
431 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
432 "out", NULL, pix_fmts, ost->graph);
434 buffersink_params->pixel_fmts = pix_fmts;
435 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
436 "out", NULL, buffersink_params, ost->graph);
438 av_freep(&buffersink_params);
441 last_filter = ost->input_video_filter;
443 if (codec->width != icodec->width || codec->height != icodec->height) {
444 snprintf(args, 255, "%d:%d:flags=0x%X",
448 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
449 NULL, args, NULL, ost->graph)) < 0)
451 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
453 last_filter = filter;
456 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
457 ost->graph->scale_sws_opts = av_strdup(args);
460 AVFilterInOut *outputs = avfilter_inout_alloc();
461 AVFilterInOut *inputs = avfilter_inout_alloc();
463 outputs->name = av_strdup("in");
464 outputs->filter_ctx = last_filter;
465 outputs->pad_idx = 0;
466 outputs->next = NULL;
468 inputs->name = av_strdup("out");
469 inputs->filter_ctx = ost->output_video_filter;
473 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
475 av_freep(&ost->avfilter);
477 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
481 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
484 codec->width = ost->output_video_filter->inputs[0]->w;
485 codec->height = ost->output_video_filter->inputs[0]->h;
486 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
487 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
488 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
489 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
493 #endif /* CONFIG_AVFILTER */
495 static void term_exit(void)
497 av_log(NULL, AV_LOG_QUIET, "%s", "");
500 tcsetattr (0, TCSANOW, &oldtty);
504 static volatile int received_sigterm = 0;
507 sigterm_handler(int sig)
509 received_sigterm = sig;
514 static void term_init(void)
524 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
525 |INLCR|IGNCR|ICRNL|IXON);
526 tty.c_oflag |= OPOST;
527 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
528 tty.c_cflag &= ~(CSIZE|PARENB);
533 tcsetattr (0, TCSANOW, &tty);
534 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
538 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
539 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
541 signal(SIGXCPU, sigterm_handler);
545 /* read a key without blocking */
546 static int read_key(void)
561 n = select(1, &rfds, NULL, NULL, &tv);
576 static int decode_interrupt_cb(void)
578 q_pressed += read_key() == 'q';
579 return q_pressed > 1;
582 void exit_program(int ret)
587 for(i=0;i<nb_output_files;i++) {
588 AVFormatContext *s = output_files[i].ctx;
589 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
591 avformat_free_context(s);
592 av_dict_free(&output_files[i].opts);
594 for(i=0;i<nb_input_files;i++) {
595 av_close_input_file(input_files[i].ctx);
597 for (i = 0; i < nb_input_streams; i++)
598 av_dict_free(&input_streams[i].opts);
600 av_free(intra_matrix);
601 av_free(inter_matrix);
605 av_free(vstats_filename);
607 av_freep(&input_streams);
608 av_freep(&input_files);
609 av_freep(&output_streams);
610 av_freep(&output_files);
615 allocated_audio_buf_size= allocated_audio_out_size= 0;
622 if (received_sigterm) {
624 "Received signal %d: terminating.\n",
625 (int) received_sigterm);
629 exit(ret); /* not all OS-es handle main() return value */
632 static void assert_avoptions(AVDictionary *m)
634 AVDictionaryEntry *t;
635 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
636 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
641 static void assert_codec_experimental(AVCodecContext *c, int encoder)
643 const char *codec_string = encoder ? "encoder" : "decoder";
645 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
646 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
647 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
648 "results.\nAdd '-strict experimental' if you want to use it.\n",
649 codec_string, c->codec->name);
650 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
651 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
652 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
653 codec_string, codec->name);
658 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
660 if(codec && codec->sample_fmts){
661 const enum AVSampleFormat *p= codec->sample_fmts;
663 if(*p == st->codec->sample_fmt)
667 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
668 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
669 if(av_get_sample_fmt_name(st->codec->sample_fmt))
670 av_log(NULL, AV_LOG_WARNING,
671 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
672 av_get_sample_fmt_name(st->codec->sample_fmt),
674 av_get_sample_fmt_name(codec->sample_fmts[0]));
675 st->codec->sample_fmt = codec->sample_fmts[0];
680 static void choose_sample_rate(AVStream *st, AVCodec *codec)
682 if(codec && codec->supported_samplerates){
683 const int *p= codec->supported_samplerates;
685 int best_dist=INT_MAX;
687 int dist= abs(st->codec->sample_rate - *p);
688 if(dist < best_dist){
694 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
696 st->codec->sample_rate= best;
700 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
702 if(codec && codec->pix_fmts){
703 const enum PixelFormat *p= codec->pix_fmts;
704 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
705 if(st->codec->codec_id==CODEC_ID_MJPEG){
706 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
707 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
708 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};
712 if(*p == st->codec->pix_fmt)
716 if(st->codec->pix_fmt != PIX_FMT_NONE)
717 av_log(NULL, AV_LOG_WARNING,
718 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
719 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
721 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
722 st->codec->pix_fmt = codec->pix_fmts[0];
728 get_sync_ipts(const OutputStream *ost)
730 const InputStream *ist = ost->sync_ist;
731 OutputFile *of = &output_files[ost->file_index];
732 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
735 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
739 AVPacket new_pkt= *pkt;
740 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
741 &new_pkt.data, &new_pkt.size,
742 pkt->data, pkt->size,
743 pkt->flags & AV_PKT_FLAG_KEY);
746 new_pkt.destruct= av_destruct_packet;
748 fprintf(stderr, "%s failed for stream %d, codec %s",
749 bsfc->filter->name, pkt->stream_index,
750 avctx->codec ? avctx->codec->name : "copy");
760 ret= av_interleaved_write_frame(s, pkt);
762 print_error("av_interleaved_write_frame()", ret);
767 static void do_audio_out(AVFormatContext *s,
770 unsigned char *buf, int size)
773 int64_t audio_out_size, audio_buf_size;
774 int64_t allocated_for_size= size;
776 int size_out, frame_bytes, ret, resample_changed;
777 AVCodecContext *enc= ost->st->codec;
778 AVCodecContext *dec= ist->st->codec;
779 int osize = av_get_bytes_per_sample(enc->sample_fmt);
780 int isize = av_get_bytes_per_sample(dec->sample_fmt);
781 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
784 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
785 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
786 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
787 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
788 audio_buf_size*= osize*enc->channels;
790 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
791 if(coded_bps > 8*osize)
792 audio_out_size= audio_out_size * coded_bps / (8*osize);
793 audio_out_size += FF_MIN_BUFFER_SIZE;
795 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
796 fprintf(stderr, "Buffer sizes too large\n");
800 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
801 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
802 if (!audio_buf || !audio_out){
803 fprintf(stderr, "Out of memory in do_audio_out\n");
807 if (enc->channels != dec->channels)
808 ost->audio_resample = 1;
810 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
811 ost->resample_channels != dec->channels ||
812 ost->resample_sample_rate != dec->sample_rate;
814 if ((ost->audio_resample && !ost->resample) || resample_changed) {
815 if (resample_changed) {
816 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",
817 ist->file_index, ist->st->index,
818 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
819 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
820 ost->resample_sample_fmt = dec->sample_fmt;
821 ost->resample_channels = dec->channels;
822 ost->resample_sample_rate = dec->sample_rate;
824 audio_resample_close(ost->resample);
826 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
827 if (audio_sync_method <= 1 &&
828 ost->resample_sample_fmt == enc->sample_fmt &&
829 ost->resample_channels == enc->channels &&
830 ost->resample_sample_rate == enc->sample_rate) {
831 ost->resample = NULL;
832 ost->audio_resample = 0;
834 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
835 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
836 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
837 enc->sample_rate, dec->sample_rate,
838 enc->sample_fmt, dec->sample_fmt,
840 if (!ost->resample) {
841 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
842 dec->channels, dec->sample_rate,
843 enc->channels, enc->sample_rate);
849 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
850 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
851 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
852 if (ost->reformat_ctx)
853 av_audio_convert_free(ost->reformat_ctx);
854 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
855 dec->sample_fmt, 1, NULL, 0);
856 if (!ost->reformat_ctx) {
857 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
858 av_get_sample_fmt_name(dec->sample_fmt),
859 av_get_sample_fmt_name(enc->sample_fmt));
862 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
865 if(audio_sync_method){
866 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
867 - av_fifo_size(ost->fifo)/(enc->channels * 2);
868 double idelta= delta*dec->sample_rate / enc->sample_rate;
869 int byte_delta= ((int)idelta)*2*dec->channels;
871 //FIXME resample delay
872 if(fabs(delta) > 50){
873 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
875 byte_delta= FFMAX(byte_delta, -size);
879 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
884 static uint8_t *input_tmp= NULL;
885 input_tmp= av_realloc(input_tmp, byte_delta + size);
887 if(byte_delta > allocated_for_size - size){
888 allocated_for_size= byte_delta + (int64_t)size;
893 memset(input_tmp, 0, byte_delta);
894 memcpy(input_tmp + byte_delta, buf, size);
898 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
900 }else if(audio_sync_method>1){
901 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
902 av_assert0(ost->audio_resample);
904 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
905 // 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));
906 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
910 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
911 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
913 if (ost->audio_resample) {
915 size_out = audio_resample(ost->resample,
916 (short *)buftmp, (short *)buf,
917 size / (dec->channels * isize));
918 size_out = size_out * enc->channels * osize;
924 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
925 const void *ibuf[6]= {buftmp};
926 void *obuf[6]= {audio_buf};
927 int istride[6]= {isize};
928 int ostride[6]= {osize};
929 int len= size_out/istride[0];
930 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
931 printf("av_audio_convert() failed\n");
937 size_out = len*osize;
940 /* now encode as many frames as possible */
941 if (enc->frame_size > 1) {
942 /* output resampled raw samples */
943 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
944 fprintf(stderr, "av_fifo_realloc2() failed\n");
947 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
949 frame_bytes = enc->frame_size * osize * enc->channels;
951 while (av_fifo_size(ost->fifo) >= frame_bytes) {
953 av_init_packet(&pkt);
955 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
957 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
959 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
962 fprintf(stderr, "Audio encoding failed\n");
966 pkt.stream_index= ost->index;
969 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
970 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
971 pkt.flags |= AV_PKT_FLAG_KEY;
972 write_frame(s, &pkt, enc, ost->bitstream_filters);
974 ost->sync_opts += enc->frame_size;
978 av_init_packet(&pkt);
980 ost->sync_opts += size_out / (osize * enc->channels);
982 /* output a pcm frame */
983 /* determine the size of the coded buffer */
986 size_out = size_out*coded_bps/8;
988 if(size_out > audio_out_size){
989 fprintf(stderr, "Internal error, buffer size too small\n");
993 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
994 ret = avcodec_encode_audio(enc, audio_out, size_out,
997 fprintf(stderr, "Audio encoding failed\n");
1001 pkt.stream_index= ost->index;
1002 pkt.data= audio_out;
1004 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1005 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1006 pkt.flags |= AV_PKT_FLAG_KEY;
1007 write_frame(s, &pkt, enc, ost->bitstream_filters);
1011 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1013 AVCodecContext *dec;
1014 AVPicture *picture2;
1015 AVPicture picture_tmp;
1018 dec = ist->st->codec;
1020 /* deinterlace : must be done before any resize */
1021 if (do_deinterlace) {
1024 /* create temporary picture */
1025 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1026 buf = av_malloc(size);
1030 picture2 = &picture_tmp;
1031 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1033 if(avpicture_deinterlace(picture2, picture,
1034 dec->pix_fmt, dec->width, dec->height) < 0) {
1035 /* if error, do not deinterlace */
1036 fprintf(stderr, "Deinterlacing failed\n");
1045 if (picture != picture2)
1046 *picture = *picture2;
1050 static void do_subtitle_out(AVFormatContext *s,
1056 static uint8_t *subtitle_out = NULL;
1057 int subtitle_out_max_size = 1024 * 1024;
1058 int subtitle_out_size, nb, i;
1059 AVCodecContext *enc;
1062 if (pts == AV_NOPTS_VALUE) {
1063 fprintf(stderr, "Subtitle packets must have a pts\n");
1069 enc = ost->st->codec;
1071 if (!subtitle_out) {
1072 subtitle_out = av_malloc(subtitle_out_max_size);
1075 /* Note: DVB subtitle need one packet to draw them and one other
1076 packet to clear them */
1077 /* XXX: signal it in the codec context ? */
1078 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1083 for(i = 0; i < nb; i++) {
1084 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1085 // start_display_time is required to be 0
1086 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1087 sub->end_display_time -= sub->start_display_time;
1088 sub->start_display_time = 0;
1089 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1090 subtitle_out_max_size, sub);
1091 if (subtitle_out_size < 0) {
1092 fprintf(stderr, "Subtitle encoding failed\n");
1096 av_init_packet(&pkt);
1097 pkt.stream_index = ost->index;
1098 pkt.data = subtitle_out;
1099 pkt.size = subtitle_out_size;
1100 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1101 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1102 /* XXX: the pts correction is handled here. Maybe handling
1103 it in the codec would be better */
1105 pkt.pts += 90 * sub->start_display_time;
1107 pkt.pts += 90 * sub->end_display_time;
1109 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1113 static int bit_buffer_size= 1024*256;
1114 static uint8_t *bit_buffer= NULL;
1116 static void do_video_resample(OutputStream *ost,
1118 AVFrame *in_picture,
1119 AVFrame **out_picture)
1121 int resample_changed = 0;
1122 AVCodecContext *dec = ist->st->codec;
1123 AVCodecContext *enc = ost->st->codec;
1124 *out_picture = in_picture;
1126 resample_changed = ost->resample_width != dec->width ||
1127 ost->resample_height != dec->height ||
1128 ost->resample_pix_fmt != dec->pix_fmt;
1130 #if !CONFIG_AVFILTER
1131 if (resample_changed) {
1132 av_log(NULL, AV_LOG_INFO,
1133 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1134 ist->file_index, ist->st->index,
1135 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1136 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1137 ost->resample_width = dec->width;
1138 ost->resample_height = dec->height;
1139 ost->resample_pix_fmt = dec->pix_fmt;
1142 ost->video_resample = dec->width != enc->width ||
1143 dec->height != enc->height ||
1144 dec->pix_fmt != enc->pix_fmt;
1146 if (ost->video_resample) {
1147 *out_picture = &ost->resample_frame;
1148 if (!ost->img_resample_ctx || resample_changed) {
1149 /* initialize the destination picture */
1150 if (!ost->resample_frame.data[0]) {
1151 avcodec_get_frame_defaults(&ost->resample_frame);
1152 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1153 enc->width, enc->height)) {
1154 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1158 /* initialize a new scaler context */
1159 sws_freeContext(ost->img_resample_ctx);
1160 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1161 enc->width, enc->height, enc->pix_fmt,
1162 ost->sws_flags, NULL, NULL, NULL);
1163 if (ost->img_resample_ctx == NULL) {
1164 fprintf(stderr, "Cannot get resampling context\n");
1168 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1169 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1172 if (resample_changed) {
1173 avfilter_graph_free(&ost->graph);
1174 if (configure_video_filters(ist, ost)) {
1175 fprintf(stderr, "Error reinitializing filters!\n");
1180 if (resample_changed) {
1181 ost->resample_width = dec->width;
1182 ost->resample_height = dec->height;
1183 ost->resample_pix_fmt = dec->pix_fmt;
1188 static void do_video_out(AVFormatContext *s,
1191 AVFrame *in_picture,
1192 int *frame_size, float quality)
1194 int nb_frames, i, ret, format_video_sync;
1195 AVFrame *final_picture;
1196 AVCodecContext *enc;
1199 enc = ost->st->codec;
1201 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1203 /* by default, we output a single frame */
1208 format_video_sync = video_sync_method;
1209 if (format_video_sync < 0)
1210 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1212 if (format_video_sync) {
1213 double vdelta = sync_ipts - ost->sync_opts;
1214 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1217 else if (format_video_sync == 2) {
1220 }else if(vdelta>0.6)
1221 ost->sync_opts= lrintf(sync_ipts);
1222 }else if (vdelta > 1.1)
1223 nb_frames = lrintf(vdelta);
1224 //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);
1225 if (nb_frames == 0){
1228 fprintf(stderr, "*** drop!\n");
1229 }else if (nb_frames > 1) {
1230 nb_frames_dup += nb_frames - 1;
1232 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1235 ost->sync_opts= lrintf(sync_ipts);
1237 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1241 do_video_resample(ost, ist, in_picture, &final_picture);
1243 /* duplicates frame if needed */
1244 for(i=0;i<nb_frames;i++) {
1246 av_init_packet(&pkt);
1247 pkt.stream_index= ost->index;
1249 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1250 /* raw pictures are written as AVPicture structure to
1251 avoid any copies. We support temporarily the older
1253 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1254 enc->coded_frame->top_field_first = in_picture->top_field_first;
1255 pkt.data= (uint8_t *)final_picture;
1256 pkt.size= sizeof(AVPicture);
1257 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1258 pkt.flags |= AV_PKT_FLAG_KEY;
1260 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1262 AVFrame big_picture;
1264 big_picture= *final_picture;
1265 /* better than nothing: use input picture interlaced
1267 big_picture.interlaced_frame = in_picture->interlaced_frame;
1268 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1269 if(top_field_first == -1)
1270 big_picture.top_field_first = in_picture->top_field_first;
1272 big_picture.top_field_first = top_field_first;
1275 /* handles same_quant here. This is not correct because it may
1276 not be a global option */
1277 big_picture.quality = quality;
1279 big_picture.pict_type = 0;
1280 // big_picture.pts = AV_NOPTS_VALUE;
1281 big_picture.pts= ost->sync_opts;
1282 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1283 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1284 if (ost->forced_kf_index < ost->forced_kf_count &&
1285 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1286 big_picture.pict_type = AV_PICTURE_TYPE_I;
1287 ost->forced_kf_index++;
1289 ret = avcodec_encode_video(enc,
1290 bit_buffer, bit_buffer_size,
1293 fprintf(stderr, "Video encoding failed\n");
1298 pkt.data= bit_buffer;
1300 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1301 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1302 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1303 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1304 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1306 if(enc->coded_frame->key_frame)
1307 pkt.flags |= AV_PKT_FLAG_KEY;
1308 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1311 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1312 // enc->frame_number-1, ret, enc->pict_type);
1313 /* if two pass, output log */
1314 if (ost->logfile && enc->stats_out) {
1315 fprintf(ost->logfile, "%s", enc->stats_out);
1320 ost->frame_number++;
1324 static double psnr(double d){
1325 return -10.0*log(d)/log(10.0);
1328 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1331 AVCodecContext *enc;
1333 double ti1, bitrate, avg_bitrate;
1335 /* this is executed just the first time do_video_stats is called */
1337 vstats_file = fopen(vstats_filename, "w");
1344 enc = ost->st->codec;
1345 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1346 frame_number = ost->frame_number;
1347 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1348 if (enc->flags&CODEC_FLAG_PSNR)
1349 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1351 fprintf(vstats_file,"f_size= %6d ", frame_size);
1352 /* compute pts value */
1353 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1357 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1358 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1359 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1360 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1361 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1365 static void print_report(OutputFile *output_files,
1366 OutputStream *ost_table, int nb_ostreams,
1367 int is_last_report, int64_t timer_start)
1371 AVFormatContext *oc;
1373 AVCodecContext *enc;
1374 int frame_number, vid, i;
1376 int64_t pts = INT64_MAX;
1377 static int64_t last_time = -1;
1378 static int qp_histogram[52];
1380 if (!is_last_report) {
1382 /* display the report every 0.5 seconds */
1383 cur_time = av_gettime();
1384 if (last_time == -1) {
1385 last_time = cur_time;
1388 if ((cur_time - last_time) < 500000)
1390 last_time = cur_time;
1394 oc = output_files[0].ctx;
1396 total_size = avio_size(oc->pb);
1397 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1398 total_size= avio_tell(oc->pb);
1402 for(i=0;i<nb_ostreams;i++) {
1404 ost = &ost_table[i];
1405 enc = ost->st->codec;
1406 if (!ost->st->stream_copy && enc->coded_frame)
1407 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1408 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1409 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1411 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1412 float t = (av_gettime()-timer_start) / 1000000.0;
1414 frame_number = ost->frame_number;
1415 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1416 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1418 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1422 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1425 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1427 if (enc->flags&CODEC_FLAG_PSNR){
1429 double error, error_sum=0;
1430 double scale, scale_sum=0;
1431 char type[3]= {'Y','U','V'};
1432 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1435 error= enc->error[j];
1436 scale= enc->width*enc->height*255.0*255.0*frame_number;
1438 error= enc->coded_frame->error[j];
1439 scale= enc->width*enc->height*255.0*255.0;
1444 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1446 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1450 /* compute min output value */
1451 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1452 ost->st->time_base, AV_TIME_BASE_Q));
1455 if (verbose > 0 || is_last_report) {
1456 int hours, mins, secs, us;
1457 secs = pts / AV_TIME_BASE;
1458 us = pts % AV_TIME_BASE;
1464 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1466 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1467 "size=%8.0fkB time=", total_size / 1024.0);
1468 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1469 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1470 (100 * us) / AV_TIME_BASE);
1471 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1472 "bitrate=%6.1fkbits/s", bitrate);
1474 if (nb_frames_dup || nb_frames_drop)
1475 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1476 nb_frames_dup, nb_frames_drop);
1479 fprintf(stderr, "%s \r", buf);
1484 if (is_last_report && verbose >= 0){
1485 int64_t raw= audio_size + video_size + extra_size;
1486 fprintf(stderr, "\n");
1487 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1491 100.0*(total_size - raw)/raw
1496 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1498 int fill_char = 0x00;
1499 if (sample_fmt == AV_SAMPLE_FMT_U8)
1501 memset(buf, fill_char, size);
1504 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1508 for (i = 0; i < nb_ostreams; i++) {
1509 OutputStream *ost = &ost_table[i];
1510 AVCodecContext *enc = ost->st->codec;
1511 AVFormatContext *os = output_files[ost->file_index].ctx;
1513 if (!ost->encoding_needed)
1516 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1518 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1524 av_init_packet(&pkt);
1525 pkt.stream_index= ost->index;
1527 switch (ost->st->codec->codec_type) {
1528 case AVMEDIA_TYPE_AUDIO:
1529 fifo_bytes = av_fifo_size(ost->fifo);
1531 /* encode any samples remaining in fifo */
1532 if (fifo_bytes > 0) {
1533 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1534 int fs_tmp = enc->frame_size;
1536 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1537 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1538 enc->frame_size = fifo_bytes / (osize * enc->channels);
1540 int frame_bytes = enc->frame_size*osize*enc->channels;
1541 if (allocated_audio_buf_size < frame_bytes)
1543 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1546 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1547 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1548 ost->st->time_base.num, enc->sample_rate);
1549 enc->frame_size = fs_tmp;
1552 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1555 fprintf(stderr, "Audio encoding failed\n");
1559 pkt.flags |= AV_PKT_FLAG_KEY;
1561 case AVMEDIA_TYPE_VIDEO:
1562 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1564 fprintf(stderr, "Video encoding failed\n");
1568 if(enc->coded_frame && enc->coded_frame->key_frame)
1569 pkt.flags |= AV_PKT_FLAG_KEY;
1570 if (ost->logfile && enc->stats_out) {
1571 fprintf(ost->logfile, "%s", enc->stats_out);
1580 pkt.data = bit_buffer;
1582 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1583 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1584 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1589 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1590 static int output_packet(InputStream *ist, int ist_index,
1591 OutputStream *ost_table, int nb_ostreams,
1592 const AVPacket *pkt)
1594 AVFormatContext *os;
1599 void *buffer_to_free = NULL;
1600 static unsigned int samples_size= 0;
1601 AVSubtitle subtitle, *subtitle_to_free;
1602 int64_t pkt_pts = AV_NOPTS_VALUE;
1604 int frame_available;
1609 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1611 if(ist->next_pts == AV_NOPTS_VALUE)
1612 ist->next_pts= ist->pts;
1616 av_init_packet(&avpkt);
1624 if(pkt->dts != AV_NOPTS_VALUE)
1625 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1626 if(pkt->pts != AV_NOPTS_VALUE)
1627 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1629 //while we have more to decode or while the decoder did output something on EOF
1630 while (avpkt.size > 0 || (!pkt && got_output)) {
1631 uint8_t *data_buf, *decoded_data_buf;
1632 int data_size, decoded_data_size;
1634 ist->pts= ist->next_pts;
1636 if(avpkt.size && avpkt.size != pkt->size &&
1637 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1638 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1639 ist->showed_multi_packet_warning=1;
1642 /* decode the packet if needed */
1643 decoded_data_buf = NULL; /* fail safe */
1644 decoded_data_size= 0;
1645 data_buf = avpkt.data;
1646 data_size = avpkt.size;
1647 subtitle_to_free = NULL;
1648 if (ist->decoding_needed) {
1649 switch(ist->st->codec->codec_type) {
1650 case AVMEDIA_TYPE_AUDIO:{
1651 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1652 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1654 samples= av_malloc(samples_size);
1656 decoded_data_size= samples_size;
1657 /* XXX: could avoid copy if PCM 16 bits with same
1658 endianness as CPU */
1659 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1666 got_output = decoded_data_size > 0;
1667 /* Some bug in mpeg audio decoder gives */
1668 /* decoded_data_size < 0, it seems they are overflows */
1670 /* no audio frame */
1673 decoded_data_buf = (uint8_t *)samples;
1674 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1675 (ist->st->codec->sample_rate * ist->st->codec->channels);
1677 case AVMEDIA_TYPE_VIDEO:
1678 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1679 /* XXX: allocate picture correctly */
1680 avcodec_get_frame_defaults(&picture);
1681 avpkt.pts = pkt_pts;
1682 avpkt.dts = ist->pts;
1683 pkt_pts = AV_NOPTS_VALUE;
1685 ret = avcodec_decode_video2(ist->st->codec,
1686 &picture, &got_output, &avpkt);
1687 quality = same_quant ? picture.quality : 0;
1691 /* no picture yet */
1692 goto discard_packet;
1694 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1695 if (ist->st->codec->time_base.num != 0) {
1696 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1697 ist->next_pts += ((int64_t)AV_TIME_BASE *
1698 ist->st->codec->time_base.num * ticks) /
1699 ist->st->codec->time_base.den;
1702 buffer_to_free = NULL;
1703 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1705 case AVMEDIA_TYPE_SUBTITLE:
1706 ret = avcodec_decode_subtitle2(ist->st->codec,
1707 &subtitle, &got_output, &avpkt);
1711 goto discard_packet;
1713 subtitle_to_free = &subtitle;
1720 switch(ist->st->codec->codec_type) {
1721 case AVMEDIA_TYPE_AUDIO:
1722 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1723 ist->st->codec->sample_rate;
1725 case AVMEDIA_TYPE_VIDEO:
1726 if (ist->st->codec->time_base.num != 0) {
1727 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1728 ist->next_pts += ((int64_t)AV_TIME_BASE *
1729 ist->st->codec->time_base.num * ticks) /
1730 ist->st->codec->time_base.den;
1737 // preprocess audio (volume)
1738 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1739 if (audio_volume != 256) {
1742 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1743 int v = ((*volp) * audio_volume + 128) >> 8;
1744 *volp++ = av_clip_int16(v);
1749 /* frame rate emulation */
1750 if (input_files[ist->file_index].rate_emu) {
1751 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1752 int64_t now = av_gettime() - ist->start;
1756 /* if output time reached then transcode raw format,
1757 encode packets and output them */
1758 for (i = 0; i < nb_ostreams; i++) {
1759 OutputFile *of = &output_files[ost_table[i].file_index];
1762 ost = &ost_table[i];
1763 if (ost->source_index != ist_index)
1766 if (of->start_time && ist->pts < of->start_time)
1769 if (of->recording_time != INT64_MAX &&
1770 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1771 (AVRational){1, 1000000}) >= 0) {
1772 ost->is_past_recording_time = 1;
1777 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1778 ost->input_video_filter) {
1779 if (!picture.sample_aspect_ratio.num)
1780 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1781 picture.pts = ist->pts;
1783 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1785 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1786 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1787 while (frame_available) {
1788 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1789 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1790 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1793 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1794 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1798 os = output_files[ost->file_index].ctx;
1800 /* set the input output pts pairs */
1801 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1803 if (ost->encoding_needed) {
1804 av_assert0(ist->decoding_needed);
1805 switch(ost->st->codec->codec_type) {
1806 case AVMEDIA_TYPE_AUDIO:
1807 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1809 case AVMEDIA_TYPE_VIDEO:
1811 if (ost->picref->video && !ost->frame_aspect_ratio)
1812 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1814 do_video_out(os, ost, ist, &picture, &frame_size,
1815 same_quant ? quality : ost->st->codec->global_quality);
1816 if (vstats_filename && frame_size)
1817 do_video_stats(os, ost, frame_size);
1819 case AVMEDIA_TYPE_SUBTITLE:
1820 do_subtitle_out(os, ost, ist, &subtitle,
1827 AVFrame avframe; //FIXME/XXX remove this
1830 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1831 av_init_packet(&opkt);
1833 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1834 #if !CONFIG_AVFILTER
1840 /* no reencoding needed : output the packet directly */
1841 /* force the input stream PTS */
1843 avcodec_get_frame_defaults(&avframe);
1844 ost->st->codec->coded_frame= &avframe;
1845 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1847 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1848 audio_size += data_size;
1849 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1850 video_size += data_size;
1854 opkt.stream_index= ost->index;
1855 if(pkt->pts != AV_NOPTS_VALUE)
1856 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1858 opkt.pts= AV_NOPTS_VALUE;
1860 if (pkt->dts == AV_NOPTS_VALUE)
1861 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1863 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1864 opkt.dts -= ost_tb_start_time;
1866 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1867 opkt.flags= pkt->flags;
1869 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1870 if( ost->st->codec->codec_id != CODEC_ID_H264
1871 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1872 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1874 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1875 opkt.destruct= av_destruct_packet;
1877 opkt.data = data_buf;
1878 opkt.size = data_size;
1881 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1882 /* store AVPicture in AVPacket, as expected by the output format */
1883 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1884 opkt.data = (uint8_t *)&pict;
1885 opkt.size = sizeof(AVPicture);
1886 opkt.flags |= AV_PKT_FLAG_KEY;
1888 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1889 ost->st->codec->frame_number++;
1890 ost->frame_number++;
1891 av_free_packet(&opkt);
1895 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1896 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1898 avfilter_unref_buffer(ost->picref);
1903 av_free(buffer_to_free);
1904 /* XXX: allocate the subtitles in the codec ? */
1905 if (subtitle_to_free) {
1906 avsubtitle_free(subtitle_to_free);
1907 subtitle_to_free = NULL;
1915 static void print_sdp(OutputFile *output_files, int n)
1919 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1923 for (i = 0; i < n; i++)
1924 avc[i] = output_files[i].ctx;
1926 av_sdp_create(avc, n, sdp, sizeof(sdp));
1927 printf("SDP:\n%s\n", sdp);
1932 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1933 char *error, int error_len)
1936 InputStream *ist = &input_streams[ist_index];
1937 if (ist->decoding_needed) {
1938 AVCodec *codec = ist->dec;
1940 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1941 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1942 return AVERROR(EINVAL);
1945 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1946 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1947 ist->file_index, ist->st->index);
1948 return AVERROR(EINVAL);
1950 assert_codec_experimental(ist->st->codec, 0);
1951 assert_avoptions(ist->opts);
1954 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;
1955 ist->next_pts = AV_NOPTS_VALUE;
1961 static int transcode_init(OutputFile *output_files,
1962 int nb_output_files,
1963 InputFile *input_files,
1967 AVFormatContext *os;
1968 AVCodecContext *codec, *icodec;
1974 /* init framerate emulation */
1975 for (i = 0; i < nb_input_files; i++) {
1976 InputFile *ifile = &input_files[i];
1977 if (ifile->rate_emu)
1978 for (j = 0; j < ifile->nb_streams; j++)
1979 input_streams[j + ifile->ist_index].start = av_gettime();
1982 /* output stream init */
1983 for(i=0;i<nb_output_files;i++) {
1984 os = output_files[i].ctx;
1985 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1986 av_dump_format(os, i, os->filename, 1);
1987 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1988 return AVERROR(EINVAL);
1992 /* for each output stream, we compute the right encoding parameters */
1993 for (i = 0; i < nb_output_streams; i++) {
1994 ost = &output_streams[i];
1995 os = output_files[ost->file_index].ctx;
1996 ist = &input_streams[ost->source_index];
1998 codec = ost->st->codec;
1999 icodec = ist->st->codec;
2001 ost->st->disposition = ist->st->disposition;
2002 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2003 codec->chroma_sample_location = icodec->chroma_sample_location;
2005 if (ost->st->stream_copy) {
2006 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2008 if (extra_size > INT_MAX) {
2009 return AVERROR(EINVAL);
2012 /* if stream_copy is selected, no need to decode or encode */
2013 codec->codec_id = icodec->codec_id;
2014 codec->codec_type = icodec->codec_type;
2016 if(!codec->codec_tag){
2017 if( !os->oformat->codec_tag
2018 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2019 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2020 codec->codec_tag = icodec->codec_tag;
2023 codec->bit_rate = icodec->bit_rate;
2024 codec->rc_max_rate = icodec->rc_max_rate;
2025 codec->rc_buffer_size = icodec->rc_buffer_size;
2026 codec->extradata= av_mallocz(extra_size);
2027 if (!codec->extradata) {
2028 return AVERROR(ENOMEM);
2030 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2031 codec->extradata_size= icodec->extradata_size;
2033 codec->time_base = ist->st->time_base;
2034 if(!strcmp(os->oformat->name, "avi")) {
2035 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2036 codec->time_base = icodec->time_base;
2037 codec->time_base.num *= icodec->ticks_per_frame;
2038 codec->time_base.den *= 2;
2040 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2041 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){
2042 codec->time_base = icodec->time_base;
2043 codec->time_base.num *= icodec->ticks_per_frame;
2046 av_reduce(&codec->time_base.num, &codec->time_base.den,
2047 codec->time_base.num, codec->time_base.den, INT_MAX);
2049 switch(codec->codec_type) {
2050 case AVMEDIA_TYPE_AUDIO:
2051 if(audio_volume != 256) {
2052 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2055 codec->channel_layout = icodec->channel_layout;
2056 codec->sample_rate = icodec->sample_rate;
2057 codec->channels = icodec->channels;
2058 codec->frame_size = icodec->frame_size;
2059 codec->audio_service_type = icodec->audio_service_type;
2060 codec->block_align= icodec->block_align;
2061 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2062 codec->block_align= 0;
2063 if(codec->codec_id == CODEC_ID_AC3)
2064 codec->block_align= 0;
2066 case AVMEDIA_TYPE_VIDEO:
2067 codec->pix_fmt = icodec->pix_fmt;
2068 codec->width = icodec->width;
2069 codec->height = icodec->height;
2070 codec->has_b_frames = icodec->has_b_frames;
2071 if (!codec->sample_aspect_ratio.num) {
2072 codec->sample_aspect_ratio =
2073 ost->st->sample_aspect_ratio =
2074 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2075 ist->st->codec->sample_aspect_ratio.num ?
2076 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2079 case AVMEDIA_TYPE_SUBTITLE:
2080 codec->width = icodec->width;
2081 codec->height = icodec->height;
2083 case AVMEDIA_TYPE_DATA:
2090 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2091 switch(codec->codec_type) {
2092 case AVMEDIA_TYPE_AUDIO:
2093 ost->fifo= av_fifo_alloc(1024);
2095 return AVERROR(ENOMEM);
2097 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2098 if (!codec->sample_rate) {
2099 codec->sample_rate = icodec->sample_rate;
2101 choose_sample_rate(ost->st, ost->enc);
2102 codec->time_base = (AVRational){1, codec->sample_rate};
2103 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2104 codec->sample_fmt = icodec->sample_fmt;
2105 choose_sample_fmt(ost->st, ost->enc);
2106 if (!codec->channels) {
2107 codec->channels = icodec->channels;
2108 codec->channel_layout = icodec->channel_layout;
2110 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2111 codec->channel_layout = 0;
2112 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2113 icodec->request_channels = codec->channels;
2114 ist->decoding_needed = 1;
2115 ost->encoding_needed = 1;
2116 ost->resample_sample_fmt = icodec->sample_fmt;
2117 ost->resample_sample_rate = icodec->sample_rate;
2118 ost->resample_channels = icodec->channels;
2120 case AVMEDIA_TYPE_VIDEO:
2121 if (codec->pix_fmt == PIX_FMT_NONE)
2122 codec->pix_fmt = icodec->pix_fmt;
2123 choose_pixel_fmt(ost->st, ost->enc);
2125 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2126 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2130 if (!codec->width || !codec->height) {
2131 codec->width = icodec->width;
2132 codec->height = icodec->height;
2135 ost->video_resample = codec->width != icodec->width ||
2136 codec->height != icodec->height ||
2137 codec->pix_fmt != icodec->pix_fmt;
2138 if (ost->video_resample) {
2139 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2142 ost->resample_height = icodec->height;
2143 ost->resample_width = icodec->width;
2144 ost->resample_pix_fmt= icodec->pix_fmt;
2145 ost->encoding_needed = 1;
2146 ist->decoding_needed = 1;
2148 if (!ost->frame_rate.num)
2149 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2150 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2151 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2152 ost->frame_rate = ost->enc->supported_framerates[idx];
2154 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2155 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2156 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2157 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2158 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2162 if (configure_video_filters(ist, ost)) {
2163 fprintf(stderr, "Error opening filters!\n");
2168 case AVMEDIA_TYPE_SUBTITLE:
2169 ost->encoding_needed = 1;
2170 ist->decoding_needed = 1;
2177 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2178 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2179 char logfilename[1024];
2182 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2183 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2185 if (codec->flags & CODEC_FLAG_PASS1) {
2186 f = fopen(logfilename, "wb");
2188 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2194 size_t logbuffer_size;
2195 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2196 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2199 codec->stats_in = logbuffer;
2203 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2204 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2205 int size= codec->width * codec->height;
2206 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2211 bit_buffer = av_malloc(bit_buffer_size);
2213 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2215 return AVERROR(ENOMEM);
2218 /* open each encoder */
2219 for (i = 0; i < nb_output_streams; i++) {
2220 ost = &output_streams[i];
2221 if (ost->encoding_needed) {
2222 AVCodec *codec = ost->enc;
2223 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2225 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2226 ost->st->codec->codec_id, ost->file_index, ost->index);
2227 ret = AVERROR(EINVAL);
2230 if (dec->subtitle_header) {
2231 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2232 if (!ost->st->codec->subtitle_header) {
2233 ret = AVERROR(ENOMEM);
2236 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2237 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2239 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2240 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2241 ost->file_index, ost->index);
2242 ret = AVERROR(EINVAL);
2245 assert_codec_experimental(ost->st->codec, 1);
2246 assert_avoptions(ost->opts);
2247 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2248 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2249 "It takes bits/s as argument, not kbits/s\n");
2250 extra_size += ost->st->codec->extradata_size;
2254 /* init input streams */
2255 for (i = 0; i < nb_input_streams; i++)
2256 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2259 /* open files and write file headers */
2260 for (i = 0; i < nb_output_files; i++) {
2261 os = output_files[i].ctx;
2262 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2263 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2264 ret = AVERROR(EINVAL);
2267 // assert_avoptions(output_files[i].opts);
2268 if (strcmp(os->oformat->name, "rtp")) {
2274 /* dump the file output parameters - cannot be done before in case
2276 for(i=0;i<nb_output_files;i++) {
2277 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2280 /* dump the stream mapping */
2282 fprintf(stderr, "Stream mapping:\n");
2283 for (i = 0; i < nb_output_streams;i ++) {
2284 ost = &output_streams[i];
2285 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2286 input_streams[ost->source_index].file_index,
2287 input_streams[ost->source_index].st->index,
2290 if (ost->sync_ist != &input_streams[ost->source_index])
2291 fprintf(stderr, " [sync #%d.%d]",
2292 ost->sync_ist->file_index,
2293 ost->sync_ist->st->index);
2294 if (ost->st->stream_copy)
2295 fprintf(stderr, " (copy)");
2297 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2298 input_streams[ost->source_index].dec->name : "?",
2299 ost->enc ? ost->enc->name : "?");
2300 fprintf(stderr, "\n");
2305 fprintf(stderr, "%s\n", error);
2310 print_sdp(output_files, nb_output_files);
2317 * The following code is the main loop of the file converter
2319 static int transcode(OutputFile *output_files,
2320 int nb_output_files,
2321 InputFile *input_files,
2325 AVFormatContext *is, *os;
2329 int no_packet_count=0;
2330 int64_t timer_start;
2333 if (!(no_packet = av_mallocz(nb_input_files)))
2336 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2342 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2343 avio_set_interrupt_cb(decode_interrupt_cb);
2347 timer_start = av_gettime();
2349 for(; received_sigterm == 0;) {
2350 int file_index, ist_index;
2355 ipts_min = INT64_MAX;
2357 /* if 'q' pressed, exits */
2361 /* read_key() returns 0 on EOF */
2365 if (key == '+') verbose++;
2366 if (key == '-') verbose--;
2367 if (key == 's') qp_hist ^= 1;
2370 do_hex_dump = do_pkt_dump = 0;
2371 } else if(do_pkt_dump){
2375 av_log_set_level(AV_LOG_DEBUG);
2377 if (key == 'd' || key == 'D'){
2380 debug = input_streams[0].st->codec->debug<<1;
2381 if(!debug) debug = 1;
2382 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2385 scanf("%d", &debug);
2386 for(i=0;i<nb_input_streams;i++) {
2387 input_streams[i].st->codec->debug = debug;
2389 for(i=0;i<nb_output_streams;i++) {
2390 ost = &output_streams[i];
2391 ost->st->codec->debug = debug;
2393 if(debug) av_log_set_level(AV_LOG_DEBUG);
2394 fprintf(stderr,"debug=%d\n", debug);
2397 fprintf(stderr, "key function\n"
2398 "? show this help\n"
2399 "+ increase verbosity\n"
2400 "- decrease verbosity\n"
2401 "D cycle through available debug modes\n"
2402 "h dump packets/hex press to cycle through the 3 states\n"
2404 "s Show QP histogram\n"
2409 /* select the stream that we must read now by looking at the
2410 smallest output pts */
2412 for (i = 0; i < nb_output_streams; i++) {
2416 ost = &output_streams[i];
2417 of = &output_files[ost->file_index];
2418 os = output_files[ost->file_index].ctx;
2419 ist = &input_streams[ost->source_index];
2420 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2421 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2423 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2425 if (!input_files[ist->file_index].eof_reached){
2426 if(ipts < ipts_min) {
2428 if(input_sync ) file_index = ist->file_index;
2430 if(opts < opts_min) {
2432 if(!input_sync) file_index = ist->file_index;
2435 if (ost->frame_number >= ost->max_frames) {
2437 for (j = of->ost_index; j < of->ctx->nb_streams; j++)
2438 output_streams[j].is_past_recording_time = 1;
2442 /* if none, if is finished */
2443 if (file_index < 0) {
2444 if(no_packet_count){
2446 memset(no_packet, 0, nb_input_files);
2453 /* read a frame from it and output it in the fifo */
2454 is = input_files[file_index].ctx;
2455 ret= av_read_frame(is, &pkt);
2456 if(ret == AVERROR(EAGAIN)){
2457 no_packet[file_index]=1;
2462 input_files[file_index].eof_reached = 1;
2470 memset(no_packet, 0, nb_input_files);
2473 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2474 is->streams[pkt.stream_index]);
2476 /* the following test is needed in case new streams appear
2477 dynamically in stream : we ignore them */
2478 if (pkt.stream_index >= input_files[file_index].nb_streams)
2479 goto discard_packet;
2480 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2481 ist = &input_streams[ist_index];
2483 goto discard_packet;
2485 if (pkt.dts != AV_NOPTS_VALUE)
2486 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2487 if (pkt.pts != AV_NOPTS_VALUE)
2488 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2490 if(pkt.pts != AV_NOPTS_VALUE)
2491 pkt.pts *= ist->ts_scale;
2492 if(pkt.dts != AV_NOPTS_VALUE)
2493 pkt.dts *= ist->ts_scale;
2495 // 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);
2496 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2497 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2498 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2499 int64_t delta= pkt_dts - ist->next_pts;
2500 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2501 input_files[ist->file_index].ts_offset -= delta;
2503 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2504 delta, input_files[ist->file_index].ts_offset);
2505 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2506 if(pkt.pts != AV_NOPTS_VALUE)
2507 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2511 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2512 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2515 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2516 ist->file_index, ist->st->index);
2519 av_free_packet(&pkt);
2524 av_free_packet(&pkt);
2526 /* dump report by using the output first video and audio streams */
2527 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2530 /* at the end of stream, we must flush the decoder buffers */
2531 for (i = 0; i < nb_input_streams; i++) {
2532 ist = &input_streams[i];
2533 if (ist->decoding_needed) {
2534 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2537 flush_encoders(output_streams, nb_output_streams);
2541 /* write the trailer if needed and close file */
2542 for(i=0;i<nb_output_files;i++) {
2543 os = output_files[i].ctx;
2544 av_write_trailer(os);
2547 /* dump report by using the first video and audio streams */
2548 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2550 /* close each encoder */
2551 for (i = 0; i < nb_output_streams; i++) {
2552 ost = &output_streams[i];
2553 if (ost->encoding_needed) {
2554 av_freep(&ost->st->codec->stats_in);
2555 avcodec_close(ost->st->codec);
2558 avfilter_graph_free(&ost->graph);
2562 /* close each decoder */
2563 for (i = 0; i < nb_input_streams; i++) {
2564 ist = &input_streams[i];
2565 if (ist->decoding_needed) {
2566 avcodec_close(ist->st->codec);
2574 av_freep(&bit_buffer);
2575 av_freep(&no_packet);
2577 if (output_streams) {
2578 for (i = 0; i < nb_output_streams; i++) {
2579 ost = &output_streams[i];
2581 if (ost->st->stream_copy)
2582 av_freep(&ost->st->codec->extradata);
2584 fclose(ost->logfile);
2585 ost->logfile = NULL;
2587 av_fifo_free(ost->fifo); /* works even if fifo is not
2588 initialized but set to zero */
2589 av_freep(&ost->st->codec->subtitle_header);
2590 av_free(ost->resample_frame.data[0]);
2591 av_free(ost->forced_kf_pts);
2592 if (ost->video_resample)
2593 sws_freeContext(ost->img_resample_ctx);
2595 audio_resample_close(ost->resample);
2596 if (ost->reformat_ctx)
2597 av_audio_convert_free(ost->reformat_ctx);
2598 av_dict_free(&ost->opts);
2605 static int opt_video_rc_override_string(const char *opt, const char *arg)
2607 video_rc_override_string = arg;
2611 static int opt_me_threshold(const char *opt, const char *arg)
2613 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2617 static int opt_verbose(const char *opt, const char *arg)
2619 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2623 static int opt_frame_rate(const char *opt, const char *arg)
2625 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2626 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2632 static int opt_frame_size(const char *opt, const char *arg)
2634 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2635 fprintf(stderr, "Incorrect frame size\n");
2636 return AVERROR(EINVAL);
2641 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2643 if (strcmp(arg, "list")) {
2644 frame_pix_fmt = av_get_pix_fmt(arg);
2645 if (frame_pix_fmt == PIX_FMT_NONE) {
2646 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2647 return AVERROR(EINVAL);
2650 opt_pix_fmts(NULL, NULL);
2656 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2663 p = strchr(arg, ':');
2665 x = strtol(arg, &end, 10);
2667 y = strtol(end+1, &end, 10);
2669 ar = (double)x / (double)y;
2671 ar = strtod(arg, NULL);
2674 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2675 return AVERROR(EINVAL);
2677 frame_aspect_ratio = ar;
2681 static int opt_qscale(const char *opt, const char *arg)
2683 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2684 if (video_qscale <= 0 || video_qscale > 255) {
2685 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2686 return AVERROR(EINVAL);
2691 static int opt_top_field_first(const char *opt, const char *arg)
2693 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2694 return opt_default(opt, arg);
2697 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2699 if (strcmp(arg, "list")) {
2700 audio_sample_fmt = av_get_sample_fmt(arg);
2701 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2702 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2703 return AVERROR(EINVAL);
2708 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2709 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2715 static int opt_audio_rate(const char *opt, const char *arg)
2717 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2721 static int opt_audio_channels(const char *opt, const char *arg)
2723 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2727 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2729 return parse_option(o, "codec:a", arg, options);
2732 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2734 return parse_option(o, "codec:v", arg, options);
2737 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2739 return parse_option(o, "codec:s", arg, options);
2742 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2744 return parse_option(o, "codec:d", arg, options);
2747 static int opt_codec_tag(const char *opt, const char *arg)
2750 uint32_t *codec_tag;
2752 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2753 !strcmp(opt, "vtag") ? &video_codec_tag :
2754 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2758 *codec_tag = strtol(arg, &tail, 0);
2760 *codec_tag = AV_RL32(arg);
2765 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2767 StreamMap *m = NULL;
2768 int i, negative = 0, file_idx;
2769 int sync_file_idx = -1, sync_stream_idx;
2777 map = av_strdup(arg);
2779 /* parse sync stream first, just pick first matching stream */
2780 if (sync = strchr(map, ',')) {
2782 sync_file_idx = strtol(sync + 1, &sync, 0);
2783 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2784 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2789 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2790 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2791 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2792 sync_stream_idx = i;
2795 if (i == input_files[sync_file_idx].nb_streams) {
2796 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2797 "match any streams.\n", arg);
2803 file_idx = strtol(map, &p, 0);
2804 if (file_idx >= nb_input_files || file_idx < 0) {
2805 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2809 /* disable some already defined maps */
2810 for (i = 0; i < o->nb_stream_maps; i++) {
2811 m = &o->stream_maps[i];
2812 if (check_stream_specifier(input_files[m->file_index].ctx,
2813 input_files[m->file_index].ctx->streams[m->stream_index],
2814 *p == ':' ? p + 1 : p) > 0)
2818 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2819 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2820 *p == ':' ? p + 1 : p) <= 0)
2822 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2823 &o->nb_stream_maps, o->nb_stream_maps + 1);
2824 m = &o->stream_maps[o->nb_stream_maps - 1];
2826 m->file_index = file_idx;
2827 m->stream_index = i;
2829 if (sync_file_idx >= 0) {
2830 m->sync_file_index = sync_file_idx;
2831 m->sync_stream_index = sync_stream_idx;
2833 m->sync_file_index = file_idx;
2834 m->sync_stream_index = i;
2839 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2847 static void parse_meta_type(char *arg, char *type, int *index)
2857 if (*(++arg) == ':')
2858 *index = strtol(++arg, NULL, 0);
2861 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2868 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2870 MetadataMap *m, *m1;
2873 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2874 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2876 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2877 m->file = strtol(arg, &p, 0);
2878 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2880 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2881 if (p = strchr(opt, ':'))
2882 parse_meta_type(p + 1, &m1->type, &m1->index);
2886 if (m->type == 'g' || m1->type == 'g')
2887 o->metadata_global_manual = 1;
2888 if (m->type == 's' || m1->type == 's')
2889 o->metadata_streams_manual = 1;
2890 if (m->type == 'c' || m1->type == 'c')
2891 o->metadata_chapters_manual = 1;
2896 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2898 const char *codec_string = encoder ? "encoder" : "decoder";
2902 return CODEC_ID_NONE;
2904 avcodec_find_encoder_by_name(name) :
2905 avcodec_find_decoder_by_name(name);
2907 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2910 if(codec->type != type) {
2911 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2917 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2919 char *codec_name = NULL;
2921 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2925 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2926 return avcodec_find_encoder(st->codec->codec_id);
2928 } else if (!strcmp(codec_name, "copy"))
2929 st->stream_copy = 1;
2931 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2932 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2933 avcodec_find_decoder_by_name(codec_name);
2940 * Add all the streams from the given input file to the global
2941 * list of input streams.
2943 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2945 int i, rfps, rfps_base;
2947 for (i = 0; i < ic->nb_streams; i++) {
2948 AVStream *st = ic->streams[i];
2949 AVCodecContext *dec = st->codec;
2953 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2954 ist = &input_streams[nb_input_streams - 1];
2956 ist->file_index = nb_input_files;
2958 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2960 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2961 ist->ts_scale = scale;
2963 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2965 ist->dec = avcodec_find_decoder(dec->codec_id);
2967 switch (dec->codec_type) {
2968 case AVMEDIA_TYPE_AUDIO:
2970 ist->dec = avcodec_find_decoder(dec->codec_id);
2972 st->discard= AVDISCARD_ALL;
2974 case AVMEDIA_TYPE_VIDEO:
2976 ist->dec = avcodec_find_decoder(dec->codec_id);
2977 rfps = ic->streams[i]->r_frame_rate.num;
2978 rfps_base = ic->streams[i]->r_frame_rate.den;
2980 dec->flags |= CODEC_FLAG_EMU_EDGE;
2983 dec->debug |= FF_DEBUG_MV;
2985 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2988 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2989 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2991 (float)rfps / rfps_base, rfps, rfps_base);
2995 st->discard= AVDISCARD_ALL;
2996 else if(video_discard)
2997 st->discard= video_discard;
2999 case AVMEDIA_TYPE_DATA:
3001 case AVMEDIA_TYPE_SUBTITLE:
3003 ist->dec = avcodec_find_decoder(dec->codec_id);
3004 if(subtitle_disable)
3005 st->discard = AVDISCARD_ALL;
3007 case AVMEDIA_TYPE_ATTACHMENT:
3008 case AVMEDIA_TYPE_UNKNOWN:
3016 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3018 AVFormatContext *ic;
3019 AVInputFormat *file_iformat = NULL;
3023 AVDictionary **opts;
3024 int orig_nb_streams; // number of streams before avformat_find_stream_info
3027 if (!(file_iformat = av_find_input_format(o->format))) {
3028 fprintf(stderr, "Unknown input format: '%s'\n", o->format);
3033 if (!strcmp(filename, "-"))
3036 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3037 !strcmp(filename, "/dev/stdin");
3039 /* get default parameters from command line */
3040 ic = avformat_alloc_context();
3042 print_error(filename, AVERROR(ENOMEM));
3045 if (audio_sample_rate) {
3046 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3047 av_dict_set(&format_opts, "sample_rate", buf, 0);
3049 if (audio_channels) {
3050 snprintf(buf, sizeof(buf), "%d", audio_channels);
3051 av_dict_set(&format_opts, "channels", buf, 0);
3053 if (frame_rate.num) {
3054 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3055 av_dict_set(&format_opts, "framerate", buf, 0);
3057 if (frame_width && frame_height) {
3058 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3059 av_dict_set(&format_opts, "video_size", buf, 0);
3061 if (frame_pix_fmt != PIX_FMT_NONE)
3062 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3064 ic->flags |= AVFMT_FLAG_NONBLOCK;
3066 /* open the input file with generic libav function */
3067 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3069 print_error(filename, err);
3072 assert_avoptions(format_opts);
3077 for(i=0; i<ic->nb_streams; i++){
3078 ic->streams[i]->discard= AVDISCARD_ALL;
3080 for(i=0; i<ic->nb_programs; i++){
3081 AVProgram *p= ic->programs[i];
3082 if(p->id != opt_programid){
3083 p->discard = AVDISCARD_ALL;
3086 for(j=0; j<p->nb_stream_indexes; j++){
3087 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3092 fprintf(stderr, "Specified program id not found\n");
3098 /* apply forced codec ids */
3099 for (i = 0; i < ic->nb_streams; i++)
3100 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3102 /* Set AVCodecContext options for avformat_find_stream_info */
3103 opts = setup_find_stream_info_opts(ic, codec_opts);
3104 orig_nb_streams = ic->nb_streams;
3106 /* If not enough info to get the stream parameters, we decode the
3107 first frames to get it. (used in mpeg case for example) */
3108 ret = avformat_find_stream_info(ic, opts);
3109 if (ret < 0 && verbose >= 0) {
3110 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3111 av_close_input_file(ic);
3115 timestamp = o->start_time;
3116 /* add the stream start time */
3117 if (ic->start_time != AV_NOPTS_VALUE)
3118 timestamp += ic->start_time;
3120 /* if seeking requested, we execute it */
3121 if (o->start_time != 0) {
3122 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3124 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3125 filename, (double)timestamp / AV_TIME_BASE);
3129 /* update the current parameters so that they match the one of the input stream */
3130 add_input_streams(o, ic);
3132 /* dump the file content */
3134 av_dump_format(ic, nb_input_files, filename, 0);
3136 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3137 input_files[nb_input_files - 1].ctx = ic;
3138 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3139 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3140 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3142 top_field_first = -1;
3143 frame_rate = (AVRational){0, 0};
3144 frame_pix_fmt = PIX_FMT_NONE;
3147 audio_sample_rate = 0;
3149 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3151 for (i = 0; i < orig_nb_streams; i++)
3152 av_dict_free(&opts[i]);
3159 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3160 AVCodecContext *avctx)
3166 for (p = kf; *p; p++)
3169 ost->forced_kf_count = n;
3170 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3171 if (!ost->forced_kf_pts) {
3172 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3175 for (i = 0; i < n; i++) {
3176 p = i ? strchr(p, ',') + 1 : kf;
3177 t = parse_time_or_die("force_key_frames", p, 1);
3178 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3182 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3185 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3186 int idx = oc->nb_streams - 1;
3187 int64_t max_frames = INT64_MAX;
3188 char *bsf = NULL, *next;
3189 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3192 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3196 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3197 nb_output_streams + 1);
3198 ost = &output_streams[nb_output_streams - 1];
3199 ost->file_index = nb_output_files;
3202 st->codec->codec_type = type;
3203 ost->enc = choose_codec(o, oc, st, type);
3205 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3208 avcodec_get_context_defaults3(st->codec, ost->enc);
3209 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3211 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3212 ost->max_frames = max_frames;
3214 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3216 if (next = strchr(bsf, ','))
3218 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3219 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter %s\n", bsf);
3223 bsfc_prev->next = bsfc;
3225 ost->bitstream_filters = bsfc;
3231 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3235 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3239 AVCodecContext *video_enc;
3241 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3243 if (!st->stream_copy) {
3244 ost->frame_aspect_ratio = frame_aspect_ratio;
3245 frame_aspect_ratio = 0;
3247 ost->avfilter = vfilters;
3252 video_enc = st->codec;
3255 video_enc->codec_tag= video_codec_tag;
3257 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3258 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3261 if (st->stream_copy) {
3262 video_enc->sample_aspect_ratio =
3263 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3269 ost->frame_rate = frame_rate;
3271 video_enc->width = frame_width;
3272 video_enc->height = frame_height;
3273 video_enc->pix_fmt = frame_pix_fmt;
3274 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3275 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3277 if (video_qscale || same_quant) {
3278 video_enc->flags |= CODEC_FLAG_QSCALE;
3279 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3283 video_enc->intra_matrix = intra_matrix;
3285 video_enc->inter_matrix = inter_matrix;
3287 p= video_rc_override_string;
3290 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3292 fprintf(stderr, "error parsing rc_override\n");
3295 video_enc->rc_override=
3296 av_realloc(video_enc->rc_override,
3297 sizeof(RcOverride)*(i+1));
3298 video_enc->rc_override[i].start_frame= start;
3299 video_enc->rc_override[i].end_frame = end;
3301 video_enc->rc_override[i].qscale= q;
3302 video_enc->rc_override[i].quality_factor= 1.0;
3305 video_enc->rc_override[i].qscale= 0;
3306 video_enc->rc_override[i].quality_factor= -q/100.0;
3311 video_enc->rc_override_count=i;
3312 if (!video_enc->rc_initial_buffer_occupancy)
3313 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3314 video_enc->me_threshold= me_threshold;
3315 video_enc->intra_dc_precision= intra_dc_precision - 8;
3318 video_enc->flags|= CODEC_FLAG_PSNR;
3323 video_enc->flags |= CODEC_FLAG_PASS1;
3325 video_enc->flags |= CODEC_FLAG_PASS2;
3329 if (forced_key_frames)
3330 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3332 if (video_language) {
3333 av_dict_set(&st->metadata, "language", video_language, 0);
3334 av_freep(&video_language);
3337 /* reset some key parameters */
3339 av_freep(&forced_key_frames);
3340 frame_pix_fmt = PIX_FMT_NONE;
3344 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3348 AVCodecContext *audio_enc;
3350 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3353 audio_enc = st->codec;
3354 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3357 audio_enc->codec_tag= audio_codec_tag;
3359 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3360 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3362 if (!st->stream_copy) {
3363 if (audio_qscale > QSCALE_NONE) {
3364 audio_enc->flags |= CODEC_FLAG_QSCALE;
3365 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3368 audio_enc->channels = audio_channels;
3369 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3370 audio_enc->sample_fmt = audio_sample_fmt;
3371 if (audio_sample_rate)
3372 audio_enc->sample_rate = audio_sample_rate;
3374 if (audio_language) {
3375 av_dict_set(&st->metadata, "language", audio_language, 0);
3376 av_freep(&audio_language);
3379 /* reset some key parameters */
3385 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3389 AVCodecContext *data_enc;
3391 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3393 data_enc = st->codec;
3394 if (!st->stream_copy) {
3395 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3400 data_enc->codec_tag= data_codec_tag;
3402 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3403 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3410 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3414 AVCodecContext *subtitle_enc;
3416 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3418 subtitle_enc = st->codec;
3420 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3422 if(subtitle_codec_tag)
3423 subtitle_enc->codec_tag= subtitle_codec_tag;
3425 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3426 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3429 if (subtitle_language) {
3430 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3431 av_freep(&subtitle_language);
3434 subtitle_disable = 0;
3438 /* arg format is "output-stream-index:streamid-value". */
3439 static int opt_streamid(const char *opt, const char *arg)
3445 av_strlcpy(idx_str, arg, sizeof(idx_str));
3446 p = strchr(idx_str, ':');
3449 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3454 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3455 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3456 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3460 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3462 AVFormatContext *is = ifile->ctx;
3463 AVFormatContext *os = ofile->ctx;
3466 for (i = 0; i < is->nb_chapters; i++) {
3467 AVChapter *in_ch = is->chapters[i], *out_ch;
3468 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3469 AV_TIME_BASE_Q, in_ch->time_base);
3470 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3471 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3474 if (in_ch->end < ts_off)
3476 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3479 out_ch = av_mallocz(sizeof(AVChapter));
3481 return AVERROR(ENOMEM);
3483 out_ch->id = in_ch->id;
3484 out_ch->time_base = in_ch->time_base;
3485 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3486 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3489 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3492 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3494 return AVERROR(ENOMEM);
3495 os->chapters[os->nb_chapters - 1] = out_ch;
3500 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3503 AVFormatContext *ic = NULL;
3505 err = avformat_open_input(&ic, filename, NULL, NULL);
3508 /* copy stream format */
3509 for(i=0;i<ic->nb_streams;i++) {
3514 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3515 ost = new_output_stream(o, s, codec->type);
3518 // FIXME: a more elegant solution is needed
3519 memcpy(st, ic->streams[i], sizeof(AVStream));
3520 st->info = av_malloc(sizeof(*st->info));
3521 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3522 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3524 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3525 choose_sample_fmt(st, codec);
3526 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3527 choose_pixel_fmt(st, codec);
3530 av_close_input_file(ic);
3534 static void opt_output_file(void *optctx, const char *filename)
3536 OptionsContext *o = optctx;
3537 AVFormatContext *oc;
3539 AVOutputFormat *file_oformat;
3543 if (!strcmp(filename, "-"))
3546 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3548 print_error(filename, err);
3552 file_oformat= oc->oformat;
3554 if (!strcmp(file_oformat->name, "ffm") &&
3555 av_strstart(filename, "http:", NULL)) {
3556 /* special case for files sent to ffserver: we get the stream
3557 parameters from ffserver */
3558 int err = read_ffserver_streams(o, oc, filename);
3560 print_error(filename, err);
3563 } else if (!o->nb_stream_maps) {
3564 /* pick the "best" stream of each type */
3565 #define NEW_STREAM(type, index)\
3567 ost = new_ ## type ## _stream(o, oc);\
3568 ost->source_index = index;\
3569 ost->sync_ist = &input_streams[index];\
3570 input_streams[index].discard = 0;\
3573 /* video: highest resolution */
3574 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3575 int area = 0, idx = -1;
3576 for (i = 0; i < nb_input_streams; i++) {
3577 ist = &input_streams[i];
3578 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3579 ist->st->codec->width * ist->st->codec->height > area) {
3580 area = ist->st->codec->width * ist->st->codec->height;
3584 NEW_STREAM(video, idx);
3587 /* audio: most channels */
3588 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3589 int channels = 0, idx = -1;
3590 for (i = 0; i < nb_input_streams; i++) {
3591 ist = &input_streams[i];
3592 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3593 ist->st->codec->channels > channels) {
3594 channels = ist->st->codec->channels;
3598 NEW_STREAM(audio, idx);
3601 /* subtitles: pick first */
3602 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3603 for (i = 0; i < nb_input_streams; i++)
3604 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3605 NEW_STREAM(subtitle, i);
3609 /* do something with data? */
3611 for (i = 0; i < o->nb_stream_maps; i++) {
3612 StreamMap *map = &o->stream_maps[i];
3617 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3618 switch (ist->st->codec->codec_type) {
3619 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3620 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3621 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3622 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3624 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3625 map->file_index, map->stream_index);
3629 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3630 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3631 map->sync_stream_index];
3636 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3637 output_files[nb_output_files - 1].ctx = oc;
3638 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3639 output_files[nb_output_files - 1].recording_time = o->recording_time;
3640 output_files[nb_output_files - 1].start_time = o->start_time;
3641 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3642 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3644 /* check filename in case of an image number is expected */
3645 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3646 if (!av_filename_number_test(oc->filename)) {
3647 print_error(oc->filename, AVERROR(EINVAL));
3652 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3653 /* test if it already exists to avoid loosing precious files */
3654 if (!file_overwrite &&
3655 (strchr(filename, ':') == NULL ||
3656 filename[1] == ':' ||
3657 av_strstart(filename, "file:", NULL))) {
3658 if (avio_check(filename, 0) == 0) {
3660 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3662 if (!read_yesno()) {
3663 fprintf(stderr, "Not overwriting - exiting\n");
3668 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3675 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3676 print_error(filename, err);
3681 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3682 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3685 if (o->chapters_input_file >= nb_input_files) {
3686 if (o->chapters_input_file == INT_MAX) {
3687 /* copy chapters from the first input file that has them*/
3688 o->chapters_input_file = -1;
3689 for (i = 0; i < nb_input_files; i++)
3690 if (input_files[i].ctx->nb_chapters) {
3691 o->chapters_input_file = i;
3695 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3696 o->chapters_input_file);
3700 if (o->chapters_input_file >= 0)
3701 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3702 o->metadata_chapters_manual);
3705 for (i = 0; i < o->nb_meta_data_maps; i++) {
3706 AVFormatContext *files[2];
3707 AVDictionary **meta[2];
3710 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3711 if ((index) < 0 || (index) >= (nb_elems)) {\
3712 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3717 int in_file_index = o->meta_data_maps[i][1].file;
3718 if (in_file_index < 0)
3720 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3723 files[1] = input_files[in_file_index].ctx;
3725 for (j = 0; j < 2; j++) {
3726 MetadataMap *map = &o->meta_data_maps[i][j];
3728 switch (map->type) {
3730 meta[j] = &files[j]->metadata;
3733 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3734 meta[j] = &files[j]->streams[map->index]->metadata;
3737 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3738 meta[j] = &files[j]->chapters[map->index]->metadata;
3741 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3742 meta[j] = &files[j]->programs[map->index]->metadata;
3747 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3750 /* copy global metadata by default */
3751 if (!o->metadata_global_manual && nb_input_files)
3752 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3753 AV_DICT_DONT_OVERWRITE);
3754 if (!o->metadata_streams_manual)
3755 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3756 InputStream *ist = &input_streams[output_streams[i].source_index];
3757 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3760 /* process manually set metadata */
3761 for (i = 0; i < o->nb_metadata; i++) {
3766 val = strchr(o->metadata[i].u.str, '=');
3768 av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3769 o->metadata[i].u.str);
3774 parse_meta_type(o->metadata[i].specifier, &type, &index);
3780 if (index < 0 || index >= oc->nb_streams) {
3781 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3784 m = &oc->streams[i]->metadata;
3787 if (index < 0 || index >= oc->nb_chapters) {
3788 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3791 m = &oc->chapters[i]->metadata;
3794 av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3798 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3801 frame_rate = (AVRational){0, 0};
3804 audio_sample_rate = 0;
3806 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3808 av_freep(&streamid_map);
3809 nb_streamid_map = 0;
3811 av_freep(&forced_key_frames);
3815 /* same option as mencoder */
3816 static int opt_pass(const char *opt, const char *arg)
3818 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3822 static int64_t getutime(void)
3825 struct rusage rusage;
3827 getrusage(RUSAGE_SELF, &rusage);
3828 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3829 #elif HAVE_GETPROCESSTIMES
3831 FILETIME c, e, k, u;
3832 proc = GetCurrentProcess();
3833 GetProcessTimes(proc, &c, &e, &k, &u);
3834 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3836 return av_gettime();
3840 static int64_t getmaxrss(void)
3842 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3843 struct rusage rusage;
3844 getrusage(RUSAGE_SELF, &rusage);
3845 return (int64_t)rusage.ru_maxrss * 1024;
3846 #elif HAVE_GETPROCESSMEMORYINFO
3848 PROCESS_MEMORY_COUNTERS memcounters;
3849 proc = GetCurrentProcess();
3850 memcounters.cb = sizeof(memcounters);
3851 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3852 return memcounters.PeakPagefileUsage;
3858 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3861 const char *p = str;
3868 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3875 static int opt_inter_matrix(const char *opt, const char *arg)
3877 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3878 parse_matrix_coeffs(inter_matrix, arg);
3882 static int opt_intra_matrix(const char *opt, const char *arg)
3884 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3885 parse_matrix_coeffs(intra_matrix, arg);
3889 static void show_usage(void)
3891 printf("Hyper fast Audio and Video encoder\n");
3892 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3896 static int opt_help(const char *opt, const char *arg)
3899 AVOutputFormat *oformat = NULL;
3900 AVInputFormat *iformat = NULL;
3901 const AVClass *class;
3903 av_log_set_callback(log_callback_help);
3905 show_help_options(options, "Main options:\n",
3906 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3907 show_help_options(options, "\nAdvanced options:\n",
3908 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3910 show_help_options(options, "\nVideo options:\n",
3911 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3913 show_help_options(options, "\nAdvanced Video options:\n",
3914 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3915 OPT_VIDEO | OPT_EXPERT);
3916 show_help_options(options, "\nAudio options:\n",
3917 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3919 show_help_options(options, "\nAdvanced Audio options:\n",
3920 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3921 OPT_AUDIO | OPT_EXPERT);
3922 show_help_options(options, "\nSubtitle options:\n",
3923 OPT_SUBTITLE | OPT_GRAB,
3925 show_help_options(options, "\nAudio/Video grab options:\n",
3929 class = avcodec_get_class();
3930 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3933 /* individual codec options */
3935 while ((c = av_codec_next(c))) {
3936 if (c->priv_class) {
3937 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3942 class = avformat_get_class();
3943 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3946 /* individual muxer options */
3947 while ((oformat = av_oformat_next(oformat))) {
3948 if (oformat->priv_class) {
3949 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3954 /* individual demuxer options */
3955 while ((iformat = av_iformat_next(iformat))) {
3956 if (iformat->priv_class) {
3957 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3962 class = sws_get_class();
3963 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3967 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3969 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3970 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3972 if(!strncmp(arg, "pal-", 4)) {
3975 } else if(!strncmp(arg, "ntsc-", 5)) {
3978 } else if(!strncmp(arg, "film-", 5)) {
3983 /* Calculate FR via float to avoid int overflow */
3984 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
3987 } else if((fr == 29970) || (fr == 23976)) {
3990 /* Try to determine PAL/NTSC by peeking in the input files */
3991 if(nb_input_files) {
3993 for (j = 0; j < nb_input_files; j++) {
3994 for (i = 0; i < input_files[j].nb_streams; i++) {
3995 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3996 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3998 fr = c->time_base.den * 1000 / c->time_base.num;
4002 } else if((fr == 29970) || (fr == 23976)) {
4012 if(verbose > 0 && norm != UNKNOWN)
4013 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4016 if(norm == UNKNOWN) {
4017 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4018 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4019 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4023 if(!strcmp(arg, "vcd")) {
4024 opt_video_codec(o, "c:v", "mpeg1video");
4025 opt_audio_codec(o, "c:a", "mp2");
4026 parse_option(o, "f", "vcd", options);
4028 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4029 opt_frame_rate("r", frame_rates[norm]);
4030 opt_default("g", norm == PAL ? "15" : "18");
4032 opt_default("b", "1150000");
4033 opt_default("maxrate", "1150000");
4034 opt_default("minrate", "1150000");
4035 opt_default("bufsize", "327680"); // 40*1024*8;
4037 opt_default("b:a", "224000");
4038 audio_sample_rate = 44100;
4041 opt_default("packetsize", "2324");
4042 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4044 /* We have to offset the PTS, so that it is consistent with the SCR.
4045 SCR starts at 36000, but the first two packs contain only padding
4046 and the first pack from the other stream, respectively, may also have
4047 been written before.
4048 So the real data starts at SCR 36000+3*1200. */
4049 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4050 } else if(!strcmp(arg, "svcd")) {
4052 opt_video_codec(o, "c:v", "mpeg2video");
4053 opt_audio_codec(o, "c:a", "mp2");
4054 parse_option(o, "f", "svcd", options);
4056 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4057 opt_frame_rate("r", frame_rates[norm]);
4058 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4059 opt_default("g", norm == PAL ? "15" : "18");
4061 opt_default("b", "2040000");
4062 opt_default("maxrate", "2516000");
4063 opt_default("minrate", "0"); //1145000;
4064 opt_default("bufsize", "1835008"); //224*1024*8;
4065 opt_default("flags", "+scan_offset");
4068 opt_default("b:a", "224000");
4069 audio_sample_rate = 44100;
4071 opt_default("packetsize", "2324");
4073 } else if(!strcmp(arg, "dvd")) {
4075 opt_video_codec(o, "c:v", "mpeg2video");
4076 opt_audio_codec(o, "c:a", "ac3");
4077 parse_option(o, "f", "dvd", options);
4079 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4080 opt_frame_rate("r", frame_rates[norm]);
4081 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4082 opt_default("g", norm == PAL ? "15" : "18");
4084 opt_default("b", "6000000");
4085 opt_default("maxrate", "9000000");
4086 opt_default("minrate", "0"); //1500000;
4087 opt_default("bufsize", "1835008"); //224*1024*8;
4089 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4090 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4092 opt_default("b:a", "448000");
4093 audio_sample_rate = 48000;
4095 } else if(!strncmp(arg, "dv", 2)) {
4097 parse_option(o, "f", "dv", options);
4099 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4100 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4101 norm == PAL ? "yuv420p" : "yuv411p");
4102 opt_frame_rate("r", frame_rates[norm]);
4104 audio_sample_rate = 48000;
4108 fprintf(stderr, "Unknown target: %s\n", arg);
4109 return AVERROR(EINVAL);
4114 static int opt_vstats_file(const char *opt, const char *arg)
4116 av_free (vstats_filename);
4117 vstats_filename=av_strdup (arg);
4121 static int opt_vstats(const char *opt, const char *arg)
4124 time_t today2 = time(NULL);
4125 struct tm *today = localtime(&today2);
4127 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4129 return opt_vstats_file(opt, filename);
4132 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4134 return parse_option(o, "frames:v", arg, options);
4137 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4139 return parse_option(o, "frames:a", arg, options);
4142 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4144 return parse_option(o, "frames:d", arg, options);
4147 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4151 static int opt_passlogfile(const char *opt, const char *arg)
4153 pass_logfilename_prefix = arg;
4154 #if CONFIG_LIBX264_ENCODER
4155 return opt_default("passlogfile", arg);
4161 #define OFFSET(x) offsetof(OptionsContext, x)
4162 static const OptionDef options[] = {
4164 #include "cmdutils_common_opts.h"
4165 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4166 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4167 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4168 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4169 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4170 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4171 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4172 "outfile[,metadata]:infile[,metadata]" },
4173 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4174 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4175 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4176 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4177 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4178 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4179 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4180 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4181 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4182 "add timings for benchmarking" },
4183 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4184 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4185 "dump each input packet" },
4186 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4187 "when dumping packets, also dump the payload" },
4188 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4189 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4190 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4191 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4192 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4193 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4194 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4195 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4196 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4197 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4198 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4199 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4200 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4201 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4204 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4205 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4206 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4207 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4208 { "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" },
4209 { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4210 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4211 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4212 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4213 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4214 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4215 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold", "threshold" },
4216 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4217 "use same quantizer as source (implies VBR)" },
4218 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4219 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4220 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4221 "deinterlace pictures" },
4222 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4223 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4224 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4226 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4228 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4229 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4230 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4231 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4232 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4233 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4234 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4235 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4236 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4237 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4240 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4241 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4242 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4243 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4244 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4245 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4246 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4247 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4248 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4249 { "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" },
4251 /* subtitle options */
4252 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4253 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4254 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4255 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4258 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4261 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4262 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4264 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4266 /* data codec support */
4267 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4269 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4273 int main(int argc, char **argv)
4275 OptionsContext o = { 0 };
4280 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4282 if(argc>1 && !strcmp(argv[1], "-d")){
4285 av_log_set_callback(log_callback_null);
4290 avcodec_register_all();
4292 avdevice_register_all();
4295 avfilter_register_all();
4300 if(isatty(STDIN_FILENO))
4301 avio_set_interrupt_cb(decode_interrupt_cb);
4308 parse_options(&o, argc, argv, options, opt_output_file);
4310 if(nb_output_files <= 0 && nb_input_files == 0) {
4312 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4316 /* file converter / grab */
4317 if (nb_output_files <= 0) {
4318 fprintf(stderr, "At least one output file must be specified\n");
4322 if (nb_input_files == 0) {
4323 fprintf(stderr, "At least one input file must be specified\n");
4328 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4330 ti = getutime() - ti;
4332 int maxrss = getmaxrss() / 1024;
4333 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);