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"
48 #include "libswresample/swresample.h"
50 #include "libavformat/ffm.h" // not public API
53 # include "libavfilter/avcodec.h"
54 # include "libavfilter/avfilter.h"
55 # include "libavfilter/avfiltergraph.h"
56 # include "libavfilter/buffersink.h"
57 # include "libavfilter/vsrc_buffer.h"
60 #if HAVE_SYS_RESOURCE_H
61 #include <sys/types.h>
63 #include <sys/resource.h>
64 #elif HAVE_GETPROCESSTIMES
67 #if HAVE_GETPROCESSMEMORYINFO
73 #include <sys/select.h>
78 #include <sys/ioctl.h>
88 #include "libavutil/avassert.h"
90 const char program_name[] = "ffmpeg";
91 const int program_birth_year = 2000;
93 /* select an input stream for an output stream */
94 typedef struct StreamMap {
95 int disabled; /** 1 is this mapping is disabled by a negative map */
99 int sync_stream_index;
103 * select an input file for an output file
105 typedef struct MetadataMap {
106 int file; ///< file index
107 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
108 int index; ///< stream/chapter/program number
111 static const OptionDef options[];
113 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
115 static int frame_bits_per_raw_sample = 0;
116 static int video_discard = 0;
117 static int same_quant = 0;
118 static int do_deinterlace = 0;
119 static int intra_dc_precision = 8;
120 static int loop_input = 0;
121 static int loop_output = AVFMT_NOOUTPUTLOOP;
122 static int qp_hist = 0;
123 static int intra_only = 0;
124 static const char *video_codec_name = NULL;
125 static const char *audio_codec_name = NULL;
126 static const char *subtitle_codec_name = NULL;
128 static int file_overwrite = 0;
129 static int do_benchmark = 0;
130 static int do_hex_dump = 0;
131 static int do_pkt_dump = 0;
132 static int do_pass = 0;
133 static const char *pass_logfilename_prefix;
134 static int video_sync_method= -1;
135 static int audio_sync_method= 0;
136 static float audio_drift_threshold= 0.1;
137 static int copy_ts= 0;
138 static int copy_tb= 0;
139 static int opt_shortest = 0;
140 static char *vstats_filename;
141 static FILE *vstats_file;
142 static int copy_initial_nonkeyframes = 0;
144 static int audio_volume = 256;
146 static int exit_on_error = 0;
147 static int using_stdin = 0;
148 static int verbose = 1;
149 static int run_as_daemon = 0;
150 static int q_pressed = 0;
151 static int64_t video_size = 0;
152 static int64_t audio_size = 0;
153 static int64_t extra_size = 0;
154 static int nb_frames_dup = 0;
155 static int nb_frames_drop = 0;
156 static int input_sync;
158 static float dts_delta_threshold = 10;
160 static uint8_t *audio_buf;
161 static uint8_t *audio_out;
162 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
164 static short *samples;
165 static uint8_t *input_tmp= NULL;
167 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
169 typedef struct InputStream {
172 int discard; /* true if stream data should be discarded */
173 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
176 int64_t start; /* time when read started */
177 int64_t next_pts; /* synthetic pts for cases where pkt.pts
179 int64_t pts; /* current pts */
181 int is_start; /* is 1 at the start and after a discontinuity */
182 int showed_multi_packet_warning;
186 typedef struct InputFile {
187 AVFormatContext *ctx;
188 int eof_reached; /* true if eof reached */
189 int ist_index; /* index of first stream in ist_table */
190 int buffer_size; /* current total buffer size */
192 int nb_streams; /* number of stream that avconv is aware of; may be different
193 from ctx.nb_streams if new streams appear during av_read_frame() */
197 typedef struct OutputStream {
198 int file_index; /* file index */
199 int index; /* stream index in the output file */
200 int source_index; /* InputStream index */
201 AVStream *st; /* stream in the output file */
202 int encoding_needed; /* true if encoding needed for this stream */
204 /* input pts and corresponding output pts
206 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
207 struct InputStream *sync_ist; /* input stream to sync against */
208 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
209 AVBitStreamFilterContext *bitstream_filters;
215 AVFrame resample_frame; /* temporary frame for image resampling */
216 struct SwsContext *img_resample_ctx; /* for image resampling */
219 int resample_pix_fmt;
220 AVRational frame_rate;
224 float frame_aspect_ratio;
226 /* forced key frames */
227 int64_t *forced_kf_pts;
233 int resample_sample_fmt;
234 int resample_channels;
235 int resample_sample_rate;
236 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
239 struct SwrContext *swr;
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 || enc->sample_fmt != dec->sample_fmt)
848 ost->audio_resample = 1;
850 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
851 ost->resample_channels != dec->channels ||
852 ost->resample_sample_rate != dec->sample_rate;
854 if ((ost->audio_resample && !ost->swr) || resample_changed) {
855 if (resample_changed) {
856 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",
857 ist->file_index, ist->st->index,
858 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
859 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
860 ost->resample_sample_fmt = dec->sample_fmt;
861 ost->resample_channels = dec->channels;
862 ost->resample_sample_rate = dec->sample_rate;
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) {
871 ost->audio_resample = 0;
873 ost->swr = swr_alloc2(ost->swr,
874 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
875 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
877 av_set_int(ost->swr, "ich", dec->channels);
878 av_set_int(ost->swr, "och", enc->channels);
879 if(audio_sync_method>1) av_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE);
880 if(ost->swr && swr_init(ost->swr) < 0){
881 fprintf(stderr, "swr_init() failed\n");
886 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
887 dec->channels, dec->sample_rate,
888 enc->channels, enc->sample_rate);
894 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
896 if(audio_sync_method){
897 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
898 - av_fifo_size(ost->fifo)/(enc->channels * 2);
899 double idelta= delta*dec->sample_rate / enc->sample_rate;
900 int byte_delta= ((int)idelta)*2*dec->channels;
902 //FIXME resample delay
903 if(fabs(delta) > 50){
904 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
906 byte_delta= FFMAX(byte_delta, -size);
910 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
915 input_tmp= av_realloc(input_tmp, byte_delta + size);
917 if(byte_delta > allocated_for_size - size){
918 allocated_for_size= byte_delta + (int64_t)size;
923 memset(input_tmp, 0, byte_delta);
924 memcpy(input_tmp + byte_delta, buf, size);
928 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
930 }else if(audio_sync_method>1){
931 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
932 av_assert0(ost->audio_resample);
934 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
935 // 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));
936 swr_compensate(ost->swr, comp, enc->sample_rate);
940 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
941 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
943 if (ost->audio_resample) {
945 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
946 (const uint8_t*[]){buf }, size / (dec->channels * isize));
947 size_out = size_out * enc->channels * osize;
953 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
955 /* now encode as many frames as possible */
956 if (enc->frame_size > 1) {
957 /* output resampled raw samples */
958 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
959 fprintf(stderr, "av_fifo_realloc2() failed\n");
962 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
964 frame_bytes = enc->frame_size * osize * enc->channels;
966 while (av_fifo_size(ost->fifo) >= frame_bytes) {
968 av_init_packet(&pkt);
970 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
972 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
974 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
977 fprintf(stderr, "Audio encoding failed\n");
981 pkt.stream_index= ost->index;
984 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
985 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
986 pkt.flags |= AV_PKT_FLAG_KEY;
987 write_frame(s, &pkt, enc, ost->bitstream_filters);
989 ost->sync_opts += enc->frame_size;
993 av_init_packet(&pkt);
995 ost->sync_opts += size_out / (osize * enc->channels);
997 /* output a pcm frame */
998 /* determine the size of the coded buffer */
1001 size_out = size_out*coded_bps/8;
1003 if(size_out > audio_out_size){
1004 fprintf(stderr, "Internal error, buffer size too small\n");
1008 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1009 ret = avcodec_encode_audio(enc, audio_out, size_out,
1012 fprintf(stderr, "Audio encoding failed\n");
1016 pkt.stream_index= ost->index;
1017 pkt.data= audio_out;
1019 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1020 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1021 pkt.flags |= AV_PKT_FLAG_KEY;
1022 write_frame(s, &pkt, enc, ost->bitstream_filters);
1026 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1028 AVCodecContext *dec;
1029 AVPicture *picture2;
1030 AVPicture picture_tmp;
1033 dec = ist->st->codec;
1035 /* deinterlace : must be done before any resize */
1036 if (do_deinterlace) {
1039 /* create temporary picture */
1040 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1041 buf = av_malloc(size);
1045 picture2 = &picture_tmp;
1046 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1048 if(avpicture_deinterlace(picture2, picture,
1049 dec->pix_fmt, dec->width, dec->height) < 0) {
1050 /* if error, do not deinterlace */
1051 fprintf(stderr, "Deinterlacing failed\n");
1060 if (picture != picture2)
1061 *picture = *picture2;
1065 static void do_subtitle_out(AVFormatContext *s,
1071 static uint8_t *subtitle_out = NULL;
1072 int subtitle_out_max_size = 1024 * 1024;
1073 int subtitle_out_size, nb, i;
1074 AVCodecContext *enc;
1077 if (pts == AV_NOPTS_VALUE) {
1078 fprintf(stderr, "Subtitle packets must have a pts\n");
1084 enc = ost->st->codec;
1086 if (!subtitle_out) {
1087 subtitle_out = av_malloc(subtitle_out_max_size);
1090 /* Note: DVB subtitle need one packet to draw them and one other
1091 packet to clear them */
1092 /* XXX: signal it in the codec context ? */
1093 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1098 for(i = 0; i < nb; i++) {
1099 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1100 // start_display_time is required to be 0
1101 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1102 sub->end_display_time -= sub->start_display_time;
1103 sub->start_display_time = 0;
1104 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1105 subtitle_out_max_size, sub);
1106 if (subtitle_out_size < 0) {
1107 fprintf(stderr, "Subtitle encoding failed\n");
1111 av_init_packet(&pkt);
1112 pkt.stream_index = ost->index;
1113 pkt.data = subtitle_out;
1114 pkt.size = subtitle_out_size;
1115 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1116 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1117 /* XXX: the pts correction is handled here. Maybe handling
1118 it in the codec would be better */
1120 pkt.pts += 90 * sub->start_display_time;
1122 pkt.pts += 90 * sub->end_display_time;
1124 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1128 static int bit_buffer_size= 1024*256;
1129 static uint8_t *bit_buffer= NULL;
1131 static void do_video_resample(OutputStream *ost,
1133 AVFrame *in_picture,
1134 AVFrame **out_picture)
1137 *out_picture = in_picture;
1139 AVCodecContext *dec = ist->st->codec;
1140 AVCodecContext *enc = ost->st->codec;
1141 int resample_changed = ost->resample_width != dec->width ||
1142 ost->resample_height != dec->height ||
1143 ost->resample_pix_fmt != dec->pix_fmt;
1145 *out_picture = in_picture;
1146 if (resample_changed) {
1147 av_log(NULL, AV_LOG_INFO,
1148 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1149 ist->file_index, ist->st->index,
1150 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1151 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1152 ost->resample_width = dec->width;
1153 ost->resample_height = dec->height;
1154 ost->resample_pix_fmt = dec->pix_fmt;
1157 ost->video_resample = dec->width != enc->width ||
1158 dec->height != enc->height ||
1159 dec->pix_fmt != enc->pix_fmt;
1161 if (ost->video_resample) {
1162 *out_picture = &ost->resample_frame;
1163 if (!ost->img_resample_ctx || resample_changed) {
1164 /* initialize the destination picture */
1165 if (!ost->resample_frame.data[0]) {
1166 avcodec_get_frame_defaults(&ost->resample_frame);
1167 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1168 enc->width, enc->height)) {
1169 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1173 /* initialize a new scaler context */
1174 sws_freeContext(ost->img_resample_ctx);
1175 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1176 enc->width, enc->height, enc->pix_fmt,
1177 ost->sws_flags, NULL, NULL, NULL);
1178 if (ost->img_resample_ctx == NULL) {
1179 fprintf(stderr, "Cannot get resampling context\n");
1183 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1184 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1190 static void do_video_out(AVFormatContext *s,
1193 AVFrame *in_picture,
1194 int *frame_size, float quality)
1196 int nb_frames, i, ret, format_video_sync;
1197 AVFrame *final_picture;
1198 AVCodecContext *enc;
1200 double duration = 0;
1202 enc = ost->st->codec;
1204 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1205 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1206 if(ist->st->avg_frame_rate.num)
1207 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1209 duration /= av_q2d(enc->time_base);
1212 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1214 /* by default, we output a single frame */
1219 format_video_sync = video_sync_method;
1220 if (format_video_sync < 0)
1221 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1223 if (format_video_sync) {
1224 double vdelta = sync_ipts - ost->sync_opts + duration;
1225 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1228 else if (format_video_sync == 2) {
1231 }else if(vdelta>0.6)
1232 ost->sync_opts= lrintf(sync_ipts);
1233 }else if (vdelta > 1.1)
1234 nb_frames = lrintf(vdelta);
1235 //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);
1236 if (nb_frames == 0){
1239 fprintf(stderr, "*** drop!\n");
1240 }else if (nb_frames > 1) {
1241 nb_frames_dup += nb_frames - 1;
1243 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1246 ost->sync_opts= lrintf(sync_ipts);
1248 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1252 do_video_resample(ost, ist, in_picture, &final_picture);
1254 /* duplicates frame if needed */
1255 for(i=0;i<nb_frames;i++) {
1257 av_init_packet(&pkt);
1258 pkt.stream_index= ost->index;
1260 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1261 /* raw pictures are written as AVPicture structure to
1262 avoid any copies. We support temporarily the older
1264 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1265 enc->coded_frame->top_field_first = in_picture->top_field_first;
1266 pkt.data= (uint8_t *)final_picture;
1267 pkt.size= sizeof(AVPicture);
1268 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1269 pkt.flags |= AV_PKT_FLAG_KEY;
1271 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1273 AVFrame big_picture;
1275 big_picture= *final_picture;
1276 /* better than nothing: use input picture interlaced
1278 big_picture.interlaced_frame = in_picture->interlaced_frame;
1279 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1280 if (ost->top_field_first == -1)
1281 big_picture.top_field_first = in_picture->top_field_first;
1283 big_picture.top_field_first = !!ost->top_field_first;
1286 /* handles same_quant here. This is not correct because it may
1287 not be a global option */
1288 big_picture.quality = quality;
1289 if (!enc->me_threshold)
1290 big_picture.pict_type = 0;
1291 // big_picture.pts = AV_NOPTS_VALUE;
1292 big_picture.pts= ost->sync_opts;
1293 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1294 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1295 if (ost->forced_kf_index < ost->forced_kf_count &&
1296 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1297 big_picture.pict_type = AV_PICTURE_TYPE_I;
1298 ost->forced_kf_index++;
1300 ret = avcodec_encode_video(enc,
1301 bit_buffer, bit_buffer_size,
1304 fprintf(stderr, "Video encoding failed\n");
1309 pkt.data= bit_buffer;
1311 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1312 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1313 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1314 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1315 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1317 if(enc->coded_frame->key_frame)
1318 pkt.flags |= AV_PKT_FLAG_KEY;
1319 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1322 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1323 // enc->frame_number-1, ret, enc->pict_type);
1324 /* if two pass, output log */
1325 if (ost->logfile && enc->stats_out) {
1326 fprintf(ost->logfile, "%s", enc->stats_out);
1331 ost->frame_number++;
1335 static double psnr(double d)
1337 return -10.0*log(d)/log(10.0);
1340 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1343 AVCodecContext *enc;
1345 double ti1, bitrate, avg_bitrate;
1347 /* this is executed just the first time do_video_stats is called */
1349 vstats_file = fopen(vstats_filename, "w");
1356 enc = ost->st->codec;
1357 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1358 frame_number = ost->frame_number;
1359 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1360 if (enc->flags&CODEC_FLAG_PSNR)
1361 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1363 fprintf(vstats_file,"f_size= %6d ", frame_size);
1364 /* compute pts value */
1365 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1369 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1370 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1371 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1372 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1373 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1377 static void print_report(OutputFile *output_files,
1378 OutputStream *ost_table, int nb_ostreams,
1379 int is_last_report, int64_t timer_start)
1383 AVFormatContext *oc;
1385 AVCodecContext *enc;
1386 int frame_number, vid, i;
1388 int64_t pts = INT64_MAX;
1389 static int64_t last_time = -1;
1390 static int qp_histogram[52];
1392 if (!is_last_report) {
1394 /* display the report every 0.5 seconds */
1395 cur_time = av_gettime();
1396 if (last_time == -1) {
1397 last_time = cur_time;
1400 if ((cur_time - last_time) < 500000)
1402 last_time = cur_time;
1406 oc = output_files[0].ctx;
1408 total_size = avio_size(oc->pb);
1409 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1410 total_size= avio_tell(oc->pb);
1414 for(i=0;i<nb_ostreams;i++) {
1416 ost = &ost_table[i];
1417 enc = ost->st->codec;
1418 if (!ost->st->stream_copy && enc->coded_frame)
1419 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1420 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1421 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1423 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1424 float t = (av_gettime()-timer_start) / 1000000.0;
1426 frame_number = ost->frame_number;
1427 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1428 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1430 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1434 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1437 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1439 if (enc->flags&CODEC_FLAG_PSNR){
1441 double error, error_sum=0;
1442 double scale, scale_sum=0;
1443 char type[3]= {'Y','U','V'};
1444 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1447 error= enc->error[j];
1448 scale= enc->width*enc->height*255.0*255.0*frame_number;
1450 error= enc->coded_frame->error[j];
1451 scale= enc->width*enc->height*255.0*255.0;
1456 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1458 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1462 /* compute min output value */
1463 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1464 ost->st->time_base, AV_TIME_BASE_Q));
1467 if (verbose > 0 || is_last_report) {
1468 int hours, mins, secs, us;
1469 secs = pts / AV_TIME_BASE;
1470 us = pts % AV_TIME_BASE;
1476 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1478 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1479 "size=%8.0fkB time=", total_size / 1024.0);
1480 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1481 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1482 (100 * us) / AV_TIME_BASE);
1483 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1484 "bitrate=%6.1fkbits/s", bitrate);
1486 if (nb_frames_dup || nb_frames_drop)
1487 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1488 nb_frames_dup, nb_frames_drop);
1491 fprintf(stderr, "%s \r", buf);
1496 if (is_last_report && verbose >= 0){
1497 int64_t raw= audio_size + video_size + extra_size;
1498 fprintf(stderr, "\n");
1499 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1503 100.0*(total_size - raw)/raw
1508 static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
1510 int fill_char = 0x00;
1511 if (sample_fmt == AV_SAMPLE_FMT_U8)
1513 memset(buf, fill_char, size);
1516 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1520 for (i = 0; i < nb_ostreams; i++) {
1521 OutputStream *ost = &ost_table[i];
1522 AVCodecContext *enc = ost->st->codec;
1523 AVFormatContext *os = output_files[ost->file_index].ctx;
1525 if (!ost->encoding_needed)
1528 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1530 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1536 av_init_packet(&pkt);
1537 pkt.stream_index= ost->index;
1539 switch (ost->st->codec->codec_type) {
1540 case AVMEDIA_TYPE_AUDIO:
1541 fifo_bytes = av_fifo_size(ost->fifo);
1543 /* encode any samples remaining in fifo */
1544 if (fifo_bytes > 0) {
1545 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1546 int fs_tmp = enc->frame_size;
1548 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1549 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1550 enc->frame_size = fifo_bytes / (osize * enc->channels);
1552 int frame_bytes = enc->frame_size*osize*enc->channels;
1553 if (allocated_audio_buf_size < frame_bytes)
1555 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1558 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1559 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1560 ost->st->time_base.num, enc->sample_rate);
1561 enc->frame_size = fs_tmp;
1564 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1567 fprintf(stderr, "Audio encoding failed\n");
1571 pkt.flags |= AV_PKT_FLAG_KEY;
1573 case AVMEDIA_TYPE_VIDEO:
1574 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1576 fprintf(stderr, "Video encoding failed\n");
1580 if(enc->coded_frame && enc->coded_frame->key_frame)
1581 pkt.flags |= AV_PKT_FLAG_KEY;
1582 if (ost->logfile && enc->stats_out) {
1583 fprintf(ost->logfile, "%s", enc->stats_out);
1592 pkt.data = bit_buffer;
1594 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1595 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1596 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1601 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1602 static int output_packet(InputStream *ist, int ist_index,
1603 OutputStream *ost_table, int nb_ostreams,
1604 const AVPacket *pkt)
1606 AVFormatContext *os;
1611 void *buffer_to_free = NULL;
1612 static unsigned int samples_size= 0;
1613 AVSubtitle subtitle, *subtitle_to_free;
1614 int64_t pkt_pts = AV_NOPTS_VALUE;
1616 int frame_available;
1621 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1623 if(ist->next_pts == AV_NOPTS_VALUE)
1624 ist->next_pts= ist->pts;
1628 av_init_packet(&avpkt);
1636 if(pkt->dts != AV_NOPTS_VALUE)
1637 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1638 if(pkt->pts != AV_NOPTS_VALUE)
1639 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1641 //while we have more to decode or while the decoder did output something on EOF
1642 while (avpkt.size > 0 || (!pkt && got_output)) {
1643 uint8_t *data_buf, *decoded_data_buf;
1644 int data_size, decoded_data_size;
1646 ist->pts= ist->next_pts;
1648 if(avpkt.size && avpkt.size != pkt->size &&
1649 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1650 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1651 ist->showed_multi_packet_warning=1;
1654 /* decode the packet if needed */
1655 decoded_data_buf = NULL; /* fail safe */
1656 decoded_data_size= 0;
1657 data_buf = avpkt.data;
1658 data_size = avpkt.size;
1659 subtitle_to_free = NULL;
1660 if (ist->decoding_needed) {
1661 switch(ist->st->codec->codec_type) {
1662 case AVMEDIA_TYPE_AUDIO:{
1663 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1664 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1666 samples= av_malloc(samples_size);
1668 decoded_data_size= samples_size;
1669 /* XXX: could avoid copy if PCM 16 bits with same
1670 endianness as CPU */
1671 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1678 got_output = decoded_data_size > 0;
1679 /* Some bug in mpeg audio decoder gives */
1680 /* decoded_data_size < 0, it seems they are overflows */
1682 /* no audio frame */
1685 decoded_data_buf = (uint8_t *)samples;
1686 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1687 (ist->st->codec->sample_rate * ist->st->codec->channels);
1689 case AVMEDIA_TYPE_VIDEO:
1690 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1691 /* XXX: allocate picture correctly */
1692 avcodec_get_frame_defaults(&picture);
1693 avpkt.pts = pkt_pts;
1694 avpkt.dts = ist->pts;
1695 pkt_pts = AV_NOPTS_VALUE;
1697 ret = avcodec_decode_video2(ist->st->codec,
1698 &picture, &got_output, &avpkt);
1699 quality = same_quant ? picture.quality : 0;
1703 /* no picture yet */
1704 goto discard_packet;
1706 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1707 if (ist->st->codec->time_base.num != 0) {
1708 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1709 ist->next_pts += ((int64_t)AV_TIME_BASE *
1710 ist->st->codec->time_base.num * ticks) /
1711 ist->st->codec->time_base.den;
1714 buffer_to_free = NULL;
1715 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1717 case AVMEDIA_TYPE_SUBTITLE:
1718 ret = avcodec_decode_subtitle2(ist->st->codec,
1719 &subtitle, &got_output, &avpkt);
1723 goto discard_packet;
1725 subtitle_to_free = &subtitle;
1732 switch(ist->st->codec->codec_type) {
1733 case AVMEDIA_TYPE_AUDIO:
1734 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1735 ist->st->codec->sample_rate;
1737 case AVMEDIA_TYPE_VIDEO:
1738 if (ist->st->codec->time_base.num != 0) {
1739 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1740 ist->next_pts += ((int64_t)AV_TIME_BASE *
1741 ist->st->codec->time_base.num * ticks) /
1742 ist->st->codec->time_base.den;
1750 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1751 for(i=0;i<nb_ostreams;i++) {
1752 OutputFile *of = &output_files[ost_table[i].file_index];
1753 if (of->start_time == 0 || ist->pts >= of->start_time) {
1754 ost = &ost_table[i];
1755 if (ost->input_video_filter && ost->source_index == ist_index) {
1756 if (!picture.sample_aspect_ratio.num)
1757 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1758 picture.pts = ist->pts;
1760 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1766 // preprocess audio (volume)
1767 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1768 if (audio_volume != 256) {
1771 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1772 int v = ((*volp) * audio_volume + 128) >> 8;
1773 *volp++ = av_clip_int16(v);
1778 /* frame rate emulation */
1779 if (input_files[ist->file_index].rate_emu) {
1780 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1781 int64_t now = av_gettime() - ist->start;
1785 /* if output time reached then transcode raw format,
1786 encode packets and output them */
1787 for (i = 0; i < nb_ostreams; i++) {
1788 OutputFile *of = &output_files[ost_table[i].file_index];
1791 ost = &ost_table[i];
1792 if (ost->source_index != ist_index)
1795 if (of->start_time && ist->pts < of->start_time)
1798 if (of->recording_time != INT64_MAX &&
1799 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1800 (AVRational){1, 1000000}) >= 0) {
1801 ost->is_past_recording_time = 1;
1806 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1807 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1808 while (frame_available) {
1809 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1810 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1811 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1814 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1815 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1819 os = output_files[ost->file_index].ctx;
1821 /* set the input output pts pairs */
1822 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1824 if (ost->encoding_needed) {
1825 av_assert0(ist->decoding_needed);
1826 switch(ost->st->codec->codec_type) {
1827 case AVMEDIA_TYPE_AUDIO:
1828 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1830 case AVMEDIA_TYPE_VIDEO:
1832 if (ost->picref->video && !ost->frame_aspect_ratio)
1833 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1835 do_video_out(os, ost, ist, &picture, &frame_size,
1836 same_quant ? quality : ost->st->codec->global_quality);
1837 if (vstats_filename && frame_size)
1838 do_video_stats(os, ost, frame_size);
1840 case AVMEDIA_TYPE_SUBTITLE:
1841 do_subtitle_out(os, ost, ist, &subtitle,
1848 AVFrame avframe; //FIXME/XXX remove this
1851 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1852 av_init_packet(&opkt);
1854 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1855 #if !CONFIG_AVFILTER
1861 /* no reencoding needed : output the packet directly */
1862 /* force the input stream PTS */
1864 avcodec_get_frame_defaults(&avframe);
1865 ost->st->codec->coded_frame= &avframe;
1866 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1868 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1869 audio_size += data_size;
1870 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1871 video_size += data_size;
1875 opkt.stream_index= ost->index;
1876 if(pkt->pts != AV_NOPTS_VALUE)
1877 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1879 opkt.pts= AV_NOPTS_VALUE;
1881 if (pkt->dts == AV_NOPTS_VALUE)
1882 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1884 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1885 opkt.dts -= ost_tb_start_time;
1887 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1888 opkt.flags= pkt->flags;
1890 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1891 if( ost->st->codec->codec_id != CODEC_ID_H264
1892 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1893 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1895 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1896 opkt.destruct= av_destruct_packet;
1898 opkt.data = data_buf;
1899 opkt.size = data_size;
1902 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1903 /* store AVPicture in AVPacket, as expected by the output format */
1904 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1905 opkt.data = (uint8_t *)&pict;
1906 opkt.size = sizeof(AVPicture);
1907 opkt.flags |= AV_PKT_FLAG_KEY;
1909 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1910 ost->st->codec->frame_number++;
1911 ost->frame_number++;
1912 av_free_packet(&opkt);
1916 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1917 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1918 avfilter_unref_buffer(ost->picref);
1923 av_free(buffer_to_free);
1924 /* XXX: allocate the subtitles in the codec ? */
1925 if (subtitle_to_free) {
1926 avsubtitle_free(subtitle_to_free);
1927 subtitle_to_free = NULL;
1935 static void print_sdp(OutputFile *output_files, int n)
1939 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1943 for (i = 0; i < n; i++)
1944 avc[i] = output_files[i].ctx;
1946 av_sdp_create(avc, n, sdp, sizeof(sdp));
1947 printf("SDP:\n%s\n", sdp);
1952 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1953 char *error, int error_len)
1955 InputStream *ist = &input_streams[ist_index];
1956 if (ist->decoding_needed) {
1957 AVCodec *codec = ist->dec;
1959 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
1960 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1961 return AVERROR(EINVAL);
1963 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1964 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1965 ist->file_index, ist->st->index);
1966 return AVERROR(EINVAL);
1968 assert_codec_experimental(ist->st->codec, 0);
1969 assert_avoptions(ist->opts);
1972 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;
1973 ist->next_pts = AV_NOPTS_VALUE;
1979 static int transcode_init(OutputFile *output_files, int nb_output_files,
1980 InputFile *input_files, int nb_input_files)
1982 int ret = 0, i, j, k;
1983 AVFormatContext *os;
1984 AVCodecContext *codec, *icodec;
1990 /* init framerate emulation */
1991 for (i = 0; i < nb_input_files; i++) {
1992 InputFile *ifile = &input_files[i];
1993 if (ifile->rate_emu)
1994 for (j = 0; j < ifile->nb_streams; j++)
1995 input_streams[j + ifile->ist_index].start = av_gettime();
1998 /* output stream init */
1999 for(i=0;i<nb_output_files;i++) {
2000 os = output_files[i].ctx;
2001 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2002 av_dump_format(os, i, os->filename, 1);
2003 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2004 return AVERROR(EINVAL);
2008 /* for each output stream, we compute the right encoding parameters */
2009 for (i = 0; i < nb_output_streams; i++) {
2010 ost = &output_streams[i];
2011 os = output_files[ost->file_index].ctx;
2012 ist = &input_streams[ost->source_index];
2014 codec = ost->st->codec;
2015 icodec = ist->st->codec;
2017 ost->st->disposition = ist->st->disposition;
2018 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2019 codec->chroma_sample_location = icodec->chroma_sample_location;
2021 if (ost->st->stream_copy) {
2022 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2024 if (extra_size > INT_MAX) {
2025 return AVERROR(EINVAL);
2028 /* if stream_copy is selected, no need to decode or encode */
2029 codec->codec_id = icodec->codec_id;
2030 codec->codec_type = icodec->codec_type;
2032 if(!codec->codec_tag){
2033 if( !os->oformat->codec_tag
2034 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2035 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2036 codec->codec_tag = icodec->codec_tag;
2039 codec->bit_rate = icodec->bit_rate;
2040 codec->rc_max_rate = icodec->rc_max_rate;
2041 codec->rc_buffer_size = icodec->rc_buffer_size;
2042 codec->extradata= av_mallocz(extra_size);
2043 if (!codec->extradata) {
2044 return AVERROR(ENOMEM);
2046 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2047 codec->extradata_size= icodec->extradata_size;
2049 codec->time_base = ist->st->time_base;
2050 if(!strcmp(os->oformat->name, "avi")) {
2051 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){
2052 codec->time_base = icodec->time_base;
2053 codec->time_base.num *= icodec->ticks_per_frame;
2054 codec->time_base.den *= 2;
2056 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2057 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){
2058 codec->time_base = icodec->time_base;
2059 codec->time_base.num *= icodec->ticks_per_frame;
2062 av_reduce(&codec->time_base.num, &codec->time_base.den,
2063 codec->time_base.num, codec->time_base.den, INT_MAX);
2065 switch(codec->codec_type) {
2066 case AVMEDIA_TYPE_AUDIO:
2067 if(audio_volume != 256) {
2068 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2071 codec->channel_layout = icodec->channel_layout;
2072 codec->sample_rate = icodec->sample_rate;
2073 codec->channels = icodec->channels;
2074 codec->frame_size = icodec->frame_size;
2075 codec->audio_service_type = icodec->audio_service_type;
2076 codec->block_align= icodec->block_align;
2077 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2078 codec->block_align= 0;
2079 if(codec->codec_id == CODEC_ID_AC3)
2080 codec->block_align= 0;
2082 case AVMEDIA_TYPE_VIDEO:
2083 codec->pix_fmt = icodec->pix_fmt;
2084 codec->width = icodec->width;
2085 codec->height = icodec->height;
2086 codec->has_b_frames = icodec->has_b_frames;
2087 if (!codec->sample_aspect_ratio.num) {
2088 codec->sample_aspect_ratio =
2089 ost->st->sample_aspect_ratio =
2090 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2091 ist->st->codec->sample_aspect_ratio.num ?
2092 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2095 case AVMEDIA_TYPE_SUBTITLE:
2096 codec->width = icodec->width;
2097 codec->height = icodec->height;
2099 case AVMEDIA_TYPE_DATA:
2106 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2107 switch(codec->codec_type) {
2108 case AVMEDIA_TYPE_AUDIO:
2109 ost->fifo= av_fifo_alloc(1024);
2111 return AVERROR(ENOMEM);
2113 if (!codec->sample_rate) {
2114 codec->sample_rate = icodec->sample_rate;
2116 choose_sample_rate(ost->st, ost->enc);
2117 codec->time_base = (AVRational){1, codec->sample_rate};
2118 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2119 codec->sample_fmt = icodec->sample_fmt;
2120 choose_sample_fmt(ost->st, ost->enc);
2121 if (!codec->channels) {
2122 codec->channels = icodec->channels;
2123 codec->channel_layout = icodec->channel_layout;
2125 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2126 codec->channel_layout = 0;
2127 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2128 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2129 || codec->channel_layout != icodec->channel_layout;
2130 icodec->request_channels = codec->channels;
2131 ist->decoding_needed = 1;
2132 ost->encoding_needed = 1;
2133 ost->resample_sample_fmt = icodec->sample_fmt;
2134 ost->resample_sample_rate = icodec->sample_rate;
2135 ost->resample_channels = icodec->channels;
2137 case AVMEDIA_TYPE_VIDEO:
2138 if (codec->pix_fmt == PIX_FMT_NONE)
2139 codec->pix_fmt = icodec->pix_fmt;
2140 choose_pixel_fmt(ost->st, ost->enc);
2142 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2143 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2147 if (!codec->width || !codec->height) {
2148 codec->width = icodec->width;
2149 codec->height = icodec->height;
2152 ost->video_resample = codec->width != icodec->width ||
2153 codec->height != icodec->height ||
2154 codec->pix_fmt != icodec->pix_fmt;
2155 if (ost->video_resample) {
2156 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2159 ost->resample_height = icodec->height;
2160 ost->resample_width = icodec->width;
2161 ost->resample_pix_fmt= icodec->pix_fmt;
2162 ost->encoding_needed = 1;
2163 ist->decoding_needed = 1;
2165 if (!ost->frame_rate.num)
2166 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2167 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2168 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2169 ost->frame_rate = ost->enc->supported_framerates[idx];
2171 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2172 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2173 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2174 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2175 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2179 if (configure_video_filters(ist, ost)) {
2180 fprintf(stderr, "Error opening filters!\n");
2185 case AVMEDIA_TYPE_SUBTITLE:
2186 ost->encoding_needed = 1;
2187 ist->decoding_needed = 1;
2194 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2195 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2196 char logfilename[1024];
2199 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2200 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2202 if (codec->flags & CODEC_FLAG_PASS1) {
2203 f = fopen(logfilename, "wb");
2205 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2211 size_t logbuffer_size;
2212 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2213 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2216 codec->stats_in = logbuffer;
2220 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2221 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2222 int size= codec->width * codec->height;
2223 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2228 bit_buffer = av_malloc(bit_buffer_size);
2230 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2232 return AVERROR(ENOMEM);
2235 /* open each encoder */
2236 for (i = 0; i < nb_output_streams; i++) {
2237 ost = &output_streams[i];
2238 if (ost->encoding_needed) {
2239 AVCodec *codec = ost->enc;
2240 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2242 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2243 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2244 ret = AVERROR(EINVAL);
2247 if (dec->subtitle_header) {
2248 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2249 if (!ost->st->codec->subtitle_header) {
2250 ret = AVERROR(ENOMEM);
2253 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2254 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2256 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2257 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2258 ost->file_index, ost->index);
2259 ret = AVERROR(EINVAL);
2262 assert_codec_experimental(ost->st->codec, 1);
2263 assert_avoptions(ost->opts);
2264 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2265 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2266 "It takes bits/s as argument, not kbits/s\n");
2267 extra_size += ost->st->codec->extradata_size;
2269 if (ost->st->codec->me_threshold)
2270 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2274 /* init input streams */
2275 for (i = 0; i < nb_input_streams; i++)
2276 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2279 /* discard unused programs */
2280 for (i = 0; i < nb_input_files; i++) {
2281 InputFile *ifile = &input_files[i];
2282 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2283 AVProgram *p = ifile->ctx->programs[j];
2284 int discard = AVDISCARD_ALL;
2286 for (k = 0; k < p->nb_stream_indexes; k++)
2287 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2288 discard = AVDISCARD_DEFAULT;
2291 p->discard = discard;
2295 /* open files and write file headers */
2296 for (i = 0; i < nb_output_files; i++) {
2297 os = output_files[i].ctx;
2298 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2299 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2300 ret = AVERROR(EINVAL);
2303 // assert_avoptions(output_files[i].opts);
2304 if (strcmp(os->oformat->name, "rtp")) {
2310 /* dump the file output parameters - cannot be done before in case
2312 for(i=0;i<nb_output_files;i++) {
2313 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2316 /* dump the stream mapping */
2318 fprintf(stderr, "Stream mapping:\n");
2319 for (i = 0; i < nb_output_streams;i ++) {
2320 ost = &output_streams[i];
2321 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2322 input_streams[ost->source_index].file_index,
2323 input_streams[ost->source_index].st->index,
2326 if (ost->sync_ist != &input_streams[ost->source_index])
2327 fprintf(stderr, " [sync #%d.%d]",
2328 ost->sync_ist->file_index,
2329 ost->sync_ist->st->index);
2330 if (ost->st->stream_copy)
2331 fprintf(stderr, " (copy)");
2333 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2334 input_streams[ost->source_index].dec->name : "?",
2335 ost->enc ? ost->enc->name : "?");
2336 fprintf(stderr, "\n");
2341 fprintf(stderr, "%s\n", error);
2346 print_sdp(output_files, nb_output_files);
2353 * The following code is the main loop of the file converter
2355 static int transcode(OutputFile *output_files, int nb_output_files,
2356 InputFile *input_files, int nb_input_files)
2359 AVFormatContext *is, *os;
2363 int no_packet_count=0;
2364 int64_t timer_start;
2367 if (!(no_packet = av_mallocz(nb_input_files)))
2370 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2376 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2377 avio_set_interrupt_cb(decode_interrupt_cb);
2381 timer_start = av_gettime();
2383 for(; received_sigterm == 0;) {
2384 int file_index, ist_index;
2389 ipts_min= INT64_MAX;
2391 /* if 'q' pressed, exits */
2395 /* read_key() returns 0 on EOF */
2399 if (key == '+') verbose++;
2400 if (key == '-') verbose--;
2401 if (key == 's') qp_hist ^= 1;
2404 do_hex_dump = do_pkt_dump = 0;
2405 } else if(do_pkt_dump){
2409 av_log_set_level(AV_LOG_DEBUG);
2412 if (key == 'c' || key == 'C'){
2413 char ret[4096], target[64], cmd[256], arg[256]={0};
2416 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2418 while((k=read_key()) !='\n' && k!='\r' && i<sizeof(ret)-1)
2419 if(k>0) ret[i++]= k;
2421 if(k>0 && sscanf(ret, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &ts, cmd, arg) >= 3){
2422 for(i=0;i<nb_output_streams;i++) {
2424 ost = &output_streams[i];
2427 r= avfilter_graph_send_command(ost->graph, target, cmd, arg, ret, sizeof(ret), key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2428 fprintf(stderr, "Command reply for %d: %d, %s\n", i, r, ret);
2430 r= avfilter_graph_queue_command(ost->graph, target, cmd, arg, 0, ts);
2435 fprintf(stderr, "Parse error\n");
2439 if (key == 'd' || key == 'D'){
2442 debug = input_streams[0].st->codec->debug<<1;
2443 if(!debug) debug = 1;
2444 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2447 scanf("%d", &debug);
2448 for(i=0;i<nb_input_streams;i++) {
2449 input_streams[i].st->codec->debug = debug;
2451 for(i=0;i<nb_output_streams;i++) {
2452 ost = &output_streams[i];
2453 ost->st->codec->debug = debug;
2455 if(debug) av_log_set_level(AV_LOG_DEBUG);
2456 fprintf(stderr,"debug=%d\n", debug);
2459 fprintf(stderr, "key function\n"
2460 "? show this help\n"
2461 "+ increase verbosity\n"
2462 "- decrease verbosity\n"
2463 "c Send command to filtergraph\n"
2464 "D cycle through available debug modes\n"
2465 "h dump packets/hex press to cycle through the 3 states\n"
2467 "s Show QP histogram\n"
2472 /* select the stream that we must read now by looking at the
2473 smallest output pts */
2475 for (i = 0; i < nb_output_streams; i++) {
2479 ost = &output_streams[i];
2480 of = &output_files[ost->file_index];
2481 os = output_files[ost->file_index].ctx;
2482 ist = &input_streams[ost->source_index];
2483 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2484 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2486 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2488 if (!input_files[ist->file_index].eof_reached){
2489 if(ipts < ipts_min) {
2491 if(input_sync ) file_index = ist->file_index;
2493 if(opts < opts_min) {
2495 if(!input_sync) file_index = ist->file_index;
2498 if (ost->frame_number >= ost->max_frames) {
2500 for (j = of->ost_index; j < of->ctx->nb_streams; j++)
2501 output_streams[j].is_past_recording_time = 1;
2505 /* if none, if is finished */
2506 if (file_index < 0) {
2507 if(no_packet_count){
2509 memset(no_packet, 0, nb_input_files);
2516 /* read a frame from it and output it in the fifo */
2517 is = input_files[file_index].ctx;
2518 ret= av_read_frame(is, &pkt);
2519 if(ret == AVERROR(EAGAIN)){
2520 no_packet[file_index]=1;
2525 input_files[file_index].eof_reached = 1;
2533 memset(no_packet, 0, nb_input_files);
2536 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2537 is->streams[pkt.stream_index]);
2539 /* the following test is needed in case new streams appear
2540 dynamically in stream : we ignore them */
2541 if (pkt.stream_index >= input_files[file_index].nb_streams)
2542 goto discard_packet;
2543 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2544 ist = &input_streams[ist_index];
2546 goto discard_packet;
2548 if (pkt.dts != AV_NOPTS_VALUE)
2549 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2550 if (pkt.pts != AV_NOPTS_VALUE)
2551 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2553 if(pkt.pts != AV_NOPTS_VALUE)
2554 pkt.pts *= ist->ts_scale;
2555 if(pkt.dts != AV_NOPTS_VALUE)
2556 pkt.dts *= ist->ts_scale;
2558 // 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);
2559 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2560 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2561 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2562 int64_t delta= pkt_dts - ist->next_pts;
2563 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2564 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2565 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2566 pkt_dts+1<ist->pts)&& !copy_ts){
2567 input_files[ist->file_index].ts_offset -= delta;
2569 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2570 delta, input_files[ist->file_index].ts_offset);
2571 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2572 if(pkt.pts != AV_NOPTS_VALUE)
2573 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2577 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2578 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2581 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2582 ist->file_index, ist->st->index);
2585 av_free_packet(&pkt);
2590 av_free_packet(&pkt);
2592 /* dump report by using the output first video and audio streams */
2593 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2596 /* at the end of stream, we must flush the decoder buffers */
2597 for (i = 0; i < nb_input_streams; i++) {
2598 ist = &input_streams[i];
2599 if (ist->decoding_needed) {
2600 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2603 flush_encoders(output_streams, nb_output_streams);
2607 /* write the trailer if needed and close file */
2608 for(i=0;i<nb_output_files;i++) {
2609 os = output_files[i].ctx;
2610 av_write_trailer(os);
2613 /* dump report by using the first video and audio streams */
2614 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2616 /* close each encoder */
2617 for (i = 0; i < nb_output_streams; i++) {
2618 ost = &output_streams[i];
2619 if (ost->encoding_needed) {
2620 av_freep(&ost->st->codec->stats_in);
2621 avcodec_close(ost->st->codec);
2624 avfilter_graph_free(&ost->graph);
2628 /* close each decoder */
2629 for (i = 0; i < nb_input_streams; i++) {
2630 ist = &input_streams[i];
2631 if (ist->decoding_needed) {
2632 avcodec_close(ist->st->codec);
2640 av_freep(&bit_buffer);
2641 av_freep(&no_packet);
2643 if (output_streams) {
2644 for (i = 0; i < nb_output_streams; i++) {
2645 ost = &output_streams[i];
2647 if (ost->st->stream_copy)
2648 av_freep(&ost->st->codec->extradata);
2650 fclose(ost->logfile);
2651 ost->logfile = NULL;
2653 av_fifo_free(ost->fifo); /* works even if fifo is not
2654 initialized but set to zero */
2655 av_freep(&ost->st->codec->subtitle_header);
2656 av_free(ost->resample_frame.data[0]);
2657 av_free(ost->forced_kf_pts);
2658 if (ost->video_resample)
2659 sws_freeContext(ost->img_resample_ctx);
2660 swr_free(&ost->swr);
2661 av_dict_free(&ost->opts);
2668 static int opt_verbose(const char *opt, const char *arg)
2670 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2674 static int opt_frame_crop(const char *opt, const char *arg)
2676 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2677 return AVERROR(EINVAL);
2680 static int opt_pad(const char *opt, const char *arg)
2682 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2686 static double parse_frame_aspect_ratio(const char *arg)
2693 p = strchr(arg, ':');
2695 x = strtol(arg, &end, 10);
2697 y = strtol(end+1, &end, 10);
2699 ar = (double)x / (double)y;
2701 ar = strtod(arg, NULL);
2704 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2710 static int opt_video_channel(const char *opt, const char *arg)
2712 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2713 return opt_default("channel", arg);
2716 static int opt_video_standard(const char *opt, const char *arg)
2718 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2719 return opt_default("standard", arg);
2722 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2724 audio_codec_name = arg;
2725 return parse_option(o, "codec:a", arg, options);
2728 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2730 video_codec_name = arg;
2731 return parse_option(o, "codec:v", arg, options);
2734 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2736 subtitle_codec_name = arg;
2737 return parse_option(o, "codec:s", arg, options);
2740 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2742 return parse_option(o, "codec:d", arg, options);
2745 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2747 StreamMap *m = NULL;
2748 int i, negative = 0, file_idx;
2749 int sync_file_idx = -1, sync_stream_idx;
2757 map = av_strdup(arg);
2759 /* parse sync stream first, just pick first matching stream */
2760 if (sync = strchr(map, ',')) {
2762 sync_file_idx = strtol(sync + 1, &sync, 0);
2763 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2764 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2769 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2770 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2771 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2772 sync_stream_idx = i;
2775 if (i == input_files[sync_file_idx].nb_streams) {
2776 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2777 "match any streams.\n", arg);
2783 file_idx = strtol(map, &p, 0);
2784 if (file_idx >= nb_input_files || file_idx < 0) {
2785 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2789 /* disable some already defined maps */
2790 for (i = 0; i < o->nb_stream_maps; i++) {
2791 m = &o->stream_maps[i];
2792 if (check_stream_specifier(input_files[m->file_index].ctx,
2793 input_files[m->file_index].ctx->streams[m->stream_index],
2794 *p == ':' ? p + 1 : p) > 0)
2798 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2799 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2800 *p == ':' ? p + 1 : p) <= 0)
2802 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2803 &o->nb_stream_maps, o->nb_stream_maps + 1);
2804 m = &o->stream_maps[o->nb_stream_maps - 1];
2806 m->file_index = file_idx;
2807 m->stream_index = i;
2809 if (sync_file_idx >= 0) {
2810 m->sync_file_index = sync_file_idx;
2811 m->sync_stream_index = sync_stream_idx;
2813 m->sync_file_index = file_idx;
2814 m->sync_stream_index = i;
2819 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2827 static void parse_meta_type(char *arg, char *type, int *index)
2837 if (*(++arg) == ':')
2838 *index = strtol(++arg, NULL, 0);
2841 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2848 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2850 MetadataMap *m, *m1;
2853 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2854 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2856 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2857 m->file = strtol(arg, &p, 0);
2858 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2860 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2861 if (p = strchr(opt, ':'))
2862 parse_meta_type(p + 1, &m1->type, &m1->index);
2866 if (m->type == 'g' || m1->type == 'g')
2867 o->metadata_global_manual = 1;
2868 if (m->type == 's' || m1->type == 's')
2869 o->metadata_streams_manual = 1;
2870 if (m->type == 'c' || m1->type == 'c')
2871 o->metadata_chapters_manual = 1;
2876 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2878 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2879 "Use -map_metadata instead.\n");
2880 return opt_map_metadata(o, opt, arg);
2883 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
2886 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2887 struct tm time = *gmtime((time_t*)&recording_timestamp);
2888 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2889 parse_option(o, "metadata", buf, options);
2891 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2892 "tag instead.\n", opt);
2896 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2898 const char *codec_string = encoder ? "encoder" : "decoder";
2902 return CODEC_ID_NONE;
2904 avcodec_find_encoder_by_name(name) :
2905 avcodec_find_decoder_by_name(name);
2907 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2910 if(codec->type != type) {
2911 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2917 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2919 char *codec_name = NULL;
2921 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2925 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2926 return avcodec_find_encoder(st->codec->codec_id);
2928 } else if (!strcmp(codec_name, "copy"))
2929 st->stream_copy = 1;
2931 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2932 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2933 avcodec_find_decoder_by_name(codec_name);
2940 * Add all the streams from the given input file to the global
2941 * list of input streams.
2943 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2945 int i, rfps, rfps_base;
2947 for (i = 0; i < ic->nb_streams; i++) {
2948 AVStream *st = ic->streams[i];
2949 AVCodecContext *dec = st->codec;
2953 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2954 ist = &input_streams[nb_input_streams - 1];
2956 ist->file_index = nb_input_files;
2958 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2960 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2961 ist->ts_scale = scale;
2963 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2965 ist->dec = avcodec_find_decoder(dec->codec_id);
2967 switch (dec->codec_type) {
2968 case AVMEDIA_TYPE_AUDIO:
2970 ist->dec = avcodec_find_decoder(dec->codec_id);
2971 if(o->audio_disable)
2972 st->discard= AVDISCARD_ALL;
2974 case AVMEDIA_TYPE_VIDEO:
2976 ist->dec = avcodec_find_decoder(dec->codec_id);
2977 rfps = ic->streams[i]->r_frame_rate.num;
2978 rfps_base = ic->streams[i]->r_frame_rate.den;
2980 dec->flags |= CODEC_FLAG_EMU_EDGE;
2983 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2986 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2987 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2989 (float)rfps / rfps_base, rfps, rfps_base);
2992 if (o->video_disable)
2993 st->discard= AVDISCARD_ALL;
2994 else if(video_discard)
2995 st->discard= video_discard;
2997 case AVMEDIA_TYPE_DATA:
2999 case AVMEDIA_TYPE_SUBTITLE:
3001 ist->dec = avcodec_find_decoder(dec->codec_id);
3002 if(o->subtitle_disable)
3003 st->discard = AVDISCARD_ALL;
3005 case AVMEDIA_TYPE_ATTACHMENT:
3006 case AVMEDIA_TYPE_UNKNOWN:
3014 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3016 AVFormatContext *ic;
3017 AVInputFormat *file_iformat = NULL;
3021 AVDictionary **opts;
3022 int orig_nb_streams; // number of streams before avformat_find_stream_info
3025 if (!(file_iformat = av_find_input_format(o->format))) {
3026 fprintf(stderr, "Unknown input format: '%s'\n", o->format);
3031 if (!strcmp(filename, "-"))
3034 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3035 !strcmp(filename, "/dev/stdin");
3037 /* get default parameters from command line */
3038 ic = avformat_alloc_context();
3040 print_error(filename, AVERROR(ENOMEM));
3043 if (o->nb_audio_sample_rate) {
3044 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3045 av_dict_set(&format_opts, "sample_rate", buf, 0);
3047 if (o->nb_audio_channels) {
3048 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3049 av_dict_set(&format_opts, "channels", buf, 0);
3051 if (o->nb_frame_rates) {
3052 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3054 if (o->nb_frame_sizes) {
3055 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3057 if (o->nb_frame_pix_fmts)
3058 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3060 ic->flags |= AVFMT_FLAG_NONBLOCK;
3063 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3064 ic->loop_input = loop_input;
3067 /* open the input file with generic libav function */
3068 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3070 print_error(filename, err);
3073 assert_avoptions(format_opts);
3075 /* apply forced codec ids */
3076 for (i = 0; i < ic->nb_streams; i++)
3077 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3079 /* Set AVCodecContext options for avformat_find_stream_info */
3080 opts = setup_find_stream_info_opts(ic, codec_opts);
3081 orig_nb_streams = ic->nb_streams;
3083 /* If not enough info to get the stream parameters, we decode the
3084 first frames to get it. (used in mpeg case for example) */
3085 ret = avformat_find_stream_info(ic, opts);
3086 if (ret < 0 && verbose >= 0) {
3087 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3088 av_close_input_file(ic);
3092 timestamp = o->start_time;
3093 /* add the stream start time */
3094 if (ic->start_time != AV_NOPTS_VALUE)
3095 timestamp += ic->start_time;
3097 /* if seeking requested, we execute it */
3098 if (o->start_time != 0) {
3099 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3101 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3102 filename, (double)timestamp / AV_TIME_BASE);
3106 /* update the current parameters so that they match the one of the input stream */
3107 add_input_streams(o, ic);
3109 /* dump the file content */
3111 av_dump_format(ic, nb_input_files, filename, 0);
3113 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3114 input_files[nb_input_files - 1].ctx = ic;
3115 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3116 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3117 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3118 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3120 for (i = 0; i < orig_nb_streams; i++)
3121 av_dict_free(&opts[i]);
3124 reset_options(o, 1);
3128 static void parse_forced_key_frames(char *kf, OutputStream *ost, AVCodecContext *avctx)
3134 for (p = kf; *p; p++)
3137 ost->forced_kf_count = n;
3138 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3139 if (!ost->forced_kf_pts) {
3140 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3143 for (i = 0; i < n; i++) {
3144 p = i ? strchr(p, ',') + 1 : kf;
3145 t = parse_time_or_die("force_key_frames", p, 1);
3146 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3150 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3153 AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
3154 int idx = oc->nb_streams - 1;
3155 int64_t max_frames = INT64_MAX;
3156 char *bsf = NULL, *next, *codec_tag = NULL;
3157 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3161 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3165 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3166 nb_output_streams + 1);
3167 ost = &output_streams[nb_output_streams - 1];
3168 ost->file_index = nb_output_files;
3171 st->codec->codec_type = type;
3172 ost->enc = choose_codec(o, oc, st, type);
3174 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3177 avcodec_get_context_defaults3(st->codec, ost->enc);
3178 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3180 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3181 ost->max_frames = max_frames;
3183 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3185 if (next = strchr(bsf, ','))
3187 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3188 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter %s\n", bsf);
3192 bsfc_prev->next = bsfc;
3194 ost->bitstream_filters = bsfc;
3200 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3202 uint32_t tag = strtol(codec_tag, &next, 0);
3204 tag = AV_RL32(codec_tag);
3205 st->codec->codec_tag = tag;
3208 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3209 if (qscale >= 0 || same_quant) {
3210 st->codec->flags |= CODEC_FLAG_QSCALE;
3211 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3214 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3218 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3221 const char *p = str;
3228 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3235 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3239 AVCodecContext *video_enc;
3241 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3243 video_enc = st->codec;
3245 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3246 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3249 if (!st->stream_copy) {
3250 const char *p = NULL;
3251 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3252 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3253 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3254 int i, force_fps = 0, top_field_first = -1;
3256 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3257 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3258 av_log(NULL, AV_LOG_ERROR, "Invalid framerate value: %s\n", frame_rate);
3262 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3263 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3264 av_log(NULL, AV_LOG_ERROR, "Invalid frame size: %s.\n", frame_size);
3268 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3269 if (frame_aspect_ratio)
3270 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3272 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3273 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3274 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3275 av_log(NULL, AV_LOG_ERROR, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3278 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3281 video_enc->gop_size = 0;
3282 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3284 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3285 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for intra matrix.\n");
3288 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3290 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3292 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3293 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for inter matrix.\n");
3296 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3299 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3302 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3304 fprintf(stderr, "error parsing rc_override\n");
3307 video_enc->rc_override=
3308 av_realloc(video_enc->rc_override,
3309 sizeof(RcOverride)*(i+1));
3310 video_enc->rc_override[i].start_frame= start;
3311 video_enc->rc_override[i].end_frame = end;
3313 video_enc->rc_override[i].qscale= q;
3314 video_enc->rc_override[i].quality_factor= 1.0;
3317 video_enc->rc_override[i].qscale= 0;
3318 video_enc->rc_override[i].quality_factor= -q/100.0;
3323 video_enc->rc_override_count=i;
3324 if (!video_enc->rc_initial_buffer_occupancy)
3325 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3326 video_enc->intra_dc_precision= intra_dc_precision - 8;
3331 video_enc->flags |= CODEC_FLAG_PASS1;
3333 video_enc->flags |= CODEC_FLAG_PASS2;
3337 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3338 if (forced_key_frames)
3339 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3341 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3342 ost->force_fps = force_fps;
3344 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3345 ost->top_field_first = top_field_first;
3348 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3350 ost->avfilter = av_strdup(filters);
3357 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3361 AVCodecContext *audio_enc;
3363 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3366 audio_enc = st->codec;
3367 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3369 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3370 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3372 if (!st->stream_copy) {
3373 char *sample_fmt = NULL;
3375 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3377 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3379 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3380 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", sample_fmt);
3384 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3390 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3394 AVCodecContext *data_enc;
3396 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3398 data_enc = st->codec;
3399 if (!st->stream_copy) {
3400 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3404 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3405 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3411 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3415 AVCodecContext *subtitle_enc;
3417 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3419 subtitle_enc = st->codec;
3421 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3423 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3424 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3430 /* arg format is "output-stream-index:streamid-value". */
3431 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3437 av_strlcpy(idx_str, arg, sizeof(idx_str));
3438 p = strchr(idx_str, ':');
3441 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3446 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3447 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3448 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3452 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3454 AVFormatContext *is = ifile->ctx;
3455 AVFormatContext *os = ofile->ctx;
3458 for (i = 0; i < is->nb_chapters; i++) {
3459 AVChapter *in_ch = is->chapters[i], *out_ch;
3460 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3461 AV_TIME_BASE_Q, in_ch->time_base);
3462 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3463 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3466 if (in_ch->end < ts_off)
3468 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3471 out_ch = av_mallocz(sizeof(AVChapter));
3473 return AVERROR(ENOMEM);
3475 out_ch->id = in_ch->id;
3476 out_ch->time_base = in_ch->time_base;
3477 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3478 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3481 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3484 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3486 return AVERROR(ENOMEM);
3487 os->chapters[os->nb_chapters - 1] = out_ch;
3492 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3495 AVFormatContext *ic = NULL;
3497 err = avformat_open_input(&ic, filename, NULL, NULL);
3500 /* copy stream format */
3501 for(i=0;i<ic->nb_streams;i++) {
3506 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3507 ost = new_output_stream(o, s, codec->type);
3510 // FIXME: a more elegant solution is needed
3511 memcpy(st, ic->streams[i], sizeof(AVStream));
3512 st->info = av_malloc(sizeof(*st->info));
3513 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3514 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3516 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3517 choose_sample_fmt(st, codec);
3518 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3519 choose_pixel_fmt(st, codec);
3522 av_close_input_file(ic);
3526 static void opt_output_file(void *optctx, const char *filename)
3528 OptionsContext *o = optctx;
3529 AVFormatContext *oc;
3531 AVOutputFormat *file_oformat;
3535 if (!strcmp(filename, "-"))
3538 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3540 print_error(filename, err);
3543 file_oformat= oc->oformat;
3545 if (!strcmp(file_oformat->name, "ffm") &&
3546 av_strstart(filename, "http:", NULL)) {
3547 /* special case for files sent to ffserver: we get the stream
3548 parameters from ffserver */
3549 int err = read_ffserver_streams(o, oc, filename);
3551 print_error(filename, err);
3554 } else if (!o->nb_stream_maps) {
3555 /* pick the "best" stream of each type */
3556 #define NEW_STREAM(type, index)\
3558 ost = new_ ## type ## _stream(o, oc);\
3559 ost->source_index = index;\
3560 ost->sync_ist = &input_streams[index];\
3561 input_streams[index].discard = 0;\
3564 /* video: highest resolution */
3565 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3566 int area = 0, idx = -1;
3567 for (i = 0; i < nb_input_streams; i++) {
3568 ist = &input_streams[i];
3569 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3570 ist->st->codec->width * ist->st->codec->height > area) {
3571 area = ist->st->codec->width * ist->st->codec->height;
3575 NEW_STREAM(video, idx);
3578 /* audio: most channels */
3579 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3580 int channels = 0, idx = -1;
3581 for (i = 0; i < nb_input_streams; i++) {
3582 ist = &input_streams[i];
3583 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3584 ist->st->codec->channels > channels) {
3585 channels = ist->st->codec->channels;
3589 NEW_STREAM(audio, idx);
3592 /* subtitles: pick first */
3593 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3594 for (i = 0; i < nb_input_streams; i++)
3595 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3596 NEW_STREAM(subtitle, i);
3600 /* do something with data? */
3602 for (i = 0; i < o->nb_stream_maps; i++) {
3603 StreamMap *map = &o->stream_maps[i];
3608 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3609 switch (ist->st->codec->codec_type) {
3610 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3611 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3612 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3613 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3615 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3616 map->file_index, map->stream_index);
3620 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3621 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3622 map->sync_stream_index];
3627 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3628 output_files[nb_output_files - 1].ctx = oc;
3629 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3630 output_files[nb_output_files - 1].recording_time = o->recording_time;
3631 output_files[nb_output_files - 1].start_time = o->start_time;
3632 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3633 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3635 /* check filename in case of an image number is expected */
3636 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3637 if (!av_filename_number_test(oc->filename)) {
3638 print_error(oc->filename, AVERROR(EINVAL));
3643 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3644 /* test if it already exists to avoid loosing precious files */
3645 if (!file_overwrite &&
3646 (strchr(filename, ':') == NULL ||
3647 filename[1] == ':' ||
3648 av_strstart(filename, "file:", NULL))) {
3649 if (avio_check(filename, 0) == 0) {
3651 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3653 if (!read_yesno()) {
3654 fprintf(stderr, "Not overwriting - exiting\n");
3659 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3666 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3667 print_error(filename, err);
3672 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3673 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3675 if (loop_output >= 0) {
3676 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3677 oc->loop_output = loop_output;
3681 if (o->chapters_input_file >= nb_input_files) {
3682 if (o->chapters_input_file == INT_MAX) {
3683 /* copy chapters from the first input file that has them*/
3684 o->chapters_input_file = -1;
3685 for (i = 0; i < nb_input_files; i++)
3686 if (input_files[i].ctx->nb_chapters) {
3687 o->chapters_input_file = i;
3691 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3692 o->chapters_input_file);
3696 if (o->chapters_input_file >= 0)
3697 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3698 !o->metadata_chapters_manual);
3701 for (i = 0; i < o->nb_meta_data_maps; i++) {
3702 AVFormatContext *files[2];
3703 AVDictionary **meta[2];
3706 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3707 if ((index) < 0 || (index) >= (nb_elems)) {\
3708 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3713 int in_file_index = o->meta_data_maps[i][1].file;
3714 if (in_file_index < 0)
3716 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3719 files[1] = input_files[in_file_index].ctx;
3721 for (j = 0; j < 2; j++) {
3722 MetadataMap *map = &o->meta_data_maps[i][j];
3724 switch (map->type) {
3726 meta[j] = &files[j]->metadata;
3729 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3730 meta[j] = &files[j]->streams[map->index]->metadata;
3733 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3734 meta[j] = &files[j]->chapters[map->index]->metadata;
3737 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3738 meta[j] = &files[j]->programs[map->index]->metadata;
3743 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3746 /* copy global metadata by default */
3747 if (!o->metadata_global_manual && nb_input_files){
3748 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3749 AV_DICT_DONT_OVERWRITE);
3750 if(o->recording_time != INT64_MAX)
3751 av_dict_set(&oc->metadata, "duration", NULL, 0);
3753 if (!o->metadata_streams_manual)
3754 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3755 InputStream *ist = &input_streams[output_streams[i].source_index];
3756 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3759 /* process manually set metadata */
3760 for (i = 0; i < o->nb_metadata; i++) {
3765 val = strchr(o->metadata[i].u.str, '=');
3767 av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3768 o->metadata[i].u.str);
3773 parse_meta_type(o->metadata[i].specifier, &type, &index);
3779 if (index < 0 || index >= oc->nb_streams) {
3780 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3783 m = &oc->streams[index]->metadata;
3786 if (index < 0 || index >= oc->nb_chapters) {
3787 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3790 m = &oc->chapters[index]->metadata;
3793 av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3797 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3800 reset_options(o, 0);
3803 /* same option as mencoder */
3804 static int opt_pass(const char *opt, const char *arg)
3806 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3810 static int64_t getutime(void)
3813 struct rusage rusage;
3815 getrusage(RUSAGE_SELF, &rusage);
3816 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3817 #elif HAVE_GETPROCESSTIMES
3819 FILETIME c, e, k, u;
3820 proc = GetCurrentProcess();
3821 GetProcessTimes(proc, &c, &e, &k, &u);
3822 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3824 return av_gettime();
3828 static int64_t getmaxrss(void)
3830 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3831 struct rusage rusage;
3832 getrusage(RUSAGE_SELF, &rusage);
3833 return (int64_t)rusage.ru_maxrss * 1024;
3834 #elif HAVE_GETPROCESSMEMORYINFO
3836 PROCESS_MEMORY_COUNTERS memcounters;
3837 proc = GetCurrentProcess();
3838 memcounters.cb = sizeof(memcounters);
3839 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3840 return memcounters.PeakPagefileUsage;
3846 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3848 return parse_option(o, "q:a", arg, options);
3851 static void show_usage(void)
3853 printf("Hyper fast Audio and Video encoder\n");
3854 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3858 static int opt_help(const char *opt, const char *arg)
3861 AVOutputFormat *oformat = NULL;
3862 AVInputFormat *iformat = NULL;
3863 const AVClass *class;
3865 av_log_set_callback(log_callback_help);
3867 show_help_options(options, "Main options:\n",
3868 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3869 show_help_options(options, "\nAdvanced options:\n",
3870 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3872 show_help_options(options, "\nVideo options:\n",
3873 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3875 show_help_options(options, "\nAdvanced Video options:\n",
3876 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3877 OPT_VIDEO | OPT_EXPERT);
3878 show_help_options(options, "\nAudio options:\n",
3879 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3881 show_help_options(options, "\nAdvanced Audio options:\n",
3882 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3883 OPT_AUDIO | OPT_EXPERT);
3884 show_help_options(options, "\nSubtitle options:\n",
3885 OPT_SUBTITLE | OPT_GRAB,
3887 show_help_options(options, "\nAudio/Video grab options:\n",
3891 class = avcodec_get_class();
3892 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3895 /* individual codec options */
3897 while ((c = av_codec_next(c))) {
3898 if (c->priv_class) {
3899 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3904 class = avformat_get_class();
3905 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3908 /* individual muxer options */
3909 while ((oformat = av_oformat_next(oformat))) {
3910 if (oformat->priv_class) {
3911 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3916 /* individual demuxer options */
3917 while ((iformat = av_iformat_next(iformat))) {
3918 if (iformat->priv_class) {
3919 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3924 class = sws_get_class();
3925 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3929 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3931 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3932 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3934 if(!strncmp(arg, "pal-", 4)) {
3937 } else if(!strncmp(arg, "ntsc-", 5)) {
3940 } else if(!strncmp(arg, "film-", 5)) {
3944 /* Try to determine PAL/NTSC by peeking in the input files */
3945 if(nb_input_files) {
3947 for (j = 0; j < nb_input_files; j++) {
3948 for (i = 0; i < input_files[j].nb_streams; i++) {
3949 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3950 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3952 fr = c->time_base.den * 1000 / c->time_base.num;
3956 } else if((fr == 29970) || (fr == 23976)) {
3965 if(verbose > 0 && norm != UNKNOWN)
3966 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3969 if(norm == UNKNOWN) {
3970 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3971 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3972 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3976 if(!strcmp(arg, "vcd")) {
3977 opt_video_codec(o, "c:v", "mpeg1video");
3978 opt_audio_codec(o, "c:a", "mp2");
3979 parse_option(o, "f", "vcd", options);
3981 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3982 parse_option(o, "r", frame_rates[norm], options);
3983 opt_default("g", norm == PAL ? "15" : "18");
3985 opt_default("b", "1150000");
3986 opt_default("maxrate", "1150000");
3987 opt_default("minrate", "1150000");
3988 opt_default("bufsize", "327680"); // 40*1024*8;
3990 opt_default("b:a", "224000");
3991 parse_option(o, "ar", "44100", options);
3992 parse_option(o, "ac", "2", options);
3994 opt_default("packetsize", "2324");
3995 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3997 /* We have to offset the PTS, so that it is consistent with the SCR.
3998 SCR starts at 36000, but the first two packs contain only padding
3999 and the first pack from the other stream, respectively, may also have
4000 been written before.
4001 So the real data starts at SCR 36000+3*1200. */
4002 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4003 } else if(!strcmp(arg, "svcd")) {
4005 opt_video_codec(o, "c:v", "mpeg2video");
4006 opt_audio_codec(o, "c:a", "mp2");
4007 parse_option(o, "f", "svcd", options);
4009 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4010 parse_option(o, "r", frame_rates[norm], options);
4011 parse_option(o, "pix_fmt", "yuv420p", options);
4012 opt_default("g", norm == PAL ? "15" : "18");
4014 opt_default("b", "2040000");
4015 opt_default("maxrate", "2516000");
4016 opt_default("minrate", "0"); //1145000;
4017 opt_default("bufsize", "1835008"); //224*1024*8;
4018 opt_default("flags", "+scan_offset");
4021 opt_default("b:a", "224000");
4022 parse_option(o, "ar", "44100", options);
4024 opt_default("packetsize", "2324");
4026 } else if(!strcmp(arg, "dvd")) {
4028 opt_video_codec(o, "c:v", "mpeg2video");
4029 opt_audio_codec(o, "c:a", "ac3");
4030 parse_option(o, "f", "dvd", options);
4032 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4033 parse_option(o, "r", frame_rates[norm], options);
4034 parse_option(o, "pix_fmt", "yuv420p", options);
4035 opt_default("g", norm == PAL ? "15" : "18");
4037 opt_default("b", "6000000");
4038 opt_default("maxrate", "9000000");
4039 opt_default("minrate", "0"); //1500000;
4040 opt_default("bufsize", "1835008"); //224*1024*8;
4042 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4043 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4045 opt_default("b:a", "448000");
4046 parse_option(o, "ar", "48000", options);
4048 } else if(!strncmp(arg, "dv", 2)) {
4050 parse_option(o, "f", "dv", options);
4052 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4053 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4054 norm == PAL ? "yuv420p" : "yuv411p", options);
4055 parse_option(o, "r", frame_rates[norm], options);
4057 parse_option(o, "ar", "48000", options);
4058 parse_option(o, "ac", "2", options);
4061 fprintf(stderr, "Unknown target: %s\n", arg);
4062 return AVERROR(EINVAL);
4067 static int opt_vstats_file(const char *opt, const char *arg)
4069 av_free (vstats_filename);
4070 vstats_filename=av_strdup (arg);
4074 static int opt_vstats(const char *opt, const char *arg)
4077 time_t today2 = time(NULL);
4078 struct tm *today = localtime(&today2);
4080 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4082 return opt_vstats_file(opt, filename);
4085 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4087 return parse_option(o, "frames:v", arg, options);
4090 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4092 return parse_option(o, "frames:a", arg, options);
4095 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4097 return parse_option(o, "frames:d", arg, options);
4100 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4103 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4104 const char *codec_name = *opt == 'v' ? video_codec_name :
4105 *opt == 'a' ? audio_codec_name :
4106 subtitle_codec_name;
4108 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4109 fprintf(stderr, "File for preset '%s' not found\n", arg);
4114 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4115 if(line[0] == '#' && !e)
4117 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4119 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4122 if(!strcmp(tmp, "acodec")){
4123 opt_audio_codec(o, tmp, tmp2);
4124 }else if(!strcmp(tmp, "vcodec")){
4125 opt_video_codec(o, tmp, tmp2);
4126 }else if(!strcmp(tmp, "scodec")){
4127 opt_subtitle_codec(o, tmp, tmp2);
4128 }else if(!strcmp(tmp, "dcodec")){
4129 opt_data_codec(o, tmp, tmp2);
4130 }else if(opt_default(tmp, tmp2) < 0){
4131 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4141 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4145 static int opt_passlogfile(const char *opt, const char *arg)
4147 pass_logfilename_prefix = arg;
4148 #if CONFIG_LIBX264_ENCODER
4149 return opt_default("passlogfile", arg);
4155 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4157 char *s= av_malloc(strlen(opt)+2);
4158 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4159 return parse_option(o, s, arg, options);
4162 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4164 return parse_option(o, "filter:v", arg, options);
4167 #define OFFSET(x) offsetof(OptionsContext, x)
4168 static const OptionDef options[] = {
4170 #include "cmdutils_common_opts.h"
4171 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4172 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4173 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4174 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4175 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4176 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4177 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4178 "outfile[,metadata]:infile[,metadata]" },
4179 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4180 "outfile[,metadata]:infile[,metadata]" },
4181 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4182 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4183 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4184 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4185 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4186 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4187 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4188 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4189 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4190 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4191 "add timings for benchmarking" },
4192 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4193 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4194 "dump each input packet" },
4195 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4196 "when dumping packets, also dump the payload" },
4197 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4198 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4199 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4200 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4201 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4202 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4203 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4204 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4205 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4206 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4207 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4208 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4209 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4210 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4211 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4212 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4213 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4214 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4216 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4220 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4221 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4222 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4223 { "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" },
4224 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4225 { "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" },
4226 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4227 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4228 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4229 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4230 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4231 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4232 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4233 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4234 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4235 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4236 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4237 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4238 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4239 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4240 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4241 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4242 "use same quantizer as source (implies VBR)" },
4243 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4244 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4245 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4246 "deinterlace pictures" },
4247 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4248 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4250 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4252 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4253 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4254 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4255 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4256 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4257 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4258 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4259 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4260 { "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" },
4263 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4264 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4265 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4266 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4267 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4268 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4269 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4270 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4271 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4273 /* subtitle options */
4274 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4275 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4276 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4279 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4280 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4281 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4284 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4285 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4287 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4288 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4289 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4291 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4292 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4293 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4294 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4295 /* data codec support */
4296 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4298 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4302 int main(int argc, char **argv)
4304 OptionsContext o = { 0 };
4307 reset_options(&o, 0);
4309 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4311 if(argc>1 && !strcmp(argv[1], "-d")){
4314 av_log_set_callback(log_callback_null);
4319 avcodec_register_all();
4321 avdevice_register_all();
4324 avfilter_register_all();
4329 if(isatty(STDIN_FILENO))
4330 avio_set_interrupt_cb(decode_interrupt_cb);
4337 parse_options(&o, argc, argv, options, opt_output_file);
4339 if(nb_output_files <= 0 && nb_input_files == 0) {
4341 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4345 /* file converter / grab */
4346 if (nb_output_files <= 0) {
4347 fprintf(stderr, "At least one output file must be specified\n");
4351 if (nb_input_files == 0) {
4352 fprintf(stderr, "At least one input file must be specified\n");
4357 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4359 ti = getutime() - ti;
4361 int maxrss = getmaxrss() / 1024;
4362 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);