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[] = "ffmpeg";
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 static int frame_bits_per_raw_sample = 0;
115 static int video_discard = 0;
116 static int same_quant = 0;
117 static int do_deinterlace = 0;
118 static int intra_dc_precision = 8;
119 static int loop_input = 0;
120 static int loop_output = AVFMT_NOOUTPUTLOOP;
121 static int qp_hist = 0;
122 static int intra_only = 0;
123 static const char *video_codec_name = NULL;
124 static const char *audio_codec_name = NULL;
125 static const char *subtitle_codec_name = NULL;
127 static int file_overwrite = 0;
128 static int do_benchmark = 0;
129 static int do_hex_dump = 0;
130 static int do_pkt_dump = 0;
131 static int do_pass = 0;
132 static const char *pass_logfilename_prefix;
133 static int video_sync_method= -1;
134 static int audio_sync_method= 0;
135 static float audio_drift_threshold= 0.1;
136 static int copy_ts= 0;
137 static int copy_tb= 0;
138 static int opt_shortest = 0;
139 static char *vstats_filename;
140 static FILE *vstats_file;
141 static int copy_initial_nonkeyframes = 0;
143 static int audio_volume = 256;
145 static int exit_on_error = 0;
146 static int using_stdin = 0;
147 static int verbose = 1;
148 static int run_as_daemon = 0;
149 static int q_pressed = 0;
150 static int64_t video_size = 0;
151 static int64_t audio_size = 0;
152 static int64_t extra_size = 0;
153 static int nb_frames_dup = 0;
154 static int nb_frames_drop = 0;
155 static int input_sync;
157 static float dts_delta_threshold = 10;
159 static uint8_t *audio_buf;
160 static uint8_t *audio_out;
161 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
163 static short *samples;
164 static uint8_t *input_tmp= NULL;
166 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
168 typedef struct InputStream {
171 int discard; /* true if stream data should be discarded */
172 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
175 int64_t start; /* time when read started */
176 int64_t next_pts; /* synthetic pts for cases where pkt.pts
178 int64_t pts; /* current pts */
180 int is_start; /* is 1 at the start and after a discontinuity */
181 int showed_multi_packet_warning;
185 typedef struct InputFile {
186 AVFormatContext *ctx;
187 int eof_reached; /* true if eof reached */
188 int ist_index; /* index of first stream in ist_table */
189 int buffer_size; /* current total buffer size */
191 int nb_streams; /* number of stream that avconv is aware of; may be different
192 from ctx.nb_streams if new streams appear during av_read_frame() */
196 typedef struct OutputStream {
197 int file_index; /* file index */
198 int index; /* stream index in the output file */
199 int source_index; /* InputStream index */
200 AVStream *st; /* stream in the output file */
201 int encoding_needed; /* true if encoding needed for this stream */
203 /* input pts and corresponding output pts
205 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
206 struct InputStream *sync_ist; /* input stream to sync against */
207 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
208 AVBitStreamFilterContext *bitstream_filters;
214 AVFrame resample_frame; /* temporary frame for image resampling */
215 struct SwsContext *img_resample_ctx; /* for image resampling */
218 int resample_pix_fmt;
219 AVRational frame_rate;
223 float frame_aspect_ratio;
225 /* forced key frames */
226 int64_t *forced_kf_pts;
232 ReSampleContext *resample; /* for audio resampling */
233 int resample_sample_fmt;
234 int resample_channels;
235 int resample_sample_rate;
237 AVAudioConvert *reformat_ctx;
238 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
242 AVFilterContext *output_video_filter;
243 AVFilterContext *input_video_filter;
244 AVFilterBufferRef *picref;
246 AVFilterGraph *graph;
251 int is_past_recording_time;
257 /* init terminal so that we can grab keys */
258 static struct termios oldtty;
261 typedef struct OutputFile {
262 AVFormatContext *ctx;
264 int ost_index; /* index of the first stream in output_streams */
265 int64_t recording_time; /* desired length of the resulting file in microseconds */
266 int64_t start_time; /* start time in microseconds */
267 uint64_t limit_filesize;
270 static InputStream *input_streams = NULL;
271 static int nb_input_streams = 0;
272 static InputFile *input_files = NULL;
273 static int nb_input_files = 0;
275 static OutputStream *output_streams = NULL;
276 static int nb_output_streams = 0;
277 static OutputFile *output_files = NULL;
278 static int nb_output_files = 0;
280 typedef struct OptionsContext {
281 /* input/output options */
285 SpecifierOpt *codec_names;
287 SpecifierOpt *audio_channels;
288 int nb_audio_channels;
289 SpecifierOpt *audio_sample_rate;
290 int nb_audio_sample_rate;
291 SpecifierOpt *frame_rates;
293 SpecifierOpt *frame_sizes;
295 SpecifierOpt *frame_pix_fmts;
296 int nb_frame_pix_fmts;
299 int64_t input_ts_offset;
302 SpecifierOpt *ts_scale;
306 StreamMap *stream_maps;
308 /* first item specifies output metadata, second is input */
309 MetadataMap (*meta_data_maps)[2];
310 int nb_meta_data_maps;
311 int metadata_global_manual;
312 int metadata_streams_manual;
313 int metadata_chapters_manual;
315 int chapters_input_file;
317 int64_t recording_time;
318 uint64_t limit_filesize;
324 int subtitle_disable;
327 /* indexed by output file stream index */
331 SpecifierOpt *metadata;
333 SpecifierOpt *max_frames;
335 SpecifierOpt *bitstream_filters;
336 int nb_bitstream_filters;
337 SpecifierOpt *codec_tags;
339 SpecifierOpt *sample_fmts;
341 SpecifierOpt *qscale;
343 SpecifierOpt *forced_key_frames;
344 int nb_forced_key_frames;
345 SpecifierOpt *force_fps;
347 SpecifierOpt *frame_aspect_ratios;
348 int nb_frame_aspect_ratios;
349 SpecifierOpt *rc_overrides;
351 SpecifierOpt *intra_matrices;
352 int nb_intra_matrices;
353 SpecifierOpt *inter_matrices;
354 int nb_inter_matrices;
355 SpecifierOpt *top_field_first;
356 int nb_top_field_first;
358 SpecifierOpt *filters;
363 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
366 for (i = 0; i < o->nb_ ## name; i++) {\
367 char *spec = o->name[i].specifier;\
368 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
369 outvar = o->name[i].u.type;\
375 static void reset_options(OptionsContext *o, int is_input)
377 const OptionDef *po = options;
378 OptionsContext bak= *o;
380 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
382 void *dst = (uint8_t*)o + po->u.off;
384 if (po->flags & OPT_SPEC) {
385 SpecifierOpt **so = dst;
386 int i, *count = (int*)(so + 1);
387 for (i = 0; i < *count; i++) {
388 av_freep(&(*so)[i].specifier);
389 if (po->flags & OPT_STRING)
390 av_freep(&(*so)[i].u.str);
394 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
399 av_freep(&o->stream_maps);
400 av_freep(&o->meta_data_maps);
401 av_freep(&o->streamid_map);
403 memset(o, 0, sizeof(*o));
405 if(is_input) o->recording_time = bak.recording_time;
406 else o->recording_time = INT64_MAX;
407 o->mux_preload = 0.5;
408 o->mux_max_delay = 0.7;
409 o->limit_filesize = UINT64_MAX;
410 o->chapters_input_file = INT_MAX;
418 static int configure_video_filters(InputStream *ist, OutputStream *ost)
420 AVFilterContext *last_filter, *filter;
421 /** filter graph containing all filters including input & output */
422 AVCodecContext *codec = ost->st->codec;
423 AVCodecContext *icodec = ist->st->codec;
424 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
425 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
426 AVRational sample_aspect_ratio;
430 ost->graph = avfilter_graph_alloc();
432 if (ist->st->sample_aspect_ratio.num){
433 sample_aspect_ratio = ist->st->sample_aspect_ratio;
435 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
437 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
438 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
439 sample_aspect_ratio.num, sample_aspect_ratio.den);
441 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
442 "src", args, NULL, ost->graph);
445 #if FF_API_OLD_VSINK_API
446 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
447 "out", NULL, pix_fmts, ost->graph);
449 buffersink_params->pixel_fmts = pix_fmts;
450 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
451 "out", NULL, buffersink_params, ost->graph);
453 av_freep(&buffersink_params);
456 last_filter = ost->input_video_filter;
458 if (codec->width != icodec->width || codec->height != icodec->height) {
459 snprintf(args, 255, "%d:%d:flags=0x%X",
463 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
464 NULL, args, NULL, ost->graph)) < 0)
466 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
468 last_filter = filter;
471 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
472 ost->graph->scale_sws_opts = av_strdup(args);
475 AVFilterInOut *outputs = avfilter_inout_alloc();
476 AVFilterInOut *inputs = avfilter_inout_alloc();
478 outputs->name = av_strdup("in");
479 outputs->filter_ctx = last_filter;
480 outputs->pad_idx = 0;
481 outputs->next = NULL;
483 inputs->name = av_strdup("out");
484 inputs->filter_ctx = ost->output_video_filter;
488 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
490 av_freep(&ost->avfilter);
492 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
496 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
499 codec->width = ost->output_video_filter->inputs[0]->w;
500 codec->height = ost->output_video_filter->inputs[0]->h;
501 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
502 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
503 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
504 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
508 #endif /* CONFIG_AVFILTER */
510 static void term_exit(void)
512 av_log(NULL, AV_LOG_QUIET, "%s", "");
515 tcsetattr (0, TCSANOW, &oldtty);
519 static volatile int received_sigterm = 0;
521 static void sigterm_handler(int sig)
523 received_sigterm = sig;
528 static void term_init(void)
538 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
539 |INLCR|IGNCR|ICRNL|IXON);
540 tty.c_oflag |= OPOST;
541 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
542 tty.c_cflag &= ~(CSIZE|PARENB);
547 tcsetattr (0, TCSANOW, &tty);
548 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
552 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
553 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
555 signal(SIGXCPU, sigterm_handler);
559 /* read a key without blocking */
560 static int read_key(void)
575 n = select(1, &rfds, NULL, NULL, &tv);
584 # if HAVE_PEEKNAMEDPIPE
586 static HANDLE input_handle;
589 input_handle = GetStdHandle(STD_INPUT_HANDLE);
590 is_pipe = !GetConsoleMode(input_handle, &dw);
593 if (stdin->_cnt > 0) {
598 /* When running under a GUI, you will end here. */
599 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
616 static int decode_interrupt_cb(void)
618 q_pressed += read_key() == 'q';
619 return q_pressed > 1;
622 void exit_program(int ret)
627 for(i=0;i<nb_output_files;i++) {
628 AVFormatContext *s = output_files[i].ctx;
629 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
631 avformat_free_context(s);
632 av_dict_free(&output_files[i].opts);
634 for(i=0;i<nb_input_files;i++) {
635 av_close_input_file(input_files[i].ctx);
637 for (i = 0; i < nb_input_streams; i++)
638 av_dict_free(&input_streams[i].opts);
642 av_free(vstats_filename);
644 av_freep(&input_streams);
645 av_freep(&input_files);
646 av_freep(&output_streams);
647 av_freep(&output_files);
652 allocated_audio_buf_size= allocated_audio_out_size= 0;
659 av_freep(&input_tmp);
661 if (received_sigterm) {
663 "Received signal %d: terminating.\n",
664 (int) received_sigterm);
668 exit(ret); /* not all OS-es handle main() return value */
671 static void assert_avoptions(AVDictionary *m)
673 AVDictionaryEntry *t;
674 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
675 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
680 static void assert_codec_experimental(AVCodecContext *c, int encoder)
682 const char *codec_string = encoder ? "encoder" : "decoder";
684 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
685 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
686 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
687 "results.\nAdd '-strict experimental' if you want to use it.\n",
688 codec_string, c->codec->name);
689 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
690 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
691 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
692 codec_string, codec->name);
697 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
699 if(codec && codec->sample_fmts){
700 const enum AVSampleFormat *p= codec->sample_fmts;
702 if(*p == st->codec->sample_fmt)
706 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
707 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
708 if(av_get_sample_fmt_name(st->codec->sample_fmt))
709 av_log(NULL, AV_LOG_WARNING,
710 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
711 av_get_sample_fmt_name(st->codec->sample_fmt),
713 av_get_sample_fmt_name(codec->sample_fmts[0]));
714 st->codec->sample_fmt = codec->sample_fmts[0];
719 static void choose_sample_rate(AVStream *st, AVCodec *codec)
721 if(codec && codec->supported_samplerates){
722 const int *p= codec->supported_samplerates;
724 int best_dist=INT_MAX;
726 int dist= abs(st->codec->sample_rate - *p);
727 if(dist < best_dist){
733 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
735 st->codec->sample_rate= best;
739 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
741 if(codec && codec->pix_fmts){
742 const enum PixelFormat *p= codec->pix_fmts;
743 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
744 if(st->codec->codec_id==CODEC_ID_MJPEG){
745 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
746 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
747 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};
751 if(*p == st->codec->pix_fmt)
755 if(st->codec->pix_fmt != PIX_FMT_NONE)
756 av_log(NULL, AV_LOG_WARNING,
757 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
758 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
760 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
761 st->codec->pix_fmt = codec->pix_fmts[0];
766 static double get_sync_ipts(const OutputStream *ost)
768 const InputStream *ist = ost->sync_ist;
769 OutputFile *of = &output_files[ost->file_index];
770 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
773 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
778 AVPacket new_pkt= *pkt;
779 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
780 &new_pkt.data, &new_pkt.size,
781 pkt->data, pkt->size,
782 pkt->flags & AV_PKT_FLAG_KEY);
785 new_pkt.destruct= av_destruct_packet;
787 fprintf(stderr, "%s failed for stream %d, codec %s",
788 bsfc->filter->name, pkt->stream_index,
789 avctx->codec ? avctx->codec->name : "copy");
799 ret= av_interleaved_write_frame(s, pkt);
801 print_error("av_interleaved_write_frame()", ret);
806 static void do_audio_out(AVFormatContext *s,
809 unsigned char *buf, int size)
812 int64_t audio_out_size, audio_buf_size;
813 int64_t allocated_for_size= size;
815 int size_out, frame_bytes, ret, resample_changed;
816 AVCodecContext *enc= ost->st->codec;
817 AVCodecContext *dec= ist->st->codec;
818 int osize = av_get_bytes_per_sample(enc->sample_fmt);
819 int isize = av_get_bytes_per_sample(dec->sample_fmt);
820 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
823 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
824 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
825 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
826 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
827 audio_buf_size*= osize*enc->channels;
829 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
830 if(coded_bps > 8*osize)
831 audio_out_size= audio_out_size * coded_bps / (8*osize);
832 audio_out_size += FF_MIN_BUFFER_SIZE;
834 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
835 fprintf(stderr, "Buffer sizes too large\n");
839 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
840 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
841 if (!audio_buf || !audio_out){
842 fprintf(stderr, "Out of memory in do_audio_out\n");
846 if (enc->channels != dec->channels)
847 ost->audio_resample = 1;
849 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
850 ost->resample_channels != dec->channels ||
851 ost->resample_sample_rate != dec->sample_rate;
853 if ((ost->audio_resample && !ost->resample) || resample_changed) {
854 if (resample_changed) {
855 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",
856 ist->file_index, ist->st->index,
857 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
858 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
859 ost->resample_sample_fmt = dec->sample_fmt;
860 ost->resample_channels = dec->channels;
861 ost->resample_sample_rate = dec->sample_rate;
863 audio_resample_close(ost->resample);
865 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
866 if (audio_sync_method <= 1 &&
867 ost->resample_sample_fmt == enc->sample_fmt &&
868 ost->resample_channels == enc->channels &&
869 ost->resample_sample_rate == enc->sample_rate) {
870 ost->resample = NULL;
871 ost->audio_resample = 0;
873 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
874 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
875 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
876 enc->sample_rate, dec->sample_rate,
877 enc->sample_fmt, dec->sample_fmt,
879 if (!ost->resample) {
880 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
881 dec->channels, dec->sample_rate,
882 enc->channels, enc->sample_rate);
888 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
889 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
890 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
891 if (ost->reformat_ctx)
892 av_audio_convert_free(ost->reformat_ctx);
893 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
894 dec->sample_fmt, 1, NULL, 0);
895 if (!ost->reformat_ctx) {
896 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
897 av_get_sample_fmt_name(dec->sample_fmt),
898 av_get_sample_fmt_name(enc->sample_fmt));
901 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
904 if(audio_sync_method){
905 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
906 - av_fifo_size(ost->fifo)/(enc->channels * 2);
907 double idelta= delta*dec->sample_rate / enc->sample_rate;
908 int byte_delta= ((int)idelta)*2*dec->channels;
910 //FIXME resample delay
911 if(fabs(delta) > 50){
912 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
914 byte_delta= FFMAX(byte_delta, -size);
918 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
923 input_tmp= av_realloc(input_tmp, byte_delta + size);
925 if(byte_delta > allocated_for_size - size){
926 allocated_for_size= byte_delta + (int64_t)size;
931 memset(input_tmp, 0, byte_delta);
932 memcpy(input_tmp + byte_delta, buf, size);
936 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
938 }else if(audio_sync_method>1){
939 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
940 av_assert0(ost->audio_resample);
942 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
943 // 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));
944 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
948 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
949 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
951 if (ost->audio_resample) {
953 size_out = audio_resample(ost->resample,
954 (short *)buftmp, (short *)buf,
955 size / (dec->channels * isize));
956 size_out = size_out * enc->channels * osize;
962 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
963 const void *ibuf[6]= {buftmp};
964 void *obuf[6]= {audio_buf};
965 int istride[6]= {isize};
966 int ostride[6]= {osize};
967 int len= size_out/istride[0];
968 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
969 printf("av_audio_convert() failed\n");
975 size_out = len*osize;
978 /* now encode as many frames as possible */
979 if (enc->frame_size > 1) {
980 /* output resampled raw samples */
981 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
982 fprintf(stderr, "av_fifo_realloc2() failed\n");
985 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
987 frame_bytes = enc->frame_size * osize * enc->channels;
989 while (av_fifo_size(ost->fifo) >= frame_bytes) {
991 av_init_packet(&pkt);
993 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
995 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
997 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1000 fprintf(stderr, "Audio encoding failed\n");
1004 pkt.stream_index= ost->index;
1005 pkt.data= audio_out;
1007 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1008 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1009 pkt.flags |= AV_PKT_FLAG_KEY;
1010 write_frame(s, &pkt, enc, ost->bitstream_filters);
1012 ost->sync_opts += enc->frame_size;
1016 av_init_packet(&pkt);
1018 ost->sync_opts += size_out / (osize * enc->channels);
1020 /* output a pcm frame */
1021 /* determine the size of the coded buffer */
1024 size_out = size_out*coded_bps/8;
1026 if(size_out > audio_out_size){
1027 fprintf(stderr, "Internal error, buffer size too small\n");
1031 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1032 ret = avcodec_encode_audio(enc, audio_out, size_out,
1035 fprintf(stderr, "Audio encoding failed\n");
1039 pkt.stream_index= ost->index;
1040 pkt.data= audio_out;
1042 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1043 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1044 pkt.flags |= AV_PKT_FLAG_KEY;
1045 write_frame(s, &pkt, enc, ost->bitstream_filters);
1049 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1051 AVCodecContext *dec;
1052 AVPicture *picture2;
1053 AVPicture picture_tmp;
1056 dec = ist->st->codec;
1058 /* deinterlace : must be done before any resize */
1059 if (do_deinterlace) {
1062 /* create temporary picture */
1063 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1064 buf = av_malloc(size);
1068 picture2 = &picture_tmp;
1069 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1071 if(avpicture_deinterlace(picture2, picture,
1072 dec->pix_fmt, dec->width, dec->height) < 0) {
1073 /* if error, do not deinterlace */
1074 fprintf(stderr, "Deinterlacing failed\n");
1083 if (picture != picture2)
1084 *picture = *picture2;
1088 static void do_subtitle_out(AVFormatContext *s,
1094 static uint8_t *subtitle_out = NULL;
1095 int subtitle_out_max_size = 1024 * 1024;
1096 int subtitle_out_size, nb, i;
1097 AVCodecContext *enc;
1100 if (pts == AV_NOPTS_VALUE) {
1101 fprintf(stderr, "Subtitle packets must have a pts\n");
1107 enc = ost->st->codec;
1109 if (!subtitle_out) {
1110 subtitle_out = av_malloc(subtitle_out_max_size);
1113 /* Note: DVB subtitle need one packet to draw them and one other
1114 packet to clear them */
1115 /* XXX: signal it in the codec context ? */
1116 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1121 for(i = 0; i < nb; i++) {
1122 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1123 // start_display_time is required to be 0
1124 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1125 sub->end_display_time -= sub->start_display_time;
1126 sub->start_display_time = 0;
1127 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1128 subtitle_out_max_size, sub);
1129 if (subtitle_out_size < 0) {
1130 fprintf(stderr, "Subtitle encoding failed\n");
1134 av_init_packet(&pkt);
1135 pkt.stream_index = ost->index;
1136 pkt.data = subtitle_out;
1137 pkt.size = subtitle_out_size;
1138 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1139 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1140 /* XXX: the pts correction is handled here. Maybe handling
1141 it in the codec would be better */
1143 pkt.pts += 90 * sub->start_display_time;
1145 pkt.pts += 90 * sub->end_display_time;
1147 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1151 static int bit_buffer_size= 1024*256;
1152 static uint8_t *bit_buffer= NULL;
1154 static void do_video_resample(OutputStream *ost,
1156 AVFrame *in_picture,
1157 AVFrame **out_picture)
1160 *out_picture = in_picture;
1162 AVCodecContext *dec = ist->st->codec;
1163 AVCodecContext *enc = ost->st->codec;
1164 int resample_changed = ost->resample_width != dec->width ||
1165 ost->resample_height != dec->height ||
1166 ost->resample_pix_fmt != dec->pix_fmt;
1168 *out_picture = in_picture;
1169 if (resample_changed) {
1170 av_log(NULL, AV_LOG_INFO,
1171 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1172 ist->file_index, ist->st->index,
1173 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1174 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1175 ost->resample_width = dec->width;
1176 ost->resample_height = dec->height;
1177 ost->resample_pix_fmt = dec->pix_fmt;
1180 ost->video_resample = dec->width != enc->width ||
1181 dec->height != enc->height ||
1182 dec->pix_fmt != enc->pix_fmt;
1184 if (ost->video_resample) {
1185 *out_picture = &ost->resample_frame;
1186 if (!ost->img_resample_ctx || resample_changed) {
1187 /* initialize the destination picture */
1188 if (!ost->resample_frame.data[0]) {
1189 avcodec_get_frame_defaults(&ost->resample_frame);
1190 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1191 enc->width, enc->height)) {
1192 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1196 /* initialize a new scaler context */
1197 sws_freeContext(ost->img_resample_ctx);
1198 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1199 enc->width, enc->height, enc->pix_fmt,
1200 ost->sws_flags, NULL, NULL, NULL);
1201 if (ost->img_resample_ctx == NULL) {
1202 fprintf(stderr, "Cannot get resampling context\n");
1206 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1207 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1213 static void do_video_out(AVFormatContext *s,
1216 AVFrame *in_picture,
1217 int *frame_size, float quality)
1219 int nb_frames, i, ret, format_video_sync;
1220 AVFrame *final_picture;
1221 AVCodecContext *enc;
1224 enc = ost->st->codec;
1226 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1228 /* by default, we output a single frame */
1233 format_video_sync = video_sync_method;
1234 if (format_video_sync < 0)
1235 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1237 if (format_video_sync) {
1238 double vdelta = sync_ipts - ost->sync_opts;
1239 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1242 else if (format_video_sync == 2) {
1245 }else if(vdelta>0.6)
1246 ost->sync_opts= lrintf(sync_ipts);
1247 }else if (vdelta > 1.1)
1248 nb_frames = lrintf(vdelta);
1249 //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);
1250 if (nb_frames == 0){
1253 fprintf(stderr, "*** drop!\n");
1254 }else if (nb_frames > 1) {
1255 nb_frames_dup += nb_frames - 1;
1257 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1260 ost->sync_opts= lrintf(sync_ipts);
1262 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1266 do_video_resample(ost, ist, in_picture, &final_picture);
1268 /* duplicates frame if needed */
1269 for(i=0;i<nb_frames;i++) {
1271 av_init_packet(&pkt);
1272 pkt.stream_index= ost->index;
1274 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1275 /* raw pictures are written as AVPicture structure to
1276 avoid any copies. We support temporarily the older
1278 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1279 enc->coded_frame->top_field_first = in_picture->top_field_first;
1280 pkt.data= (uint8_t *)final_picture;
1281 pkt.size= sizeof(AVPicture);
1282 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1283 pkt.flags |= AV_PKT_FLAG_KEY;
1285 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1287 AVFrame big_picture;
1289 big_picture= *final_picture;
1290 /* better than nothing: use input picture interlaced
1292 big_picture.interlaced_frame = in_picture->interlaced_frame;
1293 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1294 if (ost->top_field_first == -1)
1295 big_picture.top_field_first = in_picture->top_field_first;
1297 big_picture.top_field_first = !!ost->top_field_first;
1300 /* handles same_quant here. This is not correct because it may
1301 not be a global option */
1302 big_picture.quality = quality;
1303 if (!enc->me_threshold)
1304 big_picture.pict_type = 0;
1305 // big_picture.pts = AV_NOPTS_VALUE;
1306 big_picture.pts= ost->sync_opts;
1307 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1308 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1309 if (ost->forced_kf_index < ost->forced_kf_count &&
1310 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1311 big_picture.pict_type = AV_PICTURE_TYPE_I;
1312 ost->forced_kf_index++;
1314 ret = avcodec_encode_video(enc,
1315 bit_buffer, bit_buffer_size,
1318 fprintf(stderr, "Video encoding failed\n");
1323 pkt.data= bit_buffer;
1325 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1326 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1327 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1328 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1329 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1331 if(enc->coded_frame->key_frame)
1332 pkt.flags |= AV_PKT_FLAG_KEY;
1333 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1336 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1337 // enc->frame_number-1, ret, enc->pict_type);
1338 /* if two pass, output log */
1339 if (ost->logfile && enc->stats_out) {
1340 fprintf(ost->logfile, "%s", enc->stats_out);
1345 ost->frame_number++;
1349 static double psnr(double d)
1351 return -10.0*log(d)/log(10.0);
1354 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1357 AVCodecContext *enc;
1359 double ti1, bitrate, avg_bitrate;
1361 /* this is executed just the first time do_video_stats is called */
1363 vstats_file = fopen(vstats_filename, "w");
1370 enc = ost->st->codec;
1371 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1372 frame_number = ost->frame_number;
1373 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1374 if (enc->flags&CODEC_FLAG_PSNR)
1375 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1377 fprintf(vstats_file,"f_size= %6d ", frame_size);
1378 /* compute pts value */
1379 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1383 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1384 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1385 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1386 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1387 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1391 static void print_report(OutputFile *output_files,
1392 OutputStream *ost_table, int nb_ostreams,
1393 int is_last_report, int64_t timer_start)
1397 AVFormatContext *oc;
1399 AVCodecContext *enc;
1400 int frame_number, vid, i;
1402 int64_t pts = INT64_MAX;
1403 static int64_t last_time = -1;
1404 static int qp_histogram[52];
1406 if (!is_last_report) {
1408 /* display the report every 0.5 seconds */
1409 cur_time = av_gettime();
1410 if (last_time == -1) {
1411 last_time = cur_time;
1414 if ((cur_time - last_time) < 500000)
1416 last_time = cur_time;
1420 oc = output_files[0].ctx;
1422 total_size = avio_size(oc->pb);
1423 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1424 total_size= avio_tell(oc->pb);
1428 for(i=0;i<nb_ostreams;i++) {
1430 ost = &ost_table[i];
1431 enc = ost->st->codec;
1432 if (!ost->st->stream_copy && enc->coded_frame)
1433 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1434 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1435 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1437 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1438 float t = (av_gettime()-timer_start) / 1000000.0;
1440 frame_number = ost->frame_number;
1441 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1442 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1444 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1448 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1451 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1453 if (enc->flags&CODEC_FLAG_PSNR){
1455 double error, error_sum=0;
1456 double scale, scale_sum=0;
1457 char type[3]= {'Y','U','V'};
1458 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1461 error= enc->error[j];
1462 scale= enc->width*enc->height*255.0*255.0*frame_number;
1464 error= enc->coded_frame->error[j];
1465 scale= enc->width*enc->height*255.0*255.0;
1470 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1472 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1476 /* compute min output value */
1477 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1478 ost->st->time_base, AV_TIME_BASE_Q));
1481 if (verbose > 0 || is_last_report) {
1482 int hours, mins, secs, us;
1483 secs = pts / AV_TIME_BASE;
1484 us = pts % AV_TIME_BASE;
1490 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1492 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1493 "size=%8.0fkB time=", total_size / 1024.0);
1494 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1495 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1496 (100 * us) / AV_TIME_BASE);
1497 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1498 "bitrate=%6.1fkbits/s", bitrate);
1500 if (nb_frames_dup || nb_frames_drop)
1501 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1502 nb_frames_dup, nb_frames_drop);
1505 fprintf(stderr, "%s \r", buf);
1510 if (is_last_report && verbose >= 0){
1511 int64_t raw= audio_size + video_size + extra_size;
1512 fprintf(stderr, "\n");
1513 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1517 100.0*(total_size - raw)/raw
1522 static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
1524 int fill_char = 0x00;
1525 if (sample_fmt == AV_SAMPLE_FMT_U8)
1527 memset(buf, fill_char, size);
1530 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1534 for (i = 0; i < nb_ostreams; i++) {
1535 OutputStream *ost = &ost_table[i];
1536 AVCodecContext *enc = ost->st->codec;
1537 AVFormatContext *os = output_files[ost->file_index].ctx;
1539 if (!ost->encoding_needed)
1542 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1544 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1550 av_init_packet(&pkt);
1551 pkt.stream_index= ost->index;
1553 switch (ost->st->codec->codec_type) {
1554 case AVMEDIA_TYPE_AUDIO:
1555 fifo_bytes = av_fifo_size(ost->fifo);
1557 /* encode any samples remaining in fifo */
1558 if (fifo_bytes > 0) {
1559 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1560 int fs_tmp = enc->frame_size;
1562 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1563 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1564 enc->frame_size = fifo_bytes / (osize * enc->channels);
1566 int frame_bytes = enc->frame_size*osize*enc->channels;
1567 if (allocated_audio_buf_size < frame_bytes)
1569 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1572 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1573 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1574 ost->st->time_base.num, enc->sample_rate);
1575 enc->frame_size = fs_tmp;
1578 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1581 fprintf(stderr, "Audio encoding failed\n");
1585 pkt.flags |= AV_PKT_FLAG_KEY;
1587 case AVMEDIA_TYPE_VIDEO:
1588 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1590 fprintf(stderr, "Video encoding failed\n");
1594 if(enc->coded_frame && enc->coded_frame->key_frame)
1595 pkt.flags |= AV_PKT_FLAG_KEY;
1596 if (ost->logfile && enc->stats_out) {
1597 fprintf(ost->logfile, "%s", enc->stats_out);
1606 pkt.data = bit_buffer;
1608 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1609 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1610 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1615 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1616 static int output_packet(InputStream *ist, int ist_index,
1617 OutputStream *ost_table, int nb_ostreams,
1618 const AVPacket *pkt)
1620 AVFormatContext *os;
1625 void *buffer_to_free = NULL;
1626 static unsigned int samples_size= 0;
1627 AVSubtitle subtitle, *subtitle_to_free;
1628 int64_t pkt_pts = AV_NOPTS_VALUE;
1630 int frame_available;
1635 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1637 if(ist->next_pts == AV_NOPTS_VALUE)
1638 ist->next_pts= ist->pts;
1642 av_init_packet(&avpkt);
1650 if(pkt->dts != AV_NOPTS_VALUE)
1651 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1652 if(pkt->pts != AV_NOPTS_VALUE)
1653 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1655 //while we have more to decode or while the decoder did output something on EOF
1656 while (avpkt.size > 0 || (!pkt && got_output)) {
1657 uint8_t *data_buf, *decoded_data_buf;
1658 int data_size, decoded_data_size;
1660 ist->pts= ist->next_pts;
1662 if(avpkt.size && avpkt.size != pkt->size &&
1663 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1664 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1665 ist->showed_multi_packet_warning=1;
1668 /* decode the packet if needed */
1669 decoded_data_buf = NULL; /* fail safe */
1670 decoded_data_size= 0;
1671 data_buf = avpkt.data;
1672 data_size = avpkt.size;
1673 subtitle_to_free = NULL;
1674 if (ist->decoding_needed) {
1675 switch(ist->st->codec->codec_type) {
1676 case AVMEDIA_TYPE_AUDIO:{
1677 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1678 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1680 samples= av_malloc(samples_size);
1682 decoded_data_size= samples_size;
1683 /* XXX: could avoid copy if PCM 16 bits with same
1684 endianness as CPU */
1685 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1692 got_output = decoded_data_size > 0;
1693 /* Some bug in mpeg audio decoder gives */
1694 /* decoded_data_size < 0, it seems they are overflows */
1696 /* no audio frame */
1699 decoded_data_buf = (uint8_t *)samples;
1700 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1701 (ist->st->codec->sample_rate * ist->st->codec->channels);
1703 case AVMEDIA_TYPE_VIDEO:
1704 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1705 /* XXX: allocate picture correctly */
1706 avcodec_get_frame_defaults(&picture);
1707 avpkt.pts = pkt_pts;
1708 avpkt.dts = ist->pts;
1709 pkt_pts = AV_NOPTS_VALUE;
1711 ret = avcodec_decode_video2(ist->st->codec,
1712 &picture, &got_output, &avpkt);
1713 quality = same_quant ? picture.quality : 0;
1717 /* no picture yet */
1718 goto discard_packet;
1720 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1721 if (ist->st->codec->time_base.num != 0) {
1722 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1723 ist->next_pts += ((int64_t)AV_TIME_BASE *
1724 ist->st->codec->time_base.num * ticks) /
1725 ist->st->codec->time_base.den;
1728 buffer_to_free = NULL;
1729 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1731 case AVMEDIA_TYPE_SUBTITLE:
1732 ret = avcodec_decode_subtitle2(ist->st->codec,
1733 &subtitle, &got_output, &avpkt);
1737 goto discard_packet;
1739 subtitle_to_free = &subtitle;
1746 switch(ist->st->codec->codec_type) {
1747 case AVMEDIA_TYPE_AUDIO:
1748 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1749 ist->st->codec->sample_rate;
1751 case AVMEDIA_TYPE_VIDEO:
1752 if (ist->st->codec->time_base.num != 0) {
1753 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1754 ist->next_pts += ((int64_t)AV_TIME_BASE *
1755 ist->st->codec->time_base.num * ticks) /
1756 ist->st->codec->time_base.den;
1764 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1765 for(i=0;i<nb_ostreams;i++) {
1766 OutputFile *of = &output_files[ost_table[i].file_index];
1767 if (of->start_time == 0 || ist->pts >= of->start_time) {
1768 ost = &ost_table[i];
1769 if (ost->input_video_filter && ost->source_index == ist_index) {
1770 if (!picture.sample_aspect_ratio.num)
1771 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1772 picture.pts = ist->pts;
1774 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1780 // preprocess audio (volume)
1781 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1782 if (audio_volume != 256) {
1785 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1786 int v = ((*volp) * audio_volume + 128) >> 8;
1787 *volp++ = av_clip_int16(v);
1792 /* frame rate emulation */
1793 if (input_files[ist->file_index].rate_emu) {
1794 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1795 int64_t now = av_gettime() - ist->start;
1799 /* if output time reached then transcode raw format,
1800 encode packets and output them */
1801 for (i = 0; i < nb_ostreams; i++) {
1802 OutputFile *of = &output_files[ost_table[i].file_index];
1805 ost = &ost_table[i];
1806 if (ost->source_index != ist_index)
1809 if (of->start_time && ist->pts < of->start_time)
1812 if (of->recording_time != INT64_MAX &&
1813 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1814 (AVRational){1, 1000000}) >= 0) {
1815 ost->is_past_recording_time = 1;
1820 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1821 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1822 while (frame_available) {
1823 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1824 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1825 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1828 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1829 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1833 os = output_files[ost->file_index].ctx;
1835 /* set the input output pts pairs */
1836 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1838 if (ost->encoding_needed) {
1839 av_assert0(ist->decoding_needed);
1840 switch(ost->st->codec->codec_type) {
1841 case AVMEDIA_TYPE_AUDIO:
1842 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1844 case AVMEDIA_TYPE_VIDEO:
1846 if (ost->picref->video && !ost->frame_aspect_ratio)
1847 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1849 do_video_out(os, ost, ist, &picture, &frame_size,
1850 same_quant ? quality : ost->st->codec->global_quality);
1851 if (vstats_filename && frame_size)
1852 do_video_stats(os, ost, frame_size);
1854 case AVMEDIA_TYPE_SUBTITLE:
1855 do_subtitle_out(os, ost, ist, &subtitle,
1862 AVFrame avframe; //FIXME/XXX remove this
1865 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1866 av_init_packet(&opkt);
1868 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1869 #if !CONFIG_AVFILTER
1875 /* no reencoding needed : output the packet directly */
1876 /* force the input stream PTS */
1878 avcodec_get_frame_defaults(&avframe);
1879 ost->st->codec->coded_frame= &avframe;
1880 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1882 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1883 audio_size += data_size;
1884 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1885 video_size += data_size;
1889 opkt.stream_index= ost->index;
1890 if(pkt->pts != AV_NOPTS_VALUE)
1891 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1893 opkt.pts= AV_NOPTS_VALUE;
1895 if (pkt->dts == AV_NOPTS_VALUE)
1896 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1898 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1899 opkt.dts -= ost_tb_start_time;
1901 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1902 opkt.flags= pkt->flags;
1904 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1905 if( ost->st->codec->codec_id != CODEC_ID_H264
1906 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1907 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1909 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1910 opkt.destruct= av_destruct_packet;
1912 opkt.data = data_buf;
1913 opkt.size = data_size;
1916 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1917 /* store AVPicture in AVPacket, as expected by the output format */
1918 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1919 opkt.data = (uint8_t *)&pict;
1920 opkt.size = sizeof(AVPicture);
1921 opkt.flags |= AV_PKT_FLAG_KEY;
1923 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1924 ost->st->codec->frame_number++;
1925 ost->frame_number++;
1926 av_free_packet(&opkt);
1930 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1931 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1932 avfilter_unref_buffer(ost->picref);
1937 av_free(buffer_to_free);
1938 /* XXX: allocate the subtitles in the codec ? */
1939 if (subtitle_to_free) {
1940 avsubtitle_free(subtitle_to_free);
1941 subtitle_to_free = NULL;
1949 static void print_sdp(OutputFile *output_files, int n)
1953 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1957 for (i = 0; i < n; i++)
1958 avc[i] = output_files[i].ctx;
1960 av_sdp_create(avc, n, sdp, sizeof(sdp));
1961 printf("SDP:\n%s\n", sdp);
1966 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1967 char *error, int error_len)
1969 InputStream *ist = &input_streams[ist_index];
1970 if (ist->decoding_needed) {
1971 AVCodec *codec = ist->dec;
1973 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
1974 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1975 return AVERROR(EINVAL);
1977 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1978 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1979 ist->file_index, ist->st->index);
1980 return AVERROR(EINVAL);
1982 assert_codec_experimental(ist->st->codec, 0);
1983 assert_avoptions(ist->opts);
1986 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;
1987 ist->next_pts = AV_NOPTS_VALUE;
1993 static int transcode_init(OutputFile *output_files, int nb_output_files,
1994 InputFile *input_files, int nb_input_files)
1996 int ret = 0, i, j, k;
1997 AVFormatContext *os;
1998 AVCodecContext *codec, *icodec;
2004 /* init framerate emulation */
2005 for (i = 0; i < nb_input_files; i++) {
2006 InputFile *ifile = &input_files[i];
2007 if (ifile->rate_emu)
2008 for (j = 0; j < ifile->nb_streams; j++)
2009 input_streams[j + ifile->ist_index].start = av_gettime();
2012 /* output stream init */
2013 for(i=0;i<nb_output_files;i++) {
2014 os = output_files[i].ctx;
2015 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2016 av_dump_format(os, i, os->filename, 1);
2017 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2018 return AVERROR(EINVAL);
2022 /* for each output stream, we compute the right encoding parameters */
2023 for (i = 0; i < nb_output_streams; i++) {
2024 ost = &output_streams[i];
2025 os = output_files[ost->file_index].ctx;
2026 ist = &input_streams[ost->source_index];
2028 codec = ost->st->codec;
2029 icodec = ist->st->codec;
2031 ost->st->disposition = ist->st->disposition;
2032 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2033 codec->chroma_sample_location = icodec->chroma_sample_location;
2035 if (ost->st->stream_copy) {
2036 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2038 if (extra_size > INT_MAX) {
2039 return AVERROR(EINVAL);
2042 /* if stream_copy is selected, no need to decode or encode */
2043 codec->codec_id = icodec->codec_id;
2044 codec->codec_type = icodec->codec_type;
2046 if(!codec->codec_tag){
2047 if( !os->oformat->codec_tag
2048 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2049 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2050 codec->codec_tag = icodec->codec_tag;
2053 codec->bit_rate = icodec->bit_rate;
2054 codec->rc_max_rate = icodec->rc_max_rate;
2055 codec->rc_buffer_size = icodec->rc_buffer_size;
2056 codec->extradata= av_mallocz(extra_size);
2057 if (!codec->extradata) {
2058 return AVERROR(ENOMEM);
2060 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2061 codec->extradata_size= icodec->extradata_size;
2063 codec->time_base = ist->st->time_base;
2064 if(!strcmp(os->oformat->name, "avi")) {
2065 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){
2066 codec->time_base = icodec->time_base;
2067 codec->time_base.num *= icodec->ticks_per_frame;
2068 codec->time_base.den *= 2;
2070 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2071 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){
2072 codec->time_base = icodec->time_base;
2073 codec->time_base.num *= icodec->ticks_per_frame;
2076 av_reduce(&codec->time_base.num, &codec->time_base.den,
2077 codec->time_base.num, codec->time_base.den, INT_MAX);
2079 switch(codec->codec_type) {
2080 case AVMEDIA_TYPE_AUDIO:
2081 if(audio_volume != 256) {
2082 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2085 codec->channel_layout = icodec->channel_layout;
2086 codec->sample_rate = icodec->sample_rate;
2087 codec->channels = icodec->channels;
2088 codec->frame_size = icodec->frame_size;
2089 codec->audio_service_type = icodec->audio_service_type;
2090 codec->block_align= icodec->block_align;
2091 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2092 codec->block_align= 0;
2093 if(codec->codec_id == CODEC_ID_AC3)
2094 codec->block_align= 0;
2096 case AVMEDIA_TYPE_VIDEO:
2097 codec->pix_fmt = icodec->pix_fmt;
2098 codec->width = icodec->width;
2099 codec->height = icodec->height;
2100 codec->has_b_frames = icodec->has_b_frames;
2101 if (!codec->sample_aspect_ratio.num) {
2102 codec->sample_aspect_ratio =
2103 ost->st->sample_aspect_ratio =
2104 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2105 ist->st->codec->sample_aspect_ratio.num ?
2106 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2109 case AVMEDIA_TYPE_SUBTITLE:
2110 codec->width = icodec->width;
2111 codec->height = icodec->height;
2113 case AVMEDIA_TYPE_DATA:
2120 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2121 switch(codec->codec_type) {
2122 case AVMEDIA_TYPE_AUDIO:
2123 ost->fifo= av_fifo_alloc(1024);
2125 return AVERROR(ENOMEM);
2127 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2128 if (!codec->sample_rate) {
2129 codec->sample_rate = icodec->sample_rate;
2131 choose_sample_rate(ost->st, ost->enc);
2132 codec->time_base = (AVRational){1, codec->sample_rate};
2133 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2134 codec->sample_fmt = icodec->sample_fmt;
2135 choose_sample_fmt(ost->st, ost->enc);
2136 if (!codec->channels) {
2137 codec->channels = icodec->channels;
2138 codec->channel_layout = icodec->channel_layout;
2140 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2141 codec->channel_layout = 0;
2142 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2143 icodec->request_channels = codec->channels;
2144 ist->decoding_needed = 1;
2145 ost->encoding_needed = 1;
2146 ost->resample_sample_fmt = icodec->sample_fmt;
2147 ost->resample_sample_rate = icodec->sample_rate;
2148 ost->resample_channels = icodec->channels;
2150 case AVMEDIA_TYPE_VIDEO:
2151 if (codec->pix_fmt == PIX_FMT_NONE)
2152 codec->pix_fmt = icodec->pix_fmt;
2153 choose_pixel_fmt(ost->st, ost->enc);
2155 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2156 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2160 if (!codec->width || !codec->height) {
2161 codec->width = icodec->width;
2162 codec->height = icodec->height;
2165 ost->video_resample = codec->width != icodec->width ||
2166 codec->height != icodec->height ||
2167 codec->pix_fmt != icodec->pix_fmt;
2168 if (ost->video_resample) {
2169 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2172 ost->resample_height = icodec->height;
2173 ost->resample_width = icodec->width;
2174 ost->resample_pix_fmt= icodec->pix_fmt;
2175 ost->encoding_needed = 1;
2176 ist->decoding_needed = 1;
2178 if (!ost->frame_rate.num)
2179 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2180 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2181 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2182 ost->frame_rate = ost->enc->supported_framerates[idx];
2184 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2185 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2186 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2187 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2188 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2192 if (configure_video_filters(ist, ost)) {
2193 fprintf(stderr, "Error opening filters!\n");
2198 case AVMEDIA_TYPE_SUBTITLE:
2199 ost->encoding_needed = 1;
2200 ist->decoding_needed = 1;
2207 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2208 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2209 char logfilename[1024];
2212 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2213 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2215 if (codec->flags & CODEC_FLAG_PASS1) {
2216 f = fopen(logfilename, "wb");
2218 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2224 size_t logbuffer_size;
2225 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2226 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2229 codec->stats_in = logbuffer;
2233 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2234 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2235 int size= codec->width * codec->height;
2236 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2241 bit_buffer = av_malloc(bit_buffer_size);
2243 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2245 return AVERROR(ENOMEM);
2248 /* open each encoder */
2249 for (i = 0; i < nb_output_streams; i++) {
2250 ost = &output_streams[i];
2251 if (ost->encoding_needed) {
2252 AVCodec *codec = ost->enc;
2253 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2255 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2256 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2257 ret = AVERROR(EINVAL);
2260 if (dec->subtitle_header) {
2261 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2262 if (!ost->st->codec->subtitle_header) {
2263 ret = AVERROR(ENOMEM);
2266 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2267 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2269 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2270 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2271 ost->file_index, ost->index);
2272 ret = AVERROR(EINVAL);
2275 assert_codec_experimental(ost->st->codec, 1);
2276 assert_avoptions(ost->opts);
2277 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2278 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2279 "It takes bits/s as argument, not kbits/s\n");
2280 extra_size += ost->st->codec->extradata_size;
2282 if (ost->st->codec->me_threshold)
2283 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2287 /* init input streams */
2288 for (i = 0; i < nb_input_streams; i++)
2289 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2292 /* discard unused programs */
2293 for (i = 0; i < nb_input_files; i++) {
2294 InputFile *ifile = &input_files[i];
2295 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2296 AVProgram *p = ifile->ctx->programs[j];
2297 int discard = AVDISCARD_ALL;
2299 for (k = 0; k < p->nb_stream_indexes; k++)
2300 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2301 discard = AVDISCARD_DEFAULT;
2304 p->discard = discard;
2308 /* open files and write file headers */
2309 for (i = 0; i < nb_output_files; i++) {
2310 os = output_files[i].ctx;
2311 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2312 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2313 ret = AVERROR(EINVAL);
2316 // assert_avoptions(output_files[i].opts);
2317 if (strcmp(os->oformat->name, "rtp")) {
2323 /* dump the file output parameters - cannot be done before in case
2325 for(i=0;i<nb_output_files;i++) {
2326 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2329 /* dump the stream mapping */
2331 fprintf(stderr, "Stream mapping:\n");
2332 for (i = 0; i < nb_output_streams;i ++) {
2333 ost = &output_streams[i];
2334 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2335 input_streams[ost->source_index].file_index,
2336 input_streams[ost->source_index].st->index,
2339 if (ost->sync_ist != &input_streams[ost->source_index])
2340 fprintf(stderr, " [sync #%d.%d]",
2341 ost->sync_ist->file_index,
2342 ost->sync_ist->st->index);
2343 if (ost->st->stream_copy)
2344 fprintf(stderr, " (copy)");
2346 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2347 input_streams[ost->source_index].dec->name : "?",
2348 ost->enc ? ost->enc->name : "?");
2349 fprintf(stderr, "\n");
2354 fprintf(stderr, "%s\n", error);
2359 print_sdp(output_files, nb_output_files);
2366 * The following code is the main loop of the file converter
2368 static int transcode(OutputFile *output_files, int nb_output_files,
2369 InputFile *input_files, int nb_input_files)
2372 AVFormatContext *is, *os;
2376 int no_packet_count=0;
2377 int64_t timer_start;
2380 if (!(no_packet = av_mallocz(nb_input_files)))
2383 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2389 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2390 avio_set_interrupt_cb(decode_interrupt_cb);
2394 timer_start = av_gettime();
2396 for(; received_sigterm == 0;) {
2397 int file_index, ist_index;
2402 ipts_min= INT64_MAX;
2404 /* if 'q' pressed, exits */
2408 /* read_key() returns 0 on EOF */
2412 if (key == '+') verbose++;
2413 if (key == '-') verbose--;
2414 if (key == 's') qp_hist ^= 1;
2417 do_hex_dump = do_pkt_dump = 0;
2418 } else if(do_pkt_dump){
2422 av_log_set_level(AV_LOG_DEBUG);
2425 if (key == 'c' || key == 'C'){
2426 char ret[4096], target[64], cmd[256], arg[256]={0};
2429 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2431 while((k=read_key()) !='\n' && k!='\r' && i<sizeof(ret)-1)
2432 if(k>0) ret[i++]= k;
2434 if(k>0 && sscanf(ret, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &ts, cmd, arg) >= 3){
2435 for(i=0;i<nb_output_streams;i++) {
2437 ost = &output_streams[i];
2440 r= avfilter_graph_send_command(ost->graph, target, cmd, arg, ret, sizeof(ret), key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2441 fprintf(stderr, "Command reply for %d: %d, %s\n", i, r, ret);
2443 r= avfilter_graph_queue_command(ost->graph, target, cmd, arg, 0, ts);
2448 fprintf(stderr, "Parse error\n");
2452 if (key == 'd' || key == 'D'){
2455 debug = input_streams[0].st->codec->debug<<1;
2456 if(!debug) debug = 1;
2457 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2460 scanf("%d", &debug);
2461 for(i=0;i<nb_input_streams;i++) {
2462 input_streams[i].st->codec->debug = debug;
2464 for(i=0;i<nb_output_streams;i++) {
2465 ost = &output_streams[i];
2466 ost->st->codec->debug = debug;
2468 if(debug) av_log_set_level(AV_LOG_DEBUG);
2469 fprintf(stderr,"debug=%d\n", debug);
2472 fprintf(stderr, "key function\n"
2473 "? show this help\n"
2474 "+ increase verbosity\n"
2475 "- decrease verbosity\n"
2476 "c Send command to filtergraph\n"
2477 "D cycle through available debug modes\n"
2478 "h dump packets/hex press to cycle through the 3 states\n"
2480 "s Show QP histogram\n"
2485 /* select the stream that we must read now by looking at the
2486 smallest output pts */
2488 for (i = 0; i < nb_output_streams; i++) {
2492 ost = &output_streams[i];
2493 of = &output_files[ost->file_index];
2494 os = output_files[ost->file_index].ctx;
2495 ist = &input_streams[ost->source_index];
2496 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2497 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2499 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2501 if (!input_files[ist->file_index].eof_reached){
2502 if(ipts < ipts_min) {
2504 if(input_sync ) file_index = ist->file_index;
2506 if(opts < opts_min) {
2508 if(!input_sync) file_index = ist->file_index;
2511 if (ost->frame_number >= ost->max_frames) {
2513 for (j = of->ost_index; j < of->ctx->nb_streams; j++)
2514 output_streams[j].is_past_recording_time = 1;
2518 /* if none, if is finished */
2519 if (file_index < 0) {
2520 if(no_packet_count){
2522 memset(no_packet, 0, nb_input_files);
2529 /* read a frame from it and output it in the fifo */
2530 is = input_files[file_index].ctx;
2531 ret= av_read_frame(is, &pkt);
2532 if(ret == AVERROR(EAGAIN)){
2533 no_packet[file_index]=1;
2538 input_files[file_index].eof_reached = 1;
2546 memset(no_packet, 0, nb_input_files);
2549 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2550 is->streams[pkt.stream_index]);
2552 /* the following test is needed in case new streams appear
2553 dynamically in stream : we ignore them */
2554 if (pkt.stream_index >= input_files[file_index].nb_streams)
2555 goto discard_packet;
2556 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2557 ist = &input_streams[ist_index];
2559 goto discard_packet;
2561 if (pkt.dts != AV_NOPTS_VALUE)
2562 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2563 if (pkt.pts != AV_NOPTS_VALUE)
2564 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2566 if(pkt.pts != AV_NOPTS_VALUE)
2567 pkt.pts *= ist->ts_scale;
2568 if(pkt.dts != AV_NOPTS_VALUE)
2569 pkt.dts *= ist->ts_scale;
2571 // 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);
2572 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2573 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2574 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2575 int64_t delta= pkt_dts - ist->next_pts;
2576 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2577 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2578 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2579 pkt_dts+1<ist->pts)&& !copy_ts){
2580 input_files[ist->file_index].ts_offset -= delta;
2582 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2583 delta, input_files[ist->file_index].ts_offset);
2584 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2585 if(pkt.pts != AV_NOPTS_VALUE)
2586 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2590 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2591 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2594 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2595 ist->file_index, ist->st->index);
2598 av_free_packet(&pkt);
2603 av_free_packet(&pkt);
2605 /* dump report by using the output first video and audio streams */
2606 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2609 /* at the end of stream, we must flush the decoder buffers */
2610 for (i = 0; i < nb_input_streams; i++) {
2611 ist = &input_streams[i];
2612 if (ist->decoding_needed) {
2613 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2616 flush_encoders(output_streams, nb_output_streams);
2620 /* write the trailer if needed and close file */
2621 for(i=0;i<nb_output_files;i++) {
2622 os = output_files[i].ctx;
2623 av_write_trailer(os);
2626 /* dump report by using the first video and audio streams */
2627 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2629 /* close each encoder */
2630 for (i = 0; i < nb_output_streams; i++) {
2631 ost = &output_streams[i];
2632 if (ost->encoding_needed) {
2633 av_freep(&ost->st->codec->stats_in);
2634 avcodec_close(ost->st->codec);
2637 avfilter_graph_free(&ost->graph);
2641 /* close each decoder */
2642 for (i = 0; i < nb_input_streams; i++) {
2643 ist = &input_streams[i];
2644 if (ist->decoding_needed) {
2645 avcodec_close(ist->st->codec);
2653 av_freep(&bit_buffer);
2654 av_freep(&no_packet);
2656 if (output_streams) {
2657 for (i = 0; i < nb_output_streams; i++) {
2658 ost = &output_streams[i];
2660 if (ost->st->stream_copy)
2661 av_freep(&ost->st->codec->extradata);
2663 fclose(ost->logfile);
2664 ost->logfile = NULL;
2666 av_fifo_free(ost->fifo); /* works even if fifo is not
2667 initialized but set to zero */
2668 av_freep(&ost->st->codec->subtitle_header);
2669 av_free(ost->resample_frame.data[0]);
2670 av_free(ost->forced_kf_pts);
2671 if (ost->video_resample)
2672 sws_freeContext(ost->img_resample_ctx);
2674 audio_resample_close(ost->resample);
2675 if (ost->reformat_ctx)
2676 av_audio_convert_free(ost->reformat_ctx);
2677 av_dict_free(&ost->opts);
2684 static int opt_verbose(const char *opt, const char *arg)
2686 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2690 static int opt_frame_crop(const char *opt, const char *arg)
2692 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2693 return AVERROR(EINVAL);
2696 static int opt_pad(const char *opt, const char *arg)
2698 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2702 static double parse_frame_aspect_ratio(const char *arg)
2709 p = strchr(arg, ':');
2711 x = strtol(arg, &end, 10);
2713 y = strtol(end+1, &end, 10);
2715 ar = (double)x / (double)y;
2717 ar = strtod(arg, NULL);
2720 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2726 static int opt_video_channel(const char *opt, const char *arg)
2728 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2729 return opt_default("channel", arg);
2732 static int opt_video_standard(const char *opt, const char *arg)
2734 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2735 return opt_default("standard", arg);
2738 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2740 audio_codec_name = arg;
2741 return parse_option(o, "codec:a", arg, options);
2744 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2746 video_codec_name = arg;
2747 return parse_option(o, "codec:v", arg, options);
2750 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2752 subtitle_codec_name = arg;
2753 return parse_option(o, "codec:s", arg, options);
2756 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2758 return parse_option(o, "codec:d", arg, options);
2761 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2763 StreamMap *m = NULL;
2764 int i, negative = 0, file_idx;
2765 int sync_file_idx = -1, sync_stream_idx;
2773 map = av_strdup(arg);
2775 /* parse sync stream first, just pick first matching stream */
2776 if (sync = strchr(map, ',')) {
2778 sync_file_idx = strtol(sync + 1, &sync, 0);
2779 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2780 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2785 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2786 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2787 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2788 sync_stream_idx = i;
2791 if (i == input_files[sync_file_idx].nb_streams) {
2792 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2793 "match any streams.\n", arg);
2799 file_idx = strtol(map, &p, 0);
2800 if (file_idx >= nb_input_files || file_idx < 0) {
2801 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2805 /* disable some already defined maps */
2806 for (i = 0; i < o->nb_stream_maps; i++) {
2807 m = &o->stream_maps[i];
2808 if (check_stream_specifier(input_files[m->file_index].ctx,
2809 input_files[m->file_index].ctx->streams[m->stream_index],
2810 *p == ':' ? p + 1 : p) > 0)
2814 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2815 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2816 *p == ':' ? p + 1 : p) <= 0)
2818 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2819 &o->nb_stream_maps, o->nb_stream_maps + 1);
2820 m = &o->stream_maps[o->nb_stream_maps - 1];
2822 m->file_index = file_idx;
2823 m->stream_index = i;
2825 if (sync_file_idx >= 0) {
2826 m->sync_file_index = sync_file_idx;
2827 m->sync_stream_index = sync_stream_idx;
2829 m->sync_file_index = file_idx;
2830 m->sync_stream_index = i;
2835 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2843 static void parse_meta_type(char *arg, char *type, int *index)
2853 if (*(++arg) == ':')
2854 *index = strtol(++arg, NULL, 0);
2857 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2864 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2866 MetadataMap *m, *m1;
2869 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2870 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2872 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2873 m->file = strtol(arg, &p, 0);
2874 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2876 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2877 if (p = strchr(opt, ':'))
2878 parse_meta_type(p + 1, &m1->type, &m1->index);
2882 if (m->type == 'g' || m1->type == 'g')
2883 o->metadata_global_manual = 1;
2884 if (m->type == 's' || m1->type == 's')
2885 o->metadata_streams_manual = 1;
2886 if (m->type == 'c' || m1->type == 'c')
2887 o->metadata_chapters_manual = 1;
2892 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2894 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2895 "Use -map_metadata instead.\n");
2896 return opt_map_metadata(o, opt, arg);
2899 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
2902 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2903 struct tm time = *gmtime((time_t*)&recording_timestamp);
2904 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2905 parse_option(o, "metadata", buf, options);
2907 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2908 "tag instead.\n", opt);
2912 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2914 const char *codec_string = encoder ? "encoder" : "decoder";
2918 return CODEC_ID_NONE;
2920 avcodec_find_encoder_by_name(name) :
2921 avcodec_find_decoder_by_name(name);
2923 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2926 if(codec->type != type) {
2927 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2933 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2935 char *codec_name = NULL;
2937 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2941 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2942 return avcodec_find_encoder(st->codec->codec_id);
2944 } else if (!strcmp(codec_name, "copy"))
2945 st->stream_copy = 1;
2947 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2948 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2949 avcodec_find_decoder_by_name(codec_name);
2956 * Add all the streams from the given input file to the global
2957 * list of input streams.
2959 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2961 int i, rfps, rfps_base;
2963 for (i = 0; i < ic->nb_streams; i++) {
2964 AVStream *st = ic->streams[i];
2965 AVCodecContext *dec = st->codec;
2969 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2970 ist = &input_streams[nb_input_streams - 1];
2972 ist->file_index = nb_input_files;
2974 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2976 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2977 ist->ts_scale = scale;
2979 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2981 ist->dec = avcodec_find_decoder(dec->codec_id);
2983 switch (dec->codec_type) {
2984 case AVMEDIA_TYPE_AUDIO:
2986 ist->dec = avcodec_find_decoder(dec->codec_id);
2987 if(o->audio_disable)
2988 st->discard= AVDISCARD_ALL;
2990 case AVMEDIA_TYPE_VIDEO:
2992 ist->dec = avcodec_find_decoder(dec->codec_id);
2993 rfps = ic->streams[i]->r_frame_rate.num;
2994 rfps_base = ic->streams[i]->r_frame_rate.den;
2996 dec->flags |= CODEC_FLAG_EMU_EDGE;
2999 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3002 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3003 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3005 (float)rfps / rfps_base, rfps, rfps_base);
3008 if (o->video_disable)
3009 st->discard= AVDISCARD_ALL;
3010 else if(video_discard)
3011 st->discard= video_discard;
3013 case AVMEDIA_TYPE_DATA:
3015 case AVMEDIA_TYPE_SUBTITLE:
3017 ist->dec = avcodec_find_decoder(dec->codec_id);
3018 if(o->subtitle_disable)
3019 st->discard = AVDISCARD_ALL;
3021 case AVMEDIA_TYPE_ATTACHMENT:
3022 case AVMEDIA_TYPE_UNKNOWN:
3030 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3032 AVFormatContext *ic;
3033 AVInputFormat *file_iformat = NULL;
3037 AVDictionary **opts;
3038 int orig_nb_streams; // number of streams before avformat_find_stream_info
3041 if (!(file_iformat = av_find_input_format(o->format))) {
3042 fprintf(stderr, "Unknown input format: '%s'\n", o->format);
3047 if (!strcmp(filename, "-"))
3050 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3051 !strcmp(filename, "/dev/stdin");
3053 /* get default parameters from command line */
3054 ic = avformat_alloc_context();
3056 print_error(filename, AVERROR(ENOMEM));
3059 if (o->nb_audio_sample_rate) {
3060 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3061 av_dict_set(&format_opts, "sample_rate", buf, 0);
3063 if (o->nb_audio_channels) {
3064 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3065 av_dict_set(&format_opts, "channels", buf, 0);
3067 if (o->nb_frame_rates) {
3068 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3070 if (o->nb_frame_sizes) {
3071 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3073 if (o->nb_frame_pix_fmts)
3074 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3076 ic->flags |= AVFMT_FLAG_NONBLOCK;
3079 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3080 ic->loop_input = loop_input;
3083 /* open the input file with generic libav function */
3084 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3086 print_error(filename, err);
3089 assert_avoptions(format_opts);
3091 /* apply forced codec ids */
3092 for (i = 0; i < ic->nb_streams; i++)
3093 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3095 /* Set AVCodecContext options for avformat_find_stream_info */
3096 opts = setup_find_stream_info_opts(ic, codec_opts);
3097 orig_nb_streams = ic->nb_streams;
3099 /* If not enough info to get the stream parameters, we decode the
3100 first frames to get it. (used in mpeg case for example) */
3101 ret = avformat_find_stream_info(ic, opts);
3102 if (ret < 0 && verbose >= 0) {
3103 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3104 av_close_input_file(ic);
3108 timestamp = o->start_time;
3109 /* add the stream start time */
3110 if (ic->start_time != AV_NOPTS_VALUE)
3111 timestamp += ic->start_time;
3113 /* if seeking requested, we execute it */
3114 if (o->start_time != 0) {
3115 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3117 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3118 filename, (double)timestamp / AV_TIME_BASE);
3122 /* update the current parameters so that they match the one of the input stream */
3123 add_input_streams(o, ic);
3125 /* dump the file content */
3127 av_dump_format(ic, nb_input_files, filename, 0);
3129 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3130 input_files[nb_input_files - 1].ctx = ic;
3131 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3132 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3133 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3134 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3136 for (i = 0; i < orig_nb_streams; i++)
3137 av_dict_free(&opts[i]);
3140 reset_options(o, 1);
3144 static void parse_forced_key_frames(char *kf, OutputStream *ost, AVCodecContext *avctx)
3150 for (p = kf; *p; p++)
3153 ost->forced_kf_count = n;
3154 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3155 if (!ost->forced_kf_pts) {
3156 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3159 for (i = 0; i < n; i++) {
3160 p = i ? strchr(p, ',') + 1 : kf;
3161 t = parse_time_or_die("force_key_frames", p, 1);
3162 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3166 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3169 AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
3170 int idx = oc->nb_streams - 1;
3171 int64_t max_frames = INT64_MAX;
3172 char *bsf = NULL, *next, *codec_tag = NULL;
3173 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3177 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3181 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3182 nb_output_streams + 1);
3183 ost = &output_streams[nb_output_streams - 1];
3184 ost->file_index = nb_output_files;
3187 st->codec->codec_type = type;
3188 ost->enc = choose_codec(o, oc, st, type);
3190 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3193 avcodec_get_context_defaults3(st->codec, ost->enc);
3194 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3196 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3197 ost->max_frames = max_frames;
3199 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3201 if (next = strchr(bsf, ','))
3203 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3204 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter %s\n", bsf);
3208 bsfc_prev->next = bsfc;
3210 ost->bitstream_filters = bsfc;
3216 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3218 uint32_t tag = strtol(codec_tag, &next, 0);
3220 tag = AV_RL32(codec_tag);
3221 st->codec->codec_tag = tag;
3224 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3225 if (qscale >= 0 || same_quant) {
3226 st->codec->flags |= CODEC_FLAG_QSCALE;
3227 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3230 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3234 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3237 const char *p = str;
3244 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3251 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3255 AVCodecContext *video_enc;
3257 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3259 video_enc = st->codec;
3261 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3262 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3265 if (!st->stream_copy) {
3266 const char *p = NULL;
3267 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3268 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3269 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3270 int i, force_fps = 0, top_field_first = -1;
3272 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3273 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3274 av_log(NULL, AV_LOG_ERROR, "Invalid framerate value: %s\n", frame_rate);
3278 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3279 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3280 av_log(NULL, AV_LOG_ERROR, "Invalid frame size: %s.\n", frame_size);
3284 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3285 if (frame_aspect_ratio)
3286 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3288 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3289 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3290 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3291 av_log(NULL, AV_LOG_ERROR, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3294 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3297 video_enc->gop_size = 0;
3298 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3300 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3301 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for intra matrix.\n");
3304 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3306 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3308 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3309 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for inter matrix.\n");
3312 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3315 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3318 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3320 fprintf(stderr, "error parsing rc_override\n");
3323 video_enc->rc_override=
3324 av_realloc(video_enc->rc_override,
3325 sizeof(RcOverride)*(i+1));
3326 video_enc->rc_override[i].start_frame= start;
3327 video_enc->rc_override[i].end_frame = end;
3329 video_enc->rc_override[i].qscale= q;
3330 video_enc->rc_override[i].quality_factor= 1.0;
3333 video_enc->rc_override[i].qscale= 0;
3334 video_enc->rc_override[i].quality_factor= -q/100.0;
3339 video_enc->rc_override_count=i;
3340 if (!video_enc->rc_initial_buffer_occupancy)
3341 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3342 video_enc->intra_dc_precision= intra_dc_precision - 8;
3347 video_enc->flags |= CODEC_FLAG_PASS1;
3349 video_enc->flags |= CODEC_FLAG_PASS2;
3353 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3354 if (forced_key_frames)
3355 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3357 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3358 ost->force_fps = force_fps;
3360 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3361 ost->top_field_first = top_field_first;
3364 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3366 ost->avfilter = av_strdup(filters);
3373 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3377 AVCodecContext *audio_enc;
3379 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3382 audio_enc = st->codec;
3383 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3385 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3386 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3388 if (!st->stream_copy) {
3389 char *sample_fmt = NULL;
3391 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3393 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3395 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3396 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", sample_fmt);
3400 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3406 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3410 AVCodecContext *data_enc;
3412 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3414 data_enc = st->codec;
3415 if (!st->stream_copy) {
3416 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3420 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3421 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3427 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3431 AVCodecContext *subtitle_enc;
3433 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3435 subtitle_enc = st->codec;
3437 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3439 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3440 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3446 /* arg format is "output-stream-index:streamid-value". */
3447 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3453 av_strlcpy(idx_str, arg, sizeof(idx_str));
3454 p = strchr(idx_str, ':');
3457 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3462 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3463 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3464 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3468 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3470 AVFormatContext *is = ifile->ctx;
3471 AVFormatContext *os = ofile->ctx;
3474 for (i = 0; i < is->nb_chapters; i++) {
3475 AVChapter *in_ch = is->chapters[i], *out_ch;
3476 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3477 AV_TIME_BASE_Q, in_ch->time_base);
3478 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3479 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3482 if (in_ch->end < ts_off)
3484 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3487 out_ch = av_mallocz(sizeof(AVChapter));
3489 return AVERROR(ENOMEM);
3491 out_ch->id = in_ch->id;
3492 out_ch->time_base = in_ch->time_base;
3493 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3494 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3497 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3500 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3502 return AVERROR(ENOMEM);
3503 os->chapters[os->nb_chapters - 1] = out_ch;
3508 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3511 AVFormatContext *ic = NULL;
3513 err = avformat_open_input(&ic, filename, NULL, NULL);
3516 /* copy stream format */
3517 for(i=0;i<ic->nb_streams;i++) {
3522 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3523 ost = new_output_stream(o, s, codec->type);
3526 // FIXME: a more elegant solution is needed
3527 memcpy(st, ic->streams[i], sizeof(AVStream));
3528 st->info = av_malloc(sizeof(*st->info));
3529 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3530 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3532 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3533 choose_sample_fmt(st, codec);
3534 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3535 choose_pixel_fmt(st, codec);
3538 av_close_input_file(ic);
3542 static void opt_output_file(void *optctx, const char *filename)
3544 OptionsContext *o = optctx;
3545 AVFormatContext *oc;
3547 AVOutputFormat *file_oformat;
3551 if (!strcmp(filename, "-"))
3554 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3556 print_error(filename, err);
3559 file_oformat= oc->oformat;
3561 if (!strcmp(file_oformat->name, "ffm") &&
3562 av_strstart(filename, "http:", NULL)) {
3563 /* special case for files sent to ffserver: we get the stream
3564 parameters from ffserver */
3565 int err = read_ffserver_streams(o, oc, filename);
3567 print_error(filename, err);
3570 } else if (!o->nb_stream_maps) {
3571 /* pick the "best" stream of each type */
3572 #define NEW_STREAM(type, index)\
3574 ost = new_ ## type ## _stream(o, oc);\
3575 ost->source_index = index;\
3576 ost->sync_ist = &input_streams[index];\
3577 input_streams[index].discard = 0;\
3580 /* video: highest resolution */
3581 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3582 int area = 0, idx = -1;
3583 for (i = 0; i < nb_input_streams; i++) {
3584 ist = &input_streams[i];
3585 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3586 ist->st->codec->width * ist->st->codec->height > area) {
3587 area = ist->st->codec->width * ist->st->codec->height;
3591 NEW_STREAM(video, idx);
3594 /* audio: most channels */
3595 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3596 int channels = 0, idx = -1;
3597 for (i = 0; i < nb_input_streams; i++) {
3598 ist = &input_streams[i];
3599 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3600 ist->st->codec->channels > channels) {
3601 channels = ist->st->codec->channels;
3605 NEW_STREAM(audio, idx);
3608 /* subtitles: pick first */
3609 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3610 for (i = 0; i < nb_input_streams; i++)
3611 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3612 NEW_STREAM(subtitle, i);
3616 /* do something with data? */
3618 for (i = 0; i < o->nb_stream_maps; i++) {
3619 StreamMap *map = &o->stream_maps[i];
3624 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3625 switch (ist->st->codec->codec_type) {
3626 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3627 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3628 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3629 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3631 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3632 map->file_index, map->stream_index);
3636 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3637 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3638 map->sync_stream_index];
3643 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3644 output_files[nb_output_files - 1].ctx = oc;
3645 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3646 output_files[nb_output_files - 1].recording_time = o->recording_time;
3647 output_files[nb_output_files - 1].start_time = o->start_time;
3648 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3649 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3651 /* check filename in case of an image number is expected */
3652 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3653 if (!av_filename_number_test(oc->filename)) {
3654 print_error(oc->filename, AVERROR(EINVAL));
3659 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3660 /* test if it already exists to avoid loosing precious files */
3661 if (!file_overwrite &&
3662 (strchr(filename, ':') == NULL ||
3663 filename[1] == ':' ||
3664 av_strstart(filename, "file:", NULL))) {
3665 if (avio_check(filename, 0) == 0) {
3667 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3669 if (!read_yesno()) {
3670 fprintf(stderr, "Not overwriting - exiting\n");
3675 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3682 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3683 print_error(filename, err);
3688 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3689 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3691 if (loop_output >= 0) {
3692 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3693 oc->loop_output = loop_output;
3697 if (o->chapters_input_file >= nb_input_files) {
3698 if (o->chapters_input_file == INT_MAX) {
3699 /* copy chapters from the first input file that has them*/
3700 o->chapters_input_file = -1;
3701 for (i = 0; i < nb_input_files; i++)
3702 if (input_files[i].ctx->nb_chapters) {
3703 o->chapters_input_file = i;
3707 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3708 o->chapters_input_file);
3712 if (o->chapters_input_file >= 0)
3713 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3714 !o->metadata_chapters_manual);
3717 for (i = 0; i < o->nb_meta_data_maps; i++) {
3718 AVFormatContext *files[2];
3719 AVDictionary **meta[2];
3722 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3723 if ((index) < 0 || (index) >= (nb_elems)) {\
3724 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3729 int in_file_index = o->meta_data_maps[i][1].file;
3730 if (in_file_index < 0)
3732 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3735 files[1] = input_files[in_file_index].ctx;
3737 for (j = 0; j < 2; j++) {
3738 MetadataMap *map = &o->meta_data_maps[i][j];
3740 switch (map->type) {
3742 meta[j] = &files[j]->metadata;
3745 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3746 meta[j] = &files[j]->streams[map->index]->metadata;
3749 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3750 meta[j] = &files[j]->chapters[map->index]->metadata;
3753 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3754 meta[j] = &files[j]->programs[map->index]->metadata;
3759 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3762 /* copy global metadata by default */
3763 if (!o->metadata_global_manual && nb_input_files){
3764 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3765 AV_DICT_DONT_OVERWRITE);
3766 if(o->recording_time != INT64_MAX)
3767 av_dict_set(&oc->metadata, "duration", NULL, 0);
3769 if (!o->metadata_streams_manual)
3770 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3771 InputStream *ist = &input_streams[output_streams[i].source_index];
3772 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3775 /* process manually set metadata */
3776 for (i = 0; i < o->nb_metadata; i++) {
3781 val = strchr(o->metadata[i].u.str, '=');
3783 av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3784 o->metadata[i].u.str);
3789 parse_meta_type(o->metadata[i].specifier, &type, &index);
3795 if (index < 0 || index >= oc->nb_streams) {
3796 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3799 m = &oc->streams[index]->metadata;
3802 if (index < 0 || index >= oc->nb_chapters) {
3803 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3806 m = &oc->chapters[index]->metadata;
3809 av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3813 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3816 reset_options(o, 0);
3819 /* same option as mencoder */
3820 static int opt_pass(const char *opt, const char *arg)
3822 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3826 static int64_t getutime(void)
3829 struct rusage rusage;
3831 getrusage(RUSAGE_SELF, &rusage);
3832 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3833 #elif HAVE_GETPROCESSTIMES
3835 FILETIME c, e, k, u;
3836 proc = GetCurrentProcess();
3837 GetProcessTimes(proc, &c, &e, &k, &u);
3838 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3840 return av_gettime();
3844 static int64_t getmaxrss(void)
3846 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3847 struct rusage rusage;
3848 getrusage(RUSAGE_SELF, &rusage);
3849 return (int64_t)rusage.ru_maxrss * 1024;
3850 #elif HAVE_GETPROCESSMEMORYINFO
3852 PROCESS_MEMORY_COUNTERS memcounters;
3853 proc = GetCurrentProcess();
3854 memcounters.cb = sizeof(memcounters);
3855 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3856 return memcounters.PeakPagefileUsage;
3862 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3864 return parse_option(o, "q:a", arg, options);
3867 static void show_usage(void)
3869 printf("Hyper fast Audio and Video encoder\n");
3870 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3874 static int opt_help(const char *opt, const char *arg)
3877 AVOutputFormat *oformat = NULL;
3878 AVInputFormat *iformat = NULL;
3879 const AVClass *class;
3881 av_log_set_callback(log_callback_help);
3883 show_help_options(options, "Main options:\n",
3884 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3885 show_help_options(options, "\nAdvanced options:\n",
3886 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3888 show_help_options(options, "\nVideo options:\n",
3889 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3891 show_help_options(options, "\nAdvanced Video options:\n",
3892 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3893 OPT_VIDEO | OPT_EXPERT);
3894 show_help_options(options, "\nAudio options:\n",
3895 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3897 show_help_options(options, "\nAdvanced Audio options:\n",
3898 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3899 OPT_AUDIO | OPT_EXPERT);
3900 show_help_options(options, "\nSubtitle options:\n",
3901 OPT_SUBTITLE | OPT_GRAB,
3903 show_help_options(options, "\nAudio/Video grab options:\n",
3907 class = avcodec_get_class();
3908 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3911 /* individual codec options */
3913 while ((c = av_codec_next(c))) {
3914 if (c->priv_class) {
3915 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3920 class = avformat_get_class();
3921 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3924 /* individual muxer options */
3925 while ((oformat = av_oformat_next(oformat))) {
3926 if (oformat->priv_class) {
3927 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3932 /* individual demuxer options */
3933 while ((iformat = av_iformat_next(iformat))) {
3934 if (iformat->priv_class) {
3935 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3940 class = sws_get_class();
3941 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3945 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3947 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3948 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3950 if(!strncmp(arg, "pal-", 4)) {
3953 } else if(!strncmp(arg, "ntsc-", 5)) {
3956 } else if(!strncmp(arg, "film-", 5)) {
3960 /* Try to determine PAL/NTSC by peeking in the input files */
3961 if(nb_input_files) {
3963 for (j = 0; j < nb_input_files; j++) {
3964 for (i = 0; i < input_files[j].nb_streams; i++) {
3965 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3966 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3968 fr = c->time_base.den * 1000 / c->time_base.num;
3972 } else if((fr == 29970) || (fr == 23976)) {
3981 if(verbose > 0 && norm != UNKNOWN)
3982 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3985 if(norm == UNKNOWN) {
3986 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3987 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3988 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3992 if(!strcmp(arg, "vcd")) {
3993 opt_video_codec(o, "c:v", "mpeg1video");
3994 opt_audio_codec(o, "c:a", "mp2");
3995 parse_option(o, "f", "vcd", options);
3997 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3998 parse_option(o, "r", frame_rates[norm], options);
3999 opt_default("g", norm == PAL ? "15" : "18");
4001 opt_default("b", "1150000");
4002 opt_default("maxrate", "1150000");
4003 opt_default("minrate", "1150000");
4004 opt_default("bufsize", "327680"); // 40*1024*8;
4006 opt_default("b:a", "224000");
4007 parse_option(o, "ar", "44100", options);
4008 parse_option(o, "ac", "2", options);
4010 opt_default("packetsize", "2324");
4011 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4013 /* We have to offset the PTS, so that it is consistent with the SCR.
4014 SCR starts at 36000, but the first two packs contain only padding
4015 and the first pack from the other stream, respectively, may also have
4016 been written before.
4017 So the real data starts at SCR 36000+3*1200. */
4018 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4019 } else if(!strcmp(arg, "svcd")) {
4021 opt_video_codec(o, "c:v", "mpeg2video");
4022 opt_audio_codec(o, "c:a", "mp2");
4023 parse_option(o, "f", "svcd", options);
4025 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4026 parse_option(o, "r", frame_rates[norm], options);
4027 parse_option(o, "pix_fmt", "yuv420p", options);
4028 opt_default("g", norm == PAL ? "15" : "18");
4030 opt_default("b", "2040000");
4031 opt_default("maxrate", "2516000");
4032 opt_default("minrate", "0"); //1145000;
4033 opt_default("bufsize", "1835008"); //224*1024*8;
4034 opt_default("flags", "+scan_offset");
4037 opt_default("b:a", "224000");
4038 parse_option(o, "ar", "44100", options);
4040 opt_default("packetsize", "2324");
4042 } else if(!strcmp(arg, "dvd")) {
4044 opt_video_codec(o, "c:v", "mpeg2video");
4045 opt_audio_codec(o, "c:a", "ac3");
4046 parse_option(o, "f", "dvd", options);
4048 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4049 parse_option(o, "r", frame_rates[norm], options);
4050 parse_option(o, "pix_fmt", "yuv420p", options);
4051 opt_default("g", norm == PAL ? "15" : "18");
4053 opt_default("b", "6000000");
4054 opt_default("maxrate", "9000000");
4055 opt_default("minrate", "0"); //1500000;
4056 opt_default("bufsize", "1835008"); //224*1024*8;
4058 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4059 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4061 opt_default("b:a", "448000");
4062 parse_option(o, "ar", "48000", options);
4064 } else if(!strncmp(arg, "dv", 2)) {
4066 parse_option(o, "f", "dv", options);
4068 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4069 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4070 norm == PAL ? "yuv420p" : "yuv411p", options);
4071 parse_option(o, "r", frame_rates[norm], options);
4073 parse_option(o, "ar", "48000", options);
4074 parse_option(o, "ac", "2", options);
4077 fprintf(stderr, "Unknown target: %s\n", arg);
4078 return AVERROR(EINVAL);
4083 static int opt_vstats_file(const char *opt, const char *arg)
4085 av_free (vstats_filename);
4086 vstats_filename=av_strdup (arg);
4090 static int opt_vstats(const char *opt, const char *arg)
4093 time_t today2 = time(NULL);
4094 struct tm *today = localtime(&today2);
4096 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4098 return opt_vstats_file(opt, filename);
4101 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4103 return parse_option(o, "frames:v", arg, options);
4106 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4108 return parse_option(o, "frames:a", arg, options);
4111 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4113 return parse_option(o, "frames:d", arg, options);
4116 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4119 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4120 const char *codec_name = *opt == 'v' ? video_codec_name :
4121 *opt == 'a' ? audio_codec_name :
4122 subtitle_codec_name;
4124 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4125 fprintf(stderr, "File for preset '%s' not found\n", arg);
4130 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4131 if(line[0] == '#' && !e)
4133 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4135 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4138 if(!strcmp(tmp, "acodec")){
4139 opt_audio_codec(o, tmp, tmp2);
4140 }else if(!strcmp(tmp, "vcodec")){
4141 opt_video_codec(o, tmp, tmp2);
4142 }else if(!strcmp(tmp, "scodec")){
4143 opt_subtitle_codec(o, tmp, tmp2);
4144 }else if(!strcmp(tmp, "dcodec")){
4145 opt_data_codec(o, tmp, tmp2);
4146 }else if(opt_default(tmp, tmp2) < 0){
4147 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4157 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4161 static int opt_passlogfile(const char *opt, const char *arg)
4163 pass_logfilename_prefix = arg;
4164 #if CONFIG_LIBX264_ENCODER
4165 return opt_default("passlogfile", arg);
4171 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4173 char *s= av_malloc(strlen(opt)+2);
4174 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4175 return parse_option(o, s, arg, options);
4178 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4180 return parse_option(o, "filter:v", arg, options);
4183 #define OFFSET(x) offsetof(OptionsContext, x)
4184 static const OptionDef options[] = {
4186 #include "cmdutils_common_opts.h"
4187 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4188 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4189 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4190 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4191 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4192 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4193 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4194 "outfile[,metadata]:infile[,metadata]" },
4195 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4196 "outfile[,metadata]:infile[,metadata]" },
4197 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4198 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4199 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4200 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4201 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4202 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4203 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4204 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4205 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4206 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4207 "add timings for benchmarking" },
4208 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4209 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4210 "dump each input packet" },
4211 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4212 "when dumping packets, also dump the payload" },
4213 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4214 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4215 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4216 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4217 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4218 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4219 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4220 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4221 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4222 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4223 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4224 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4225 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4226 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4227 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4228 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4229 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4230 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4232 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4236 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4237 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4238 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4239 { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4240 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4241 { "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" },
4242 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4243 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4244 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4245 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4246 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4247 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4248 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4249 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4250 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4251 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4252 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4253 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4254 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4255 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4256 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4257 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4258 "use same quantizer as source (implies VBR)" },
4259 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4260 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4261 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4262 "deinterlace pictures" },
4263 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4264 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4266 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4268 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4269 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4270 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4271 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4272 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4273 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4274 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4275 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4276 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
4279 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4280 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4281 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4282 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4283 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4284 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4285 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4286 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4287 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4289 /* subtitle options */
4290 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4291 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4292 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4295 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4296 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4297 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4300 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4301 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4303 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4304 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4305 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4307 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4308 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4309 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4310 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4311 /* data codec support */
4312 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4314 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4318 int main(int argc, char **argv)
4320 OptionsContext o = { 0 };
4323 reset_options(&o, 0);
4325 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4327 if(argc>1 && !strcmp(argv[1], "-d")){
4330 av_log_set_callback(log_callback_null);
4335 avcodec_register_all();
4337 avdevice_register_all();
4340 avfilter_register_all();
4345 if(isatty(STDIN_FILENO))
4346 avio_set_interrupt_cb(decode_interrupt_cb);
4353 parse_options(&o, argc, argv, options, opt_output_file);
4355 if(nb_output_files <= 0 && nb_input_files == 0) {
4357 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4361 /* file converter / grab */
4362 if (nb_output_files <= 0) {
4363 fprintf(stderr, "At least one output file must be specified\n");
4367 if (nb_input_files == 0) {
4368 fprintf(stderr, "At least one input file must be specified\n");
4373 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4375 ti = getutime() - ti;
4377 int maxrss = getmaxrss() / 1024;
4378 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);