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,
1850 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1851 av_init_packet(&opkt);
1853 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1854 #if !CONFIG_AVFILTER
1860 /* no reencoding needed : output the packet directly */
1861 /* force the input stream PTS */
1863 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1864 audio_size += data_size;
1865 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1866 video_size += data_size;
1870 opkt.stream_index= ost->index;
1871 if(pkt->pts != AV_NOPTS_VALUE)
1872 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1874 opkt.pts= AV_NOPTS_VALUE;
1876 if (pkt->dts == AV_NOPTS_VALUE)
1877 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1879 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1880 opkt.dts -= ost_tb_start_time;
1882 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1883 opkt.flags= pkt->flags;
1885 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1886 if( ost->st->codec->codec_id != CODEC_ID_H264
1887 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1888 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1890 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1891 opkt.destruct= av_destruct_packet;
1893 opkt.data = data_buf;
1894 opkt.size = data_size;
1897 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1898 /* store AVPicture in AVPacket, as expected by the output format */
1899 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1900 opkt.data = (uint8_t *)&pict;
1901 opkt.size = sizeof(AVPicture);
1902 opkt.flags |= AV_PKT_FLAG_KEY;
1904 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1905 ost->st->codec->frame_number++;
1906 ost->frame_number++;
1907 av_free_packet(&opkt);
1911 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1912 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1913 avfilter_unref_buffer(ost->picref);
1918 av_free(buffer_to_free);
1919 /* XXX: allocate the subtitles in the codec ? */
1920 if (subtitle_to_free) {
1921 avsubtitle_free(subtitle_to_free);
1922 subtitle_to_free = NULL;
1930 static void print_sdp(OutputFile *output_files, int n)
1934 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1938 for (i = 0; i < n; i++)
1939 avc[i] = output_files[i].ctx;
1941 av_sdp_create(avc, n, sdp, sizeof(sdp));
1942 printf("SDP:\n%s\n", sdp);
1947 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1948 char *error, int error_len)
1950 InputStream *ist = &input_streams[ist_index];
1951 if (ist->decoding_needed) {
1952 AVCodec *codec = ist->dec;
1954 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
1955 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1956 return AVERROR(EINVAL);
1958 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1959 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1960 ist->file_index, ist->st->index);
1961 return AVERROR(EINVAL);
1963 assert_codec_experimental(ist->st->codec, 0);
1964 assert_avoptions(ist->opts);
1967 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;
1968 ist->next_pts = AV_NOPTS_VALUE;
1974 static int transcode_init(OutputFile *output_files, int nb_output_files,
1975 InputFile *input_files, int nb_input_files)
1977 int ret = 0, i, j, k;
1978 AVFormatContext *os;
1979 AVCodecContext *codec, *icodec;
1985 /* init framerate emulation */
1986 for (i = 0; i < nb_input_files; i++) {
1987 InputFile *ifile = &input_files[i];
1988 if (ifile->rate_emu)
1989 for (j = 0; j < ifile->nb_streams; j++)
1990 input_streams[j + ifile->ist_index].start = av_gettime();
1993 /* output stream init */
1994 for(i=0;i<nb_output_files;i++) {
1995 os = output_files[i].ctx;
1996 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1997 av_dump_format(os, i, os->filename, 1);
1998 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1999 return AVERROR(EINVAL);
2003 /* for each output stream, we compute the right encoding parameters */
2004 for (i = 0; i < nb_output_streams; i++) {
2005 ost = &output_streams[i];
2006 os = output_files[ost->file_index].ctx;
2007 ist = &input_streams[ost->source_index];
2009 codec = ost->st->codec;
2010 icodec = ist->st->codec;
2012 ost->st->disposition = ist->st->disposition;
2013 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2014 codec->chroma_sample_location = icodec->chroma_sample_location;
2016 if (ost->st->stream_copy) {
2017 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2019 if (extra_size > INT_MAX) {
2020 return AVERROR(EINVAL);
2023 /* if stream_copy is selected, no need to decode or encode */
2024 codec->codec_id = icodec->codec_id;
2025 codec->codec_type = icodec->codec_type;
2027 if(!codec->codec_tag){
2028 if( !os->oformat->codec_tag
2029 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2030 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2031 codec->codec_tag = icodec->codec_tag;
2034 codec->bit_rate = icodec->bit_rate;
2035 codec->rc_max_rate = icodec->rc_max_rate;
2036 codec->rc_buffer_size = icodec->rc_buffer_size;
2037 codec->extradata= av_mallocz(extra_size);
2038 if (!codec->extradata) {
2039 return AVERROR(ENOMEM);
2041 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2042 codec->extradata_size= icodec->extradata_size;
2044 codec->time_base = ist->st->time_base;
2045 if(!strcmp(os->oformat->name, "avi")) {
2046 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){
2047 codec->time_base = icodec->time_base;
2048 codec->time_base.num *= icodec->ticks_per_frame;
2049 codec->time_base.den *= 2;
2051 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2052 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){
2053 codec->time_base = icodec->time_base;
2054 codec->time_base.num *= icodec->ticks_per_frame;
2057 av_reduce(&codec->time_base.num, &codec->time_base.den,
2058 codec->time_base.num, codec->time_base.den, INT_MAX);
2060 switch(codec->codec_type) {
2061 case AVMEDIA_TYPE_AUDIO:
2062 if(audio_volume != 256) {
2063 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2066 codec->channel_layout = icodec->channel_layout;
2067 codec->sample_rate = icodec->sample_rate;
2068 codec->channels = icodec->channels;
2069 codec->frame_size = icodec->frame_size;
2070 codec->audio_service_type = icodec->audio_service_type;
2071 codec->block_align= icodec->block_align;
2072 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2073 codec->block_align= 0;
2074 if(codec->codec_id == CODEC_ID_AC3)
2075 codec->block_align= 0;
2077 case AVMEDIA_TYPE_VIDEO:
2078 codec->pix_fmt = icodec->pix_fmt;
2079 codec->width = icodec->width;
2080 codec->height = icodec->height;
2081 codec->has_b_frames = icodec->has_b_frames;
2082 if (!codec->sample_aspect_ratio.num) {
2083 codec->sample_aspect_ratio =
2084 ost->st->sample_aspect_ratio =
2085 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2086 ist->st->codec->sample_aspect_ratio.num ?
2087 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2090 case AVMEDIA_TYPE_SUBTITLE:
2091 codec->width = icodec->width;
2092 codec->height = icodec->height;
2094 case AVMEDIA_TYPE_DATA:
2101 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2102 switch(codec->codec_type) {
2103 case AVMEDIA_TYPE_AUDIO:
2104 ost->fifo= av_fifo_alloc(1024);
2106 return AVERROR(ENOMEM);
2108 if (!codec->sample_rate) {
2109 codec->sample_rate = icodec->sample_rate;
2111 choose_sample_rate(ost->st, ost->enc);
2112 codec->time_base = (AVRational){1, codec->sample_rate};
2113 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2114 codec->sample_fmt = icodec->sample_fmt;
2115 choose_sample_fmt(ost->st, ost->enc);
2116 if (!codec->channels) {
2117 codec->channels = icodec->channels;
2118 codec->channel_layout = icodec->channel_layout;
2120 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2121 codec->channel_layout = 0;
2122 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2123 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2124 || codec->channel_layout != icodec->channel_layout;
2125 icodec->request_channels = codec->channels;
2126 ist->decoding_needed = 1;
2127 ost->encoding_needed = 1;
2128 ost->resample_sample_fmt = icodec->sample_fmt;
2129 ost->resample_sample_rate = icodec->sample_rate;
2130 ost->resample_channels = icodec->channels;
2132 case AVMEDIA_TYPE_VIDEO:
2133 if (codec->pix_fmt == PIX_FMT_NONE)
2134 codec->pix_fmt = icodec->pix_fmt;
2135 choose_pixel_fmt(ost->st, ost->enc);
2137 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2138 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2142 if (!codec->width || !codec->height) {
2143 codec->width = icodec->width;
2144 codec->height = icodec->height;
2147 ost->video_resample = codec->width != icodec->width ||
2148 codec->height != icodec->height ||
2149 codec->pix_fmt != icodec->pix_fmt;
2150 if (ost->video_resample) {
2151 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2154 ost->resample_height = icodec->height;
2155 ost->resample_width = icodec->width;
2156 ost->resample_pix_fmt= icodec->pix_fmt;
2157 ost->encoding_needed = 1;
2158 ist->decoding_needed = 1;
2160 if (!ost->frame_rate.num)
2161 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2162 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2163 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2164 ost->frame_rate = ost->enc->supported_framerates[idx];
2166 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2167 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2168 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2169 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2170 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2174 if (configure_video_filters(ist, ost)) {
2175 fprintf(stderr, "Error opening filters!\n");
2180 case AVMEDIA_TYPE_SUBTITLE:
2181 ost->encoding_needed = 1;
2182 ist->decoding_needed = 1;
2189 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2190 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2191 char logfilename[1024];
2194 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2195 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2197 if (codec->flags & CODEC_FLAG_PASS1) {
2198 f = fopen(logfilename, "wb");
2200 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2206 size_t logbuffer_size;
2207 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2208 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2211 codec->stats_in = logbuffer;
2215 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2216 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2217 int size= codec->width * codec->height;
2218 bit_buffer_size= FFMAX(bit_buffer_size, 7*size + 10000);
2223 bit_buffer = av_malloc(bit_buffer_size);
2225 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2227 return AVERROR(ENOMEM);
2230 /* open each encoder */
2231 for (i = 0; i < nb_output_streams; i++) {
2232 ost = &output_streams[i];
2233 if (ost->encoding_needed) {
2234 AVCodec *codec = ost->enc;
2235 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2237 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2238 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2239 ret = AVERROR(EINVAL);
2242 if (dec->subtitle_header) {
2243 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2244 if (!ost->st->codec->subtitle_header) {
2245 ret = AVERROR(ENOMEM);
2248 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2249 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2251 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2252 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2253 ost->file_index, ost->index);
2254 ret = AVERROR(EINVAL);
2257 assert_codec_experimental(ost->st->codec, 1);
2258 assert_avoptions(ost->opts);
2259 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2260 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2261 "It takes bits/s as argument, not kbits/s\n");
2262 extra_size += ost->st->codec->extradata_size;
2264 if (ost->st->codec->me_threshold)
2265 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2269 /* init input streams */
2270 for (i = 0; i < nb_input_streams; i++)
2271 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2274 /* discard unused programs */
2275 for (i = 0; i < nb_input_files; i++) {
2276 InputFile *ifile = &input_files[i];
2277 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2278 AVProgram *p = ifile->ctx->programs[j];
2279 int discard = AVDISCARD_ALL;
2281 for (k = 0; k < p->nb_stream_indexes; k++)
2282 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2283 discard = AVDISCARD_DEFAULT;
2286 p->discard = discard;
2290 /* open files and write file headers */
2291 for (i = 0; i < nb_output_files; i++) {
2292 os = output_files[i].ctx;
2293 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2294 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2295 ret = AVERROR(EINVAL);
2298 // assert_avoptions(output_files[i].opts);
2299 if (strcmp(os->oformat->name, "rtp")) {
2305 /* dump the file output parameters - cannot be done before in case
2307 for(i=0;i<nb_output_files;i++) {
2308 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2311 /* dump the stream mapping */
2313 fprintf(stderr, "Stream mapping:\n");
2314 for (i = 0; i < nb_output_streams;i ++) {
2315 ost = &output_streams[i];
2316 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2317 input_streams[ost->source_index].file_index,
2318 input_streams[ost->source_index].st->index,
2321 if (ost->sync_ist != &input_streams[ost->source_index])
2322 fprintf(stderr, " [sync #%d.%d]",
2323 ost->sync_ist->file_index,
2324 ost->sync_ist->st->index);
2325 if (ost->st->stream_copy)
2326 fprintf(stderr, " (copy)");
2328 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2329 input_streams[ost->source_index].dec->name : "?",
2330 ost->enc ? ost->enc->name : "?");
2331 fprintf(stderr, "\n");
2336 fprintf(stderr, "%s\n", error);
2341 print_sdp(output_files, nb_output_files);
2348 * The following code is the main loop of the file converter
2350 static int transcode(OutputFile *output_files, int nb_output_files,
2351 InputFile *input_files, int nb_input_files)
2354 AVFormatContext *is, *os;
2358 int no_packet_count=0;
2359 int64_t timer_start;
2362 if (!(no_packet = av_mallocz(nb_input_files)))
2365 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2371 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2372 avio_set_interrupt_cb(decode_interrupt_cb);
2376 timer_start = av_gettime();
2378 for(; received_sigterm == 0;) {
2379 int file_index, ist_index;
2384 ipts_min= INT64_MAX;
2386 /* if 'q' pressed, exits */
2390 /* read_key() returns 0 on EOF */
2394 if (key == '+') verbose++;
2395 if (key == '-') verbose--;
2396 if (key == 's') qp_hist ^= 1;
2399 do_hex_dump = do_pkt_dump = 0;
2400 } else if(do_pkt_dump){
2404 av_log_set_level(AV_LOG_DEBUG);
2407 if (key == 'c' || key == 'C'){
2408 char buf[4096], target[64], command[256], arg[256] = {0};
2411 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2413 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2418 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2419 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2420 target, time, command, arg);
2421 for (i = 0; i < nb_output_streams; i++) {
2422 ost = &output_streams[i];
2425 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2426 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2427 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2429 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2434 av_log(NULL, AV_LOG_ERROR,
2435 "Parse error, at least 3 arguments were expected, "
2436 "only %d given in string '%s'\n", n, buf);
2440 if (key == 'd' || key == 'D'){
2443 debug = input_streams[0].st->codec->debug<<1;
2444 if(!debug) debug = 1;
2445 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2448 scanf("%d", &debug);
2449 for(i=0;i<nb_input_streams;i++) {
2450 input_streams[i].st->codec->debug = debug;
2452 for(i=0;i<nb_output_streams;i++) {
2453 ost = &output_streams[i];
2454 ost->st->codec->debug = debug;
2456 if(debug) av_log_set_level(AV_LOG_DEBUG);
2457 fprintf(stderr,"debug=%d\n", debug);
2460 fprintf(stderr, "key function\n"
2461 "? show this help\n"
2462 "+ increase verbosity\n"
2463 "- decrease verbosity\n"
2464 "c Send command to filtergraph\n"
2465 "D cycle through available debug modes\n"
2466 "h dump packets/hex press to cycle through the 3 states\n"
2468 "s Show QP histogram\n"
2473 /* select the stream that we must read now by looking at the
2474 smallest output pts */
2476 for (i = 0; i < nb_output_streams; i++) {
2480 ost = &output_streams[i];
2481 of = &output_files[ost->file_index];
2482 os = output_files[ost->file_index].ctx;
2483 ist = &input_streams[ost->source_index];
2484 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2485 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2487 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2489 if (!input_files[ist->file_index].eof_reached){
2490 if(ipts < ipts_min) {
2492 if(input_sync ) file_index = ist->file_index;
2494 if(opts < opts_min) {
2496 if(!input_sync) file_index = ist->file_index;
2499 if (ost->frame_number >= ost->max_frames) {
2501 for (j = 0; j < of->ctx->nb_streams; j++)
2502 output_streams[of->ost_index + j].is_past_recording_time = 1;
2506 /* if none, if is finished */
2507 if (file_index < 0) {
2508 if(no_packet_count){
2510 memset(no_packet, 0, nb_input_files);
2517 /* read a frame from it and output it in the fifo */
2518 is = input_files[file_index].ctx;
2519 ret= av_read_frame(is, &pkt);
2520 if(ret == AVERROR(EAGAIN)){
2521 no_packet[file_index]=1;
2526 input_files[file_index].eof_reached = 1;
2534 memset(no_packet, 0, nb_input_files);
2537 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2538 is->streams[pkt.stream_index]);
2540 /* the following test is needed in case new streams appear
2541 dynamically in stream : we ignore them */
2542 if (pkt.stream_index >= input_files[file_index].nb_streams)
2543 goto discard_packet;
2544 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2545 ist = &input_streams[ist_index];
2547 goto discard_packet;
2549 if (pkt.dts != AV_NOPTS_VALUE)
2550 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2551 if (pkt.pts != AV_NOPTS_VALUE)
2552 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2554 if(pkt.pts != AV_NOPTS_VALUE)
2555 pkt.pts *= ist->ts_scale;
2556 if(pkt.dts != AV_NOPTS_VALUE)
2557 pkt.dts *= ist->ts_scale;
2559 // 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);
2560 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2561 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2562 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2563 int64_t delta= pkt_dts - ist->next_pts;
2564 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2565 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2566 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2567 pkt_dts+1<ist->pts)&& !copy_ts){
2568 input_files[ist->file_index].ts_offset -= delta;
2570 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2571 delta, input_files[ist->file_index].ts_offset);
2572 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2573 if(pkt.pts != AV_NOPTS_VALUE)
2574 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2578 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2579 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2582 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2583 ist->file_index, ist->st->index);
2586 av_free_packet(&pkt);
2591 av_free_packet(&pkt);
2593 /* dump report by using the output first video and audio streams */
2594 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2597 /* at the end of stream, we must flush the decoder buffers */
2598 for (i = 0; i < nb_input_streams; i++) {
2599 ist = &input_streams[i];
2600 if (ist->decoding_needed) {
2601 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2604 flush_encoders(output_streams, nb_output_streams);
2608 /* write the trailer if needed and close file */
2609 for(i=0;i<nb_output_files;i++) {
2610 os = output_files[i].ctx;
2611 av_write_trailer(os);
2614 /* dump report by using the first video and audio streams */
2615 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2617 /* close each encoder */
2618 for (i = 0; i < nb_output_streams; i++) {
2619 ost = &output_streams[i];
2620 if (ost->encoding_needed) {
2621 av_freep(&ost->st->codec->stats_in);
2622 avcodec_close(ost->st->codec);
2625 avfilter_graph_free(&ost->graph);
2629 /* close each decoder */
2630 for (i = 0; i < nb_input_streams; i++) {
2631 ist = &input_streams[i];
2632 if (ist->decoding_needed) {
2633 avcodec_close(ist->st->codec);
2641 av_freep(&bit_buffer);
2642 av_freep(&no_packet);
2644 if (output_streams) {
2645 for (i = 0; i < nb_output_streams; i++) {
2646 ost = &output_streams[i];
2648 if (ost->st->stream_copy)
2649 av_freep(&ost->st->codec->extradata);
2651 fclose(ost->logfile);
2652 ost->logfile = NULL;
2654 av_fifo_free(ost->fifo); /* works even if fifo is not
2655 initialized but set to zero */
2656 av_freep(&ost->st->codec->subtitle_header);
2657 av_free(ost->resample_frame.data[0]);
2658 av_free(ost->forced_kf_pts);
2659 if (ost->video_resample)
2660 sws_freeContext(ost->img_resample_ctx);
2661 swr_free(&ost->swr);
2662 av_dict_free(&ost->opts);
2669 static int opt_verbose(const char *opt, const char *arg)
2671 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2675 static int opt_frame_crop(const char *opt, const char *arg)
2677 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2678 return AVERROR(EINVAL);
2681 static int opt_pad(const char *opt, const char *arg)
2683 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2687 static double parse_frame_aspect_ratio(const char *arg)
2694 p = strchr(arg, ':');
2696 x = strtol(arg, &end, 10);
2698 y = strtol(end+1, &end, 10);
2700 ar = (double)x / (double)y;
2702 ar = strtod(arg, NULL);
2705 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2711 static int opt_video_channel(const char *opt, const char *arg)
2713 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2714 return opt_default("channel", arg);
2717 static int opt_video_standard(const char *opt, const char *arg)
2719 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2720 return opt_default("standard", arg);
2723 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2725 audio_codec_name = arg;
2726 return parse_option(o, "codec:a", arg, options);
2729 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2731 video_codec_name = arg;
2732 return parse_option(o, "codec:v", arg, options);
2735 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2737 subtitle_codec_name = arg;
2738 return parse_option(o, "codec:s", arg, options);
2741 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2743 return parse_option(o, "codec:d", arg, options);
2746 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2748 StreamMap *m = NULL;
2749 int i, negative = 0, file_idx;
2750 int sync_file_idx = -1, sync_stream_idx;
2758 map = av_strdup(arg);
2760 /* parse sync stream first, just pick first matching stream */
2761 if (sync = strchr(map, ',')) {
2763 sync_file_idx = strtol(sync + 1, &sync, 0);
2764 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2765 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2770 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2771 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2772 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2773 sync_stream_idx = i;
2776 if (i == input_files[sync_file_idx].nb_streams) {
2777 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2778 "match any streams.\n", arg);
2784 file_idx = strtol(map, &p, 0);
2785 if (file_idx >= nb_input_files || file_idx < 0) {
2786 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2790 /* disable some already defined maps */
2791 for (i = 0; i < o->nb_stream_maps; i++) {
2792 m = &o->stream_maps[i];
2793 if (check_stream_specifier(input_files[m->file_index].ctx,
2794 input_files[m->file_index].ctx->streams[m->stream_index],
2795 *p == ':' ? p + 1 : p) > 0)
2799 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2800 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2801 *p == ':' ? p + 1 : p) <= 0)
2803 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2804 &o->nb_stream_maps, o->nb_stream_maps + 1);
2805 m = &o->stream_maps[o->nb_stream_maps - 1];
2807 m->file_index = file_idx;
2808 m->stream_index = i;
2810 if (sync_file_idx >= 0) {
2811 m->sync_file_index = sync_file_idx;
2812 m->sync_stream_index = sync_stream_idx;
2814 m->sync_file_index = file_idx;
2815 m->sync_stream_index = i;
2820 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2828 static void parse_meta_type(char *arg, char *type, int *index)
2838 if (*(++arg) == ':')
2839 *index = strtol(++arg, NULL, 0);
2842 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2849 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2851 MetadataMap *m, *m1;
2854 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2855 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2857 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2858 m->file = strtol(arg, &p, 0);
2859 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2861 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2862 if (p = strchr(opt, ':'))
2863 parse_meta_type(p + 1, &m1->type, &m1->index);
2867 if (m->type == 'g' || m1->type == 'g')
2868 o->metadata_global_manual = 1;
2869 if (m->type == 's' || m1->type == 's')
2870 o->metadata_streams_manual = 1;
2871 if (m->type == 'c' || m1->type == 'c')
2872 o->metadata_chapters_manual = 1;
2877 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2879 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2880 "Use -map_metadata instead.\n");
2881 return opt_map_metadata(o, opt, arg);
2884 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
2887 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2888 struct tm time = *gmtime((time_t*)&recording_timestamp);
2889 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2890 parse_option(o, "metadata", buf, options);
2892 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2893 "tag instead.\n", opt);
2897 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2899 const char *codec_string = encoder ? "encoder" : "decoder";
2903 return CODEC_ID_NONE;
2905 avcodec_find_encoder_by_name(name) :
2906 avcodec_find_decoder_by_name(name);
2908 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2911 if(codec->type != type) {
2912 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2918 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2920 char *codec_name = NULL;
2922 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2926 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2927 return avcodec_find_encoder(st->codec->codec_id);
2929 } else if (!strcmp(codec_name, "copy"))
2930 st->stream_copy = 1;
2932 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2933 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2934 avcodec_find_decoder_by_name(codec_name);
2941 * Add all the streams from the given input file to the global
2942 * list of input streams.
2944 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2946 int i, rfps, rfps_base;
2948 for (i = 0; i < ic->nb_streams; i++) {
2949 AVStream *st = ic->streams[i];
2950 AVCodecContext *dec = st->codec;
2954 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2955 ist = &input_streams[nb_input_streams - 1];
2957 ist->file_index = nb_input_files;
2959 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2961 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2962 ist->ts_scale = scale;
2964 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2966 ist->dec = avcodec_find_decoder(dec->codec_id);
2968 switch (dec->codec_type) {
2969 case AVMEDIA_TYPE_AUDIO:
2971 ist->dec = avcodec_find_decoder(dec->codec_id);
2972 if(o->audio_disable)
2973 st->discard= AVDISCARD_ALL;
2975 case AVMEDIA_TYPE_VIDEO:
2977 ist->dec = avcodec_find_decoder(dec->codec_id);
2978 rfps = ic->streams[i]->r_frame_rate.num;
2979 rfps_base = ic->streams[i]->r_frame_rate.den;
2981 dec->flags |= CODEC_FLAG_EMU_EDGE;
2984 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2987 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2988 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2990 (float)rfps / rfps_base, rfps, rfps_base);
2993 if (o->video_disable)
2994 st->discard= AVDISCARD_ALL;
2995 else if(video_discard)
2996 st->discard= video_discard;
2998 case AVMEDIA_TYPE_DATA:
3000 case AVMEDIA_TYPE_SUBTITLE:
3002 ist->dec = avcodec_find_decoder(dec->codec_id);
3003 if(o->subtitle_disable)
3004 st->discard = AVDISCARD_ALL;
3006 case AVMEDIA_TYPE_ATTACHMENT:
3007 case AVMEDIA_TYPE_UNKNOWN:
3015 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3017 AVFormatContext *ic;
3018 AVInputFormat *file_iformat = NULL;
3022 AVDictionary **opts;
3023 int orig_nb_streams; // number of streams before avformat_find_stream_info
3026 if (!(file_iformat = av_find_input_format(o->format))) {
3027 fprintf(stderr, "Unknown input format: '%s'\n", o->format);
3032 if (!strcmp(filename, "-"))
3035 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3036 !strcmp(filename, "/dev/stdin");
3038 /* get default parameters from command line */
3039 ic = avformat_alloc_context();
3041 print_error(filename, AVERROR(ENOMEM));
3044 if (o->nb_audio_sample_rate) {
3045 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3046 av_dict_set(&format_opts, "sample_rate", buf, 0);
3048 if (o->nb_audio_channels) {
3049 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3050 av_dict_set(&format_opts, "channels", buf, 0);
3052 if (o->nb_frame_rates) {
3053 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3055 if (o->nb_frame_sizes) {
3056 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3058 if (o->nb_frame_pix_fmts)
3059 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3061 ic->flags |= AVFMT_FLAG_NONBLOCK;
3064 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3065 ic->loop_input = loop_input;
3068 /* open the input file with generic libav function */
3069 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3071 print_error(filename, err);
3074 assert_avoptions(format_opts);
3076 /* apply forced codec ids */
3077 for (i = 0; i < ic->nb_streams; i++)
3078 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3080 /* Set AVCodecContext options for avformat_find_stream_info */
3081 opts = setup_find_stream_info_opts(ic, codec_opts);
3082 orig_nb_streams = ic->nb_streams;
3084 /* If not enough info to get the stream parameters, we decode the
3085 first frames to get it. (used in mpeg case for example) */
3086 ret = avformat_find_stream_info(ic, opts);
3087 if (ret < 0 && verbose >= 0) {
3088 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3089 av_close_input_file(ic);
3093 timestamp = o->start_time;
3094 /* add the stream start time */
3095 if (ic->start_time != AV_NOPTS_VALUE)
3096 timestamp += ic->start_time;
3098 /* if seeking requested, we execute it */
3099 if (o->start_time != 0) {
3100 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3102 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3103 filename, (double)timestamp / AV_TIME_BASE);
3107 /* update the current parameters so that they match the one of the input stream */
3108 add_input_streams(o, ic);
3110 /* dump the file content */
3112 av_dump_format(ic, nb_input_files, filename, 0);
3114 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3115 input_files[nb_input_files - 1].ctx = ic;
3116 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3117 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3118 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3119 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3121 for (i = 0; i < orig_nb_streams; i++)
3122 av_dict_free(&opts[i]);
3125 reset_options(o, 1);
3129 static void parse_forced_key_frames(char *kf, OutputStream *ost, AVCodecContext *avctx)
3135 for (p = kf; *p; p++)
3138 ost->forced_kf_count = n;
3139 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3140 if (!ost->forced_kf_pts) {
3141 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3144 for (i = 0; i < n; i++) {
3145 p = i ? strchr(p, ',') + 1 : kf;
3146 t = parse_time_or_die("force_key_frames", p, 1);
3147 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3151 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3154 AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
3155 int idx = oc->nb_streams - 1;
3156 int64_t max_frames = INT64_MAX;
3157 char *bsf = NULL, *next, *codec_tag = NULL;
3158 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3162 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3166 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3167 nb_output_streams + 1);
3168 ost = &output_streams[nb_output_streams - 1];
3169 ost->file_index = nb_output_files;
3172 st->codec->codec_type = type;
3173 ost->enc = choose_codec(o, oc, st, type);
3175 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3178 avcodec_get_context_defaults3(st->codec, ost->enc);
3179 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3181 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3182 ost->max_frames = max_frames;
3184 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3186 if (next = strchr(bsf, ','))
3188 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3189 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter %s\n", bsf);
3193 bsfc_prev->next = bsfc;
3195 ost->bitstream_filters = bsfc;
3201 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3203 uint32_t tag = strtol(codec_tag, &next, 0);
3205 tag = AV_RL32(codec_tag);
3206 st->codec->codec_tag = tag;
3209 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3210 if (qscale >= 0 || same_quant) {
3211 st->codec->flags |= CODEC_FLAG_QSCALE;
3212 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3215 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3219 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3222 const char *p = str;
3229 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3236 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3240 AVCodecContext *video_enc;
3242 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3244 video_enc = st->codec;
3246 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3247 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3250 if (!st->stream_copy) {
3251 const char *p = NULL;
3252 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3253 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3254 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3255 int i, force_fps = 0, top_field_first = -1;
3257 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3258 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3259 av_log(NULL, AV_LOG_ERROR, "Invalid framerate value: %s\n", frame_rate);
3263 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3264 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3265 av_log(NULL, AV_LOG_ERROR, "Invalid frame size: %s.\n", frame_size);
3269 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3270 if (frame_aspect_ratio)
3271 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3273 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3274 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3275 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3276 av_log(NULL, AV_LOG_ERROR, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3279 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3282 video_enc->gop_size = 0;
3283 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3285 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3286 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for intra matrix.\n");
3289 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3291 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3293 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3294 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for inter matrix.\n");
3297 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3300 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3303 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3305 fprintf(stderr, "error parsing rc_override\n");
3308 video_enc->rc_override=
3309 av_realloc(video_enc->rc_override,
3310 sizeof(RcOverride)*(i+1));
3311 video_enc->rc_override[i].start_frame= start;
3312 video_enc->rc_override[i].end_frame = end;
3314 video_enc->rc_override[i].qscale= q;
3315 video_enc->rc_override[i].quality_factor= 1.0;
3318 video_enc->rc_override[i].qscale= 0;
3319 video_enc->rc_override[i].quality_factor= -q/100.0;
3324 video_enc->rc_override_count=i;
3325 if (!video_enc->rc_initial_buffer_occupancy)
3326 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3327 video_enc->intra_dc_precision= intra_dc_precision - 8;
3332 video_enc->flags |= CODEC_FLAG_PASS1;
3334 video_enc->flags |= CODEC_FLAG_PASS2;
3338 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3339 if (forced_key_frames)
3340 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3342 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3343 ost->force_fps = force_fps;
3345 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3346 ost->top_field_first = top_field_first;
3349 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3351 ost->avfilter = av_strdup(filters);
3358 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3362 AVCodecContext *audio_enc;
3364 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3367 audio_enc = st->codec;
3368 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3370 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3371 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3373 if (!st->stream_copy) {
3374 char *sample_fmt = NULL;
3376 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3378 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3380 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3381 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", sample_fmt);
3385 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3391 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3395 AVCodecContext *data_enc;
3397 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3399 data_enc = st->codec;
3400 if (!st->stream_copy) {
3401 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3405 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3406 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3412 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3416 AVCodecContext *subtitle_enc;
3418 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3420 subtitle_enc = st->codec;
3422 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3424 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3425 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3431 /* arg format is "output-stream-index:streamid-value". */
3432 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3438 av_strlcpy(idx_str, arg, sizeof(idx_str));
3439 p = strchr(idx_str, ':');
3442 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3447 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3448 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3449 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3453 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3455 AVFormatContext *is = ifile->ctx;
3456 AVFormatContext *os = ofile->ctx;
3459 for (i = 0; i < is->nb_chapters; i++) {
3460 AVChapter *in_ch = is->chapters[i], *out_ch;
3461 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3462 AV_TIME_BASE_Q, in_ch->time_base);
3463 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3464 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3467 if (in_ch->end < ts_off)
3469 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3472 out_ch = av_mallocz(sizeof(AVChapter));
3474 return AVERROR(ENOMEM);
3476 out_ch->id = in_ch->id;
3477 out_ch->time_base = in_ch->time_base;
3478 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3479 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3482 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3485 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3487 return AVERROR(ENOMEM);
3488 os->chapters[os->nb_chapters - 1] = out_ch;
3493 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3496 AVFormatContext *ic = NULL;
3498 err = avformat_open_input(&ic, filename, NULL, NULL);
3501 /* copy stream format */
3502 for(i=0;i<ic->nb_streams;i++) {
3507 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3508 ost = new_output_stream(o, s, codec->type);
3511 // FIXME: a more elegant solution is needed
3512 memcpy(st, ic->streams[i], sizeof(AVStream));
3513 st->info = av_malloc(sizeof(*st->info));
3514 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3515 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3517 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3518 choose_sample_fmt(st, codec);
3519 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3520 choose_pixel_fmt(st, codec);
3523 av_close_input_file(ic);
3527 static void opt_output_file(void *optctx, const char *filename)
3529 OptionsContext *o = optctx;
3530 AVFormatContext *oc;
3532 AVOutputFormat *file_oformat;
3536 if (!strcmp(filename, "-"))
3539 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3541 print_error(filename, err);
3544 file_oformat= oc->oformat;
3546 if (!strcmp(file_oformat->name, "ffm") &&
3547 av_strstart(filename, "http:", NULL)) {
3548 /* special case for files sent to ffserver: we get the stream
3549 parameters from ffserver */
3550 int err = read_ffserver_streams(o, oc, filename);
3552 print_error(filename, err);
3555 } else if (!o->nb_stream_maps) {
3556 /* pick the "best" stream of each type */
3557 #define NEW_STREAM(type, index)\
3559 ost = new_ ## type ## _stream(o, oc);\
3560 ost->source_index = index;\
3561 ost->sync_ist = &input_streams[index];\
3562 input_streams[index].discard = 0;\
3565 /* video: highest resolution */
3566 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3567 int area = 0, idx = -1;
3568 for (i = 0; i < nb_input_streams; i++) {
3569 ist = &input_streams[i];
3570 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3571 ist->st->codec->width * ist->st->codec->height > area) {
3572 area = ist->st->codec->width * ist->st->codec->height;
3576 NEW_STREAM(video, idx);
3579 /* audio: most channels */
3580 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3581 int channels = 0, idx = -1;
3582 for (i = 0; i < nb_input_streams; i++) {
3583 ist = &input_streams[i];
3584 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3585 ist->st->codec->channels > channels) {
3586 channels = ist->st->codec->channels;
3590 NEW_STREAM(audio, idx);
3593 /* subtitles: pick first */
3594 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3595 for (i = 0; i < nb_input_streams; i++)
3596 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3597 NEW_STREAM(subtitle, i);
3601 /* do something with data? */
3603 for (i = 0; i < o->nb_stream_maps; i++) {
3604 StreamMap *map = &o->stream_maps[i];
3609 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3610 switch (ist->st->codec->codec_type) {
3611 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3612 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3613 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3614 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3616 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3617 map->file_index, map->stream_index);
3621 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3622 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3623 map->sync_stream_index];
3628 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3629 output_files[nb_output_files - 1].ctx = oc;
3630 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3631 output_files[nb_output_files - 1].recording_time = o->recording_time;
3632 output_files[nb_output_files - 1].start_time = o->start_time;
3633 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3634 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3636 /* check filename in case of an image number is expected */
3637 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3638 if (!av_filename_number_test(oc->filename)) {
3639 print_error(oc->filename, AVERROR(EINVAL));
3644 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3645 /* test if it already exists to avoid loosing precious files */
3646 if (!file_overwrite &&
3647 (strchr(filename, ':') == NULL ||
3648 filename[1] == ':' ||
3649 av_strstart(filename, "file:", NULL))) {
3650 if (avio_check(filename, 0) == 0) {
3652 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3654 if (!read_yesno()) {
3655 fprintf(stderr, "Not overwriting - exiting\n");
3660 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3667 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3668 print_error(filename, err);
3673 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3674 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3676 if (loop_output >= 0) {
3677 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3678 oc->loop_output = loop_output;
3682 if (o->chapters_input_file >= nb_input_files) {
3683 if (o->chapters_input_file == INT_MAX) {
3684 /* copy chapters from the first input file that has them*/
3685 o->chapters_input_file = -1;
3686 for (i = 0; i < nb_input_files; i++)
3687 if (input_files[i].ctx->nb_chapters) {
3688 o->chapters_input_file = i;
3692 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3693 o->chapters_input_file);
3697 if (o->chapters_input_file >= 0)
3698 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3699 !o->metadata_chapters_manual);
3702 for (i = 0; i < o->nb_meta_data_maps; i++) {
3703 AVFormatContext *files[2];
3704 AVDictionary **meta[2];
3707 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3708 if ((index) < 0 || (index) >= (nb_elems)) {\
3709 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3714 int in_file_index = o->meta_data_maps[i][1].file;
3715 if (in_file_index < 0)
3717 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3720 files[1] = input_files[in_file_index].ctx;
3722 for (j = 0; j < 2; j++) {
3723 MetadataMap *map = &o->meta_data_maps[i][j];
3725 switch (map->type) {
3727 meta[j] = &files[j]->metadata;
3730 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3731 meta[j] = &files[j]->streams[map->index]->metadata;
3734 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3735 meta[j] = &files[j]->chapters[map->index]->metadata;
3738 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3739 meta[j] = &files[j]->programs[map->index]->metadata;
3744 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3747 /* copy global metadata by default */
3748 if (!o->metadata_global_manual && nb_input_files){
3749 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3750 AV_DICT_DONT_OVERWRITE);
3751 if(o->recording_time != INT64_MAX)
3752 av_dict_set(&oc->metadata, "duration", NULL, 0);
3754 if (!o->metadata_streams_manual)
3755 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3756 InputStream *ist = &input_streams[output_streams[i].source_index];
3757 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3760 /* process manually set metadata */
3761 for (i = 0; i < o->nb_metadata; i++) {
3766 val = strchr(o->metadata[i].u.str, '=');
3768 av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3769 o->metadata[i].u.str);
3774 parse_meta_type(o->metadata[i].specifier, &type, &index);
3780 if (index < 0 || index >= oc->nb_streams) {
3781 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3784 m = &oc->streams[index]->metadata;
3787 if (index < 0 || index >= oc->nb_chapters) {
3788 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3791 m = &oc->chapters[index]->metadata;
3794 av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3798 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3801 reset_options(o, 0);
3804 /* same option as mencoder */
3805 static int opt_pass(const char *opt, const char *arg)
3807 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3811 static int64_t getutime(void)
3814 struct rusage rusage;
3816 getrusage(RUSAGE_SELF, &rusage);
3817 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3818 #elif HAVE_GETPROCESSTIMES
3820 FILETIME c, e, k, u;
3821 proc = GetCurrentProcess();
3822 GetProcessTimes(proc, &c, &e, &k, &u);
3823 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3825 return av_gettime();
3829 static int64_t getmaxrss(void)
3831 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3832 struct rusage rusage;
3833 getrusage(RUSAGE_SELF, &rusage);
3834 return (int64_t)rusage.ru_maxrss * 1024;
3835 #elif HAVE_GETPROCESSMEMORYINFO
3837 PROCESS_MEMORY_COUNTERS memcounters;
3838 proc = GetCurrentProcess();
3839 memcounters.cb = sizeof(memcounters);
3840 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3841 return memcounters.PeakPagefileUsage;
3847 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3849 return parse_option(o, "q:a", arg, options);
3852 static void show_usage(void)
3854 printf("Hyper fast Audio and Video encoder\n");
3855 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3859 static int opt_help(const char *opt, const char *arg)
3862 AVOutputFormat *oformat = NULL;
3863 AVInputFormat *iformat = NULL;
3864 const AVClass *class;
3866 av_log_set_callback(log_callback_help);
3868 show_help_options(options, "Main options:\n",
3869 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3870 show_help_options(options, "\nAdvanced options:\n",
3871 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3873 show_help_options(options, "\nVideo options:\n",
3874 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3876 show_help_options(options, "\nAdvanced Video options:\n",
3877 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3878 OPT_VIDEO | OPT_EXPERT);
3879 show_help_options(options, "\nAudio options:\n",
3880 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3882 show_help_options(options, "\nAdvanced Audio options:\n",
3883 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3884 OPT_AUDIO | OPT_EXPERT);
3885 show_help_options(options, "\nSubtitle options:\n",
3886 OPT_SUBTITLE | OPT_GRAB,
3888 show_help_options(options, "\nAudio/Video grab options:\n",
3892 class = avcodec_get_class();
3893 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3896 /* individual codec options */
3898 while ((c = av_codec_next(c))) {
3899 if (c->priv_class) {
3900 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3905 class = avformat_get_class();
3906 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3909 /* individual muxer options */
3910 while ((oformat = av_oformat_next(oformat))) {
3911 if (oformat->priv_class) {
3912 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3917 /* individual demuxer options */
3918 while ((iformat = av_iformat_next(iformat))) {
3919 if (iformat->priv_class) {
3920 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3925 class = sws_get_class();
3926 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3930 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3932 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3933 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3935 if(!strncmp(arg, "pal-", 4)) {
3938 } else if(!strncmp(arg, "ntsc-", 5)) {
3941 } else if(!strncmp(arg, "film-", 5)) {
3945 /* Try to determine PAL/NTSC by peeking in the input files */
3946 if(nb_input_files) {
3948 for (j = 0; j < nb_input_files; j++) {
3949 for (i = 0; i < input_files[j].nb_streams; i++) {
3950 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3951 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3953 fr = c->time_base.den * 1000 / c->time_base.num;
3957 } else if((fr == 29970) || (fr == 23976)) {
3966 if(verbose > 0 && norm != UNKNOWN)
3967 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3970 if(norm == UNKNOWN) {
3971 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3972 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3973 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
3977 if(!strcmp(arg, "vcd")) {
3978 opt_video_codec(o, "c:v", "mpeg1video");
3979 opt_audio_codec(o, "c:a", "mp2");
3980 parse_option(o, "f", "vcd", options);
3982 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3983 parse_option(o, "r", frame_rates[norm], options);
3984 opt_default("g", norm == PAL ? "15" : "18");
3986 opt_default("b", "1150000");
3987 opt_default("maxrate", "1150000");
3988 opt_default("minrate", "1150000");
3989 opt_default("bufsize", "327680"); // 40*1024*8;
3991 opt_default("b:a", "224000");
3992 parse_option(o, "ar", "44100", options);
3993 parse_option(o, "ac", "2", options);
3995 opt_default("packetsize", "2324");
3996 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3998 /* We have to offset the PTS, so that it is consistent with the SCR.
3999 SCR starts at 36000, but the first two packs contain only padding
4000 and the first pack from the other stream, respectively, may also have
4001 been written before.
4002 So the real data starts at SCR 36000+3*1200. */
4003 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4004 } else if(!strcmp(arg, "svcd")) {
4006 opt_video_codec(o, "c:v", "mpeg2video");
4007 opt_audio_codec(o, "c:a", "mp2");
4008 parse_option(o, "f", "svcd", options);
4010 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4011 parse_option(o, "r", frame_rates[norm], options);
4012 parse_option(o, "pix_fmt", "yuv420p", options);
4013 opt_default("g", norm == PAL ? "15" : "18");
4015 opt_default("b", "2040000");
4016 opt_default("maxrate", "2516000");
4017 opt_default("minrate", "0"); //1145000;
4018 opt_default("bufsize", "1835008"); //224*1024*8;
4019 opt_default("flags", "+scan_offset");
4022 opt_default("b:a", "224000");
4023 parse_option(o, "ar", "44100", options);
4025 opt_default("packetsize", "2324");
4027 } else if(!strcmp(arg, "dvd")) {
4029 opt_video_codec(o, "c:v", "mpeg2video");
4030 opt_audio_codec(o, "c:a", "ac3");
4031 parse_option(o, "f", "dvd", options);
4033 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4034 parse_option(o, "r", frame_rates[norm], options);
4035 parse_option(o, "pix_fmt", "yuv420p", options);
4036 opt_default("g", norm == PAL ? "15" : "18");
4038 opt_default("b", "6000000");
4039 opt_default("maxrate", "9000000");
4040 opt_default("minrate", "0"); //1500000;
4041 opt_default("bufsize", "1835008"); //224*1024*8;
4043 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4044 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4046 opt_default("b:a", "448000");
4047 parse_option(o, "ar", "48000", options);
4049 } else if(!strncmp(arg, "dv", 2)) {
4051 parse_option(o, "f", "dv", options);
4053 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4054 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4055 norm == PAL ? "yuv420p" : "yuv411p", options);
4056 parse_option(o, "r", frame_rates[norm], options);
4058 parse_option(o, "ar", "48000", options);
4059 parse_option(o, "ac", "2", options);
4062 fprintf(stderr, "Unknown target: %s\n", arg);
4063 return AVERROR(EINVAL);
4068 static int opt_vstats_file(const char *opt, const char *arg)
4070 av_free (vstats_filename);
4071 vstats_filename=av_strdup (arg);
4075 static int opt_vstats(const char *opt, const char *arg)
4078 time_t today2 = time(NULL);
4079 struct tm *today = localtime(&today2);
4081 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4083 return opt_vstats_file(opt, filename);
4086 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4088 return parse_option(o, "frames:v", arg, options);
4091 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4093 return parse_option(o, "frames:a", arg, options);
4096 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4098 return parse_option(o, "frames:d", arg, options);
4101 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4104 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4105 const char *codec_name = *opt == 'v' ? video_codec_name :
4106 *opt == 'a' ? audio_codec_name :
4107 subtitle_codec_name;
4109 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4110 fprintf(stderr, "File for preset '%s' not found\n", arg);
4115 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4116 if(line[0] == '#' && !e)
4118 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4120 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4123 if(!strcmp(tmp, "acodec")){
4124 opt_audio_codec(o, tmp, tmp2);
4125 }else if(!strcmp(tmp, "vcodec")){
4126 opt_video_codec(o, tmp, tmp2);
4127 }else if(!strcmp(tmp, "scodec")){
4128 opt_subtitle_codec(o, tmp, tmp2);
4129 }else if(!strcmp(tmp, "dcodec")){
4130 opt_data_codec(o, tmp, tmp2);
4131 }else if(opt_default(tmp, tmp2) < 0){
4132 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4142 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4146 static int opt_passlogfile(const char *opt, const char *arg)
4148 pass_logfilename_prefix = arg;
4149 #if CONFIG_LIBX264_ENCODER
4150 return opt_default("passlogfile", arg);
4156 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4158 char *s= av_malloc(strlen(opt)+2);
4159 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4160 return parse_option(o, s, arg, options);
4163 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4165 return parse_option(o, "filter:v", arg, options);
4168 #define OFFSET(x) offsetof(OptionsContext, x)
4169 static const OptionDef options[] = {
4171 #include "cmdutils_common_opts.h"
4172 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4173 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4174 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4175 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4176 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4177 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4178 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4179 "outfile[,metadata]:infile[,metadata]" },
4180 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4181 "outfile[,metadata]:infile[,metadata]" },
4182 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4183 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4184 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4185 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4186 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4187 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4188 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4189 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4190 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4191 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4192 "add timings for benchmarking" },
4193 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4194 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4195 "dump each input packet" },
4196 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4197 "when dumping packets, also dump the payload" },
4198 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4199 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4200 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4201 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4202 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4203 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4204 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4205 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4206 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4207 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4208 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4209 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4210 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4211 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4212 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4213 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4214 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4215 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4217 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4221 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4222 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4223 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4224 { "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" },
4225 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4226 { "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" },
4227 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4228 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4229 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4230 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4231 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4232 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4233 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4234 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4235 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4236 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4237 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4238 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4239 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4240 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4241 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4242 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4243 "use same quantizer as source (implies VBR)" },
4244 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4245 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4246 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4247 "deinterlace pictures" },
4248 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4249 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4251 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4253 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4254 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4255 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4256 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4257 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4258 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4259 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4260 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4261 { "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" },
4264 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4265 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4266 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4267 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4268 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4269 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4270 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4271 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4272 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4274 /* subtitle options */
4275 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4276 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4277 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4280 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4281 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4282 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4285 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4286 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4288 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4289 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4290 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4292 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4293 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4294 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4295 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4296 /* data codec support */
4297 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4299 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4303 int main(int argc, char **argv)
4305 OptionsContext o = { 0 };
4308 reset_options(&o, 0);
4310 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4312 if(argc>1 && !strcmp(argv[1], "-d")){
4315 av_log_set_callback(log_callback_null);
4320 avcodec_register_all();
4322 avdevice_register_all();
4325 avfilter_register_all();
4330 if(isatty(STDIN_FILENO))
4331 avio_set_interrupt_cb(decode_interrupt_cb);
4338 parse_options(&o, argc, argv, options, opt_output_file);
4340 if(nb_output_files <= 0 && nb_input_files == 0) {
4342 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4346 /* file converter / grab */
4347 if (nb_output_files <= 0) {
4348 fprintf(stderr, "At least one output file must be specified\n");
4352 if (nb_input_files == 0) {
4353 fprintf(stderr, "At least one input file must be specified\n");
4358 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4360 ti = getutime() - ti;
4362 int maxrss = getmaxrss() / 1024;
4363 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);