3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
49 #include "libavformat/ffm.h" // not public API
52 # include "libavfilter/avcodec.h"
53 # include "libavfilter/avfilter.h"
54 # include "libavfilter/avfiltergraph.h"
55 # include "libavfilter/buffersink.h"
56 # include "libavfilter/vsrc_buffer.h"
59 #if HAVE_SYS_RESOURCE_H
60 #include <sys/types.h>
62 #include <sys/resource.h>
63 #elif HAVE_GETPROCESSTIMES
66 #if HAVE_GETPROCESSMEMORYINFO
72 #include <sys/select.h>
77 #include <sys/ioctl.h>
87 #include "libavutil/avassert.h"
89 const char program_name[] = "ffmpeg";
90 const int program_birth_year = 2000;
92 /* select an input stream for an output stream */
93 typedef struct StreamMap {
94 int disabled; /** 1 is this mapping is disabled by a negative map */
98 int sync_stream_index;
102 * select an input file for an output file
104 typedef struct MetadataMap {
105 int file; ///< file index
106 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
107 int index; ///< stream/chapter/program number
110 static const OptionDef options[];
112 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
114 static int frame_bits_per_raw_sample = 0;
115 static int video_discard = 0;
116 static int same_quant = 0;
117 static int do_deinterlace = 0;
118 static int intra_dc_precision = 8;
119 static int loop_input = 0;
120 static int loop_output = AVFMT_NOOUTPUTLOOP;
121 static int qp_hist = 0;
122 static int intra_only = 0;
123 static const char *video_codec_name = NULL;
124 static const char *audio_codec_name = NULL;
125 static const char *subtitle_codec_name = NULL;
127 static int file_overwrite = 0;
128 static int do_benchmark = 0;
129 static int do_hex_dump = 0;
130 static int do_pkt_dump = 0;
131 static int do_pass = 0;
132 static const char *pass_logfilename_prefix;
133 static int video_sync_method= -1;
134 static int audio_sync_method= 0;
135 static float audio_drift_threshold= 0.1;
136 static int copy_ts= 0;
137 static int copy_tb= 0;
138 static int opt_shortest = 0;
139 static char *vstats_filename;
140 static FILE *vstats_file;
141 static int copy_initial_nonkeyframes = 0;
143 static int audio_volume = 256;
145 static int exit_on_error = 0;
146 static int using_stdin = 0;
147 static int verbose = 1;
148 static int run_as_daemon = 0;
149 static int q_pressed = 0;
150 static int64_t video_size = 0;
151 static int64_t audio_size = 0;
152 static int64_t extra_size = 0;
153 static int nb_frames_dup = 0;
154 static int nb_frames_drop = 0;
155 static int input_sync;
157 static float dts_delta_threshold = 10;
159 static uint8_t *audio_buf;
160 static uint8_t *audio_out;
161 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
163 static short *samples;
164 static uint8_t *input_tmp= NULL;
166 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
168 typedef struct InputStream {
171 int discard; /* true if stream data should be discarded */
172 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
175 int64_t start; /* time when read started */
176 int64_t next_pts; /* synthetic pts for cases where pkt.pts
178 int64_t pts; /* current pts */
180 int is_start; /* is 1 at the start and after a discontinuity */
181 int showed_multi_packet_warning;
185 typedef struct InputFile {
186 AVFormatContext *ctx;
187 int eof_reached; /* true if eof reached */
188 int ist_index; /* index of first stream in ist_table */
189 int buffer_size; /* current total buffer size */
191 int nb_streams; /* number of stream that avconv is aware of; may be different
192 from ctx.nb_streams if new streams appear during av_read_frame() */
196 typedef struct OutputStream {
197 int file_index; /* file index */
198 int index; /* stream index in the output file */
199 int source_index; /* InputStream index */
200 AVStream *st; /* stream in the output file */
201 int encoding_needed; /* true if encoding needed for this stream */
203 /* input pts and corresponding output pts
205 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
206 struct InputStream *sync_ist; /* input stream to sync against */
207 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
208 AVBitStreamFilterContext *bitstream_filters;
214 AVFrame resample_frame; /* temporary frame for image resampling */
215 struct SwsContext *img_resample_ctx; /* for image resampling */
218 int resample_pix_fmt;
219 AVRational frame_rate;
223 float frame_aspect_ratio;
225 /* forced key frames */
226 int64_t *forced_kf_pts;
232 ReSampleContext *resample; /* for audio resampling */
233 int resample_sample_fmt;
234 int resample_channels;
235 int resample_sample_rate;
237 AVAudioConvert *reformat_ctx;
238 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
242 AVFilterContext *output_video_filter;
243 AVFilterContext *input_video_filter;
244 AVFilterBufferRef *picref;
246 AVFilterGraph *graph;
251 int is_past_recording_time;
257 /* init terminal so that we can grab keys */
258 static struct termios oldtty;
261 typedef struct OutputFile {
262 AVFormatContext *ctx;
264 int ost_index; /* index of the first stream in output_streams */
265 int64_t recording_time; /* desired length of the resulting file in microseconds */
266 int64_t start_time; /* start time in microseconds */
267 uint64_t limit_filesize;
270 static InputStream *input_streams = NULL;
271 static int nb_input_streams = 0;
272 static InputFile *input_files = NULL;
273 static int nb_input_files = 0;
275 static OutputStream *output_streams = NULL;
276 static int nb_output_streams = 0;
277 static OutputFile *output_files = NULL;
278 static int nb_output_files = 0;
280 typedef struct OptionsContext {
281 /* input/output options */
285 SpecifierOpt *codec_names;
287 SpecifierOpt *audio_channels;
288 int nb_audio_channels;
289 SpecifierOpt *audio_sample_rate;
290 int nb_audio_sample_rate;
291 SpecifierOpt *frame_rates;
293 SpecifierOpt *frame_sizes;
295 SpecifierOpt *frame_pix_fmts;
296 int nb_frame_pix_fmts;
299 int64_t input_ts_offset;
302 SpecifierOpt *ts_scale;
306 StreamMap *stream_maps;
308 /* first item specifies output metadata, second is input */
309 MetadataMap (*meta_data_maps)[2];
310 int nb_meta_data_maps;
311 int metadata_global_manual;
312 int metadata_streams_manual;
313 int metadata_chapters_manual;
315 int chapters_input_file;
317 int64_t recording_time;
318 uint64_t limit_filesize;
324 int subtitle_disable;
327 /* indexed by output file stream index */
331 SpecifierOpt *metadata;
333 SpecifierOpt *max_frames;
335 SpecifierOpt *bitstream_filters;
336 int nb_bitstream_filters;
337 SpecifierOpt *codec_tags;
339 SpecifierOpt *sample_fmts;
341 SpecifierOpt *qscale;
343 SpecifierOpt *forced_key_frames;
344 int nb_forced_key_frames;
345 SpecifierOpt *force_fps;
347 SpecifierOpt *frame_aspect_ratios;
348 int nb_frame_aspect_ratios;
349 SpecifierOpt *rc_overrides;
351 SpecifierOpt *intra_matrices;
352 int nb_intra_matrices;
353 SpecifierOpt *inter_matrices;
354 int nb_inter_matrices;
355 SpecifierOpt *top_field_first;
356 int nb_top_field_first;
358 SpecifierOpt *filters;
363 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
366 for (i = 0; i < o->nb_ ## name; i++) {\
367 char *spec = o->name[i].specifier;\
368 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
369 outvar = o->name[i].u.type;\
375 static void reset_options(OptionsContext *o, int is_input)
377 const OptionDef *po = options;
378 OptionsContext bak= *o;
380 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
382 void *dst = (uint8_t*)o + po->u.off;
384 if (po->flags & OPT_SPEC) {
385 SpecifierOpt **so = dst;
386 int i, *count = (int*)(so + 1);
387 for (i = 0; i < *count; i++) {
388 av_freep(&(*so)[i].specifier);
389 if (po->flags & OPT_STRING)
390 av_freep(&(*so)[i].u.str);
394 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
399 av_freep(&o->stream_maps);
400 av_freep(&o->meta_data_maps);
401 av_freep(&o->streamid_map);
403 memset(o, 0, sizeof(*o));
405 if(is_input) o->recording_time = bak.recording_time;
406 else o->recording_time = INT64_MAX;
407 o->mux_preload = 0.5;
408 o->mux_max_delay = 0.7;
409 o->limit_filesize = UINT64_MAX;
410 o->chapters_input_file = INT_MAX;
418 static int configure_video_filters(InputStream *ist, OutputStream *ost)
420 AVFilterContext *last_filter, *filter;
421 /** filter graph containing all filters including input & output */
422 AVCodecContext *codec = ost->st->codec;
423 AVCodecContext *icodec = ist->st->codec;
424 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
425 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
426 AVRational sample_aspect_ratio;
430 ost->graph = avfilter_graph_alloc();
432 if (ist->st->sample_aspect_ratio.num){
433 sample_aspect_ratio = ist->st->sample_aspect_ratio;
435 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
437 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
438 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
439 sample_aspect_ratio.num, sample_aspect_ratio.den);
441 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
442 "src", args, NULL, ost->graph);
445 #if FF_API_OLD_VSINK_API
446 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
447 "out", NULL, pix_fmts, ost->graph);
449 buffersink_params->pixel_fmts = pix_fmts;
450 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
451 "out", NULL, buffersink_params, ost->graph);
453 av_freep(&buffersink_params);
456 last_filter = ost->input_video_filter;
458 if (codec->width != icodec->width || codec->height != icodec->height) {
459 snprintf(args, 255, "%d:%d:flags=0x%X",
463 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
464 NULL, args, NULL, ost->graph)) < 0)
466 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
468 last_filter = filter;
471 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
472 ost->graph->scale_sws_opts = av_strdup(args);
475 AVFilterInOut *outputs = avfilter_inout_alloc();
476 AVFilterInOut *inputs = avfilter_inout_alloc();
478 outputs->name = av_strdup("in");
479 outputs->filter_ctx = last_filter;
480 outputs->pad_idx = 0;
481 outputs->next = NULL;
483 inputs->name = av_strdup("out");
484 inputs->filter_ctx = ost->output_video_filter;
488 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
490 av_freep(&ost->avfilter);
492 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
496 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
499 codec->width = ost->output_video_filter->inputs[0]->w;
500 codec->height = ost->output_video_filter->inputs[0]->h;
501 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
502 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
503 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
504 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
508 #endif /* CONFIG_AVFILTER */
510 static void term_exit(void)
512 av_log(NULL, AV_LOG_QUIET, "%s", "");
515 tcsetattr (0, TCSANOW, &oldtty);
519 static volatile int received_sigterm = 0;
521 static void sigterm_handler(int sig)
523 received_sigterm = sig;
528 static void term_init(void)
538 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
539 |INLCR|IGNCR|ICRNL|IXON);
540 tty.c_oflag |= OPOST;
541 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
542 tty.c_cflag &= ~(CSIZE|PARENB);
547 tcsetattr (0, TCSANOW, &tty);
548 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
552 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
553 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
555 signal(SIGXCPU, sigterm_handler);
559 /* read a key without blocking */
560 static int read_key(void)
575 n = select(1, &rfds, NULL, NULL, &tv);
584 # if HAVE_PEEKNAMEDPIPE
586 static HANDLE input_handle;
589 input_handle = GetStdHandle(STD_INPUT_HANDLE);
590 is_pipe = !GetConsoleMode(input_handle, &dw);
593 if (stdin->_cnt > 0) {
598 /* When running under a GUI, you will end here. */
599 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
616 static int decode_interrupt_cb(void)
618 q_pressed += read_key() == 'q';
619 return q_pressed > 1;
622 void exit_program(int ret)
627 for(i=0;i<nb_output_files;i++) {
628 AVFormatContext *s = output_files[i].ctx;
629 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
631 avformat_free_context(s);
632 av_dict_free(&output_files[i].opts);
634 for(i=0;i<nb_input_files;i++) {
635 av_close_input_file(input_files[i].ctx);
637 for (i = 0; i < nb_input_streams; i++)
638 av_dict_free(&input_streams[i].opts);
642 av_free(vstats_filename);
644 av_freep(&input_streams);
645 av_freep(&input_files);
646 av_freep(&output_streams);
647 av_freep(&output_files);
652 allocated_audio_buf_size= allocated_audio_out_size= 0;
659 av_freep(&input_tmp);
661 if (received_sigterm) {
663 "Received signal %d: terminating.\n",
664 (int) received_sigterm);
668 exit(ret); /* not all OS-es handle main() return value */
671 static void assert_avoptions(AVDictionary *m)
673 AVDictionaryEntry *t;
674 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
675 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
680 static void assert_codec_experimental(AVCodecContext *c, int encoder)
682 const char *codec_string = encoder ? "encoder" : "decoder";
684 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
685 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
686 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
687 "results.\nAdd '-strict experimental' if you want to use it.\n",
688 codec_string, c->codec->name);
689 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
690 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
691 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
692 codec_string, codec->name);
697 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
699 if(codec && codec->sample_fmts){
700 const enum AVSampleFormat *p= codec->sample_fmts;
702 if(*p == st->codec->sample_fmt)
706 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
707 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
708 if(av_get_sample_fmt_name(st->codec->sample_fmt))
709 av_log(NULL, AV_LOG_WARNING,
710 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
711 av_get_sample_fmt_name(st->codec->sample_fmt),
713 av_get_sample_fmt_name(codec->sample_fmts[0]));
714 st->codec->sample_fmt = codec->sample_fmts[0];
719 static void choose_sample_rate(AVStream *st, AVCodec *codec)
721 if(codec && codec->supported_samplerates){
722 const int *p= codec->supported_samplerates;
724 int best_dist=INT_MAX;
726 int dist= abs(st->codec->sample_rate - *p);
727 if(dist < best_dist){
733 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
735 st->codec->sample_rate= best;
739 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
741 if(codec && codec->pix_fmts){
742 const enum PixelFormat *p= codec->pix_fmts;
743 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
744 if(st->codec->codec_id==CODEC_ID_MJPEG){
745 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
746 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
747 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
751 if(*p == st->codec->pix_fmt)
755 if(st->codec->pix_fmt != PIX_FMT_NONE)
756 av_log(NULL, AV_LOG_WARNING,
757 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
758 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
760 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
761 st->codec->pix_fmt = codec->pix_fmts[0];
766 static double get_sync_ipts(const OutputStream *ost)
768 const InputStream *ist = ost->sync_ist;
769 OutputFile *of = &output_files[ost->file_index];
770 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
773 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
778 AVPacket new_pkt= *pkt;
779 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
780 &new_pkt.data, &new_pkt.size,
781 pkt->data, pkt->size,
782 pkt->flags & AV_PKT_FLAG_KEY);
785 new_pkt.destruct= av_destruct_packet;
787 fprintf(stderr, "%s failed for stream %d, codec %s",
788 bsfc->filter->name, pkt->stream_index,
789 avctx->codec ? avctx->codec->name : "copy");
799 ret= av_interleaved_write_frame(s, pkt);
801 print_error("av_interleaved_write_frame()", ret);
806 static void do_audio_out(AVFormatContext *s,
809 unsigned char *buf, int size)
812 int64_t audio_out_size, audio_buf_size;
813 int64_t allocated_for_size= size;
815 int size_out, frame_bytes, ret, resample_changed;
816 AVCodecContext *enc= ost->st->codec;
817 AVCodecContext *dec= ist->st->codec;
818 int osize = av_get_bytes_per_sample(enc->sample_fmt);
819 int isize = av_get_bytes_per_sample(dec->sample_fmt);
820 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
823 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
824 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
825 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
826 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
827 audio_buf_size*= osize*enc->channels;
829 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
830 if(coded_bps > 8*osize)
831 audio_out_size= audio_out_size * coded_bps / (8*osize);
832 audio_out_size += FF_MIN_BUFFER_SIZE;
834 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
835 fprintf(stderr, "Buffer sizes too large\n");
839 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
840 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
841 if (!audio_buf || !audio_out){
842 fprintf(stderr, "Out of memory in do_audio_out\n");
846 if (enc->channels != dec->channels)
847 ost->audio_resample = 1;
849 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
850 ost->resample_channels != dec->channels ||
851 ost->resample_sample_rate != dec->sample_rate;
853 if ((ost->audio_resample && !ost->resample) || resample_changed) {
854 if (resample_changed) {
855 av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
856 ist->file_index, ist->st->index,
857 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
858 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
859 ost->resample_sample_fmt = dec->sample_fmt;
860 ost->resample_channels = dec->channels;
861 ost->resample_sample_rate = dec->sample_rate;
863 audio_resample_close(ost->resample);
865 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
866 if (audio_sync_method <= 1 &&
867 ost->resample_sample_fmt == enc->sample_fmt &&
868 ost->resample_channels == enc->channels &&
869 ost->resample_sample_rate == enc->sample_rate) {
870 ost->resample = NULL;
871 ost->audio_resample = 0;
873 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
874 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
875 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
876 enc->sample_rate, dec->sample_rate,
877 enc->sample_fmt, dec->sample_fmt,
879 if (!ost->resample) {
880 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
881 dec->channels, dec->sample_rate,
882 enc->channels, enc->sample_rate);
888 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
889 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
890 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
891 if (ost->reformat_ctx)
892 av_audio_convert_free(ost->reformat_ctx);
893 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
894 dec->sample_fmt, 1, NULL, 0);
895 if (!ost->reformat_ctx) {
896 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
897 av_get_sample_fmt_name(dec->sample_fmt),
898 av_get_sample_fmt_name(enc->sample_fmt));
901 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
904 if(audio_sync_method){
905 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
906 - av_fifo_size(ost->fifo)/(enc->channels * 2);
907 double idelta= delta*dec->sample_rate / enc->sample_rate;
908 int byte_delta= ((int)idelta)*2*dec->channels;
910 //FIXME resample delay
911 if(fabs(delta) > 50){
912 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
914 byte_delta= FFMAX(byte_delta, -size);
918 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
923 input_tmp= av_realloc(input_tmp, byte_delta + size);
925 if(byte_delta > allocated_for_size - size){
926 allocated_for_size= byte_delta + (int64_t)size;
931 memset(input_tmp, 0, byte_delta);
932 memcpy(input_tmp + byte_delta, buf, size);
936 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
938 }else if(audio_sync_method>1){
939 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
940 av_assert0(ost->audio_resample);
942 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
943 // fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
944 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
948 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
949 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
951 if (ost->audio_resample) {
953 size_out = audio_resample(ost->resample,
954 (short *)buftmp, (short *)buf,
955 size / (dec->channels * isize));
956 size_out = size_out * enc->channels * osize;
962 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
963 const void *ibuf[6]= {buftmp};
964 void *obuf[6]= {audio_buf};
965 int istride[6]= {isize};
966 int ostride[6]= {osize};
967 int len= size_out/istride[0];
968 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
969 printf("av_audio_convert() failed\n");
975 size_out = len*osize;
978 /* now encode as many frames as possible */
979 if (enc->frame_size > 1) {
980 /* output resampled raw samples */
981 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
982 fprintf(stderr, "av_fifo_realloc2() failed\n");
985 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
987 frame_bytes = enc->frame_size * osize * enc->channels;
989 while (av_fifo_size(ost->fifo) >= frame_bytes) {
991 av_init_packet(&pkt);
993 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
995 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
997 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1000 fprintf(stderr, "Audio encoding failed\n");
1004 pkt.stream_index= ost->index;
1005 pkt.data= audio_out;
1007 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1008 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1009 pkt.flags |= AV_PKT_FLAG_KEY;
1010 write_frame(s, &pkt, enc, ost->bitstream_filters);
1012 ost->sync_opts += enc->frame_size;
1016 av_init_packet(&pkt);
1018 ost->sync_opts += size_out / (osize * enc->channels);
1020 /* output a pcm frame */
1021 /* determine the size of the coded buffer */
1024 size_out = size_out*coded_bps/8;
1026 if(size_out > audio_out_size){
1027 fprintf(stderr, "Internal error, buffer size too small\n");
1031 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1032 ret = avcodec_encode_audio(enc, audio_out, size_out,
1035 fprintf(stderr, "Audio encoding failed\n");
1039 pkt.stream_index= ost->index;
1040 pkt.data= audio_out;
1042 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1043 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1044 pkt.flags |= AV_PKT_FLAG_KEY;
1045 write_frame(s, &pkt, enc, ost->bitstream_filters);
1049 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1051 AVCodecContext *dec;
1052 AVPicture *picture2;
1053 AVPicture picture_tmp;
1056 dec = ist->st->codec;
1058 /* deinterlace : must be done before any resize */
1059 if (do_deinterlace) {
1062 /* create temporary picture */
1063 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1064 buf = av_malloc(size);
1068 picture2 = &picture_tmp;
1069 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1071 if(avpicture_deinterlace(picture2, picture,
1072 dec->pix_fmt, dec->width, dec->height) < 0) {
1073 /* if error, do not deinterlace */
1074 fprintf(stderr, "Deinterlacing failed\n");
1083 if (picture != picture2)
1084 *picture = *picture2;
1088 static void do_subtitle_out(AVFormatContext *s,
1094 static uint8_t *subtitle_out = NULL;
1095 int subtitle_out_max_size = 1024 * 1024;
1096 int subtitle_out_size, nb, i;
1097 AVCodecContext *enc;
1100 if (pts == AV_NOPTS_VALUE) {
1101 fprintf(stderr, "Subtitle packets must have a pts\n");
1107 enc = ost->st->codec;
1109 if (!subtitle_out) {
1110 subtitle_out = av_malloc(subtitle_out_max_size);
1113 /* Note: DVB subtitle need one packet to draw them and one other
1114 packet to clear them */
1115 /* XXX: signal it in the codec context ? */
1116 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1121 for(i = 0; i < nb; i++) {
1122 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1123 // start_display_time is required to be 0
1124 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1125 sub->end_display_time -= sub->start_display_time;
1126 sub->start_display_time = 0;
1127 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1128 subtitle_out_max_size, sub);
1129 if (subtitle_out_size < 0) {
1130 fprintf(stderr, "Subtitle encoding failed\n");
1134 av_init_packet(&pkt);
1135 pkt.stream_index = ost->index;
1136 pkt.data = subtitle_out;
1137 pkt.size = subtitle_out_size;
1138 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1139 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1140 /* XXX: the pts correction is handled here. Maybe handling
1141 it in the codec would be better */
1143 pkt.pts += 90 * sub->start_display_time;
1145 pkt.pts += 90 * sub->end_display_time;
1147 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1151 static int bit_buffer_size= 1024*256;
1152 static uint8_t *bit_buffer= NULL;
1154 static void do_video_resample(OutputStream *ost,
1156 AVFrame *in_picture,
1157 AVFrame **out_picture)
1160 *out_picture = in_picture;
1162 AVCodecContext *dec = ist->st->codec;
1163 AVCodecContext *enc = ost->st->codec;
1164 int resample_changed = ost->resample_width != dec->width ||
1165 ost->resample_height != dec->height ||
1166 ost->resample_pix_fmt != dec->pix_fmt;
1168 *out_picture = in_picture;
1169 if (resample_changed) {
1170 av_log(NULL, AV_LOG_INFO,
1171 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1172 ist->file_index, ist->st->index,
1173 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1174 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1175 ost->resample_width = dec->width;
1176 ost->resample_height = dec->height;
1177 ost->resample_pix_fmt = dec->pix_fmt;
1180 ost->video_resample = dec->width != enc->width ||
1181 dec->height != enc->height ||
1182 dec->pix_fmt != enc->pix_fmt;
1184 if (ost->video_resample) {
1185 *out_picture = &ost->resample_frame;
1186 if (!ost->img_resample_ctx || resample_changed) {
1187 /* initialize the destination picture */
1188 if (!ost->resample_frame.data[0]) {
1189 avcodec_get_frame_defaults(&ost->resample_frame);
1190 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1191 enc->width, enc->height)) {
1192 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1196 /* initialize a new scaler context */
1197 sws_freeContext(ost->img_resample_ctx);
1198 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1199 enc->width, enc->height, enc->pix_fmt,
1200 ost->sws_flags, NULL, NULL, NULL);
1201 if (ost->img_resample_ctx == NULL) {
1202 fprintf(stderr, "Cannot get resampling context\n");
1206 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1207 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1213 static void do_video_out(AVFormatContext *s,
1216 AVFrame *in_picture,
1217 int *frame_size, float quality)
1219 int nb_frames, i, ret, format_video_sync;
1220 AVFrame *final_picture;
1221 AVCodecContext *enc;
1223 double duration = 0;
1225 enc = ost->st->codec;
1227 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1228 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1229 if(ist->st->avg_frame_rate.num)
1230 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1232 duration /= av_q2d(enc->time_base);
1235 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1237 /* by default, we output a single frame */
1242 format_video_sync = video_sync_method;
1243 if (format_video_sync < 0)
1244 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1246 if (format_video_sync) {
1247 double vdelta = sync_ipts - ost->sync_opts + duration;
1248 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1251 else if (format_video_sync == 2) {
1254 }else if(vdelta>0.6)
1255 ost->sync_opts= lrintf(sync_ipts);
1256 }else if (vdelta > 1.1)
1257 nb_frames = lrintf(vdelta);
1258 //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);
1259 if (nb_frames == 0){
1262 fprintf(stderr, "*** drop!\n");
1263 }else if (nb_frames > 1) {
1264 nb_frames_dup += nb_frames - 1;
1266 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1269 ost->sync_opts= lrintf(sync_ipts);
1271 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1275 do_video_resample(ost, ist, in_picture, &final_picture);
1277 /* duplicates frame if needed */
1278 for(i=0;i<nb_frames;i++) {
1280 av_init_packet(&pkt);
1281 pkt.stream_index= ost->index;
1283 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1284 /* raw pictures are written as AVPicture structure to
1285 avoid any copies. We support temporarily the older
1287 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1288 enc->coded_frame->top_field_first = in_picture->top_field_first;
1289 pkt.data= (uint8_t *)final_picture;
1290 pkt.size= sizeof(AVPicture);
1291 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1292 pkt.flags |= AV_PKT_FLAG_KEY;
1294 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1296 AVFrame big_picture;
1298 big_picture= *final_picture;
1299 /* better than nothing: use input picture interlaced
1301 big_picture.interlaced_frame = in_picture->interlaced_frame;
1302 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1303 if (ost->top_field_first == -1)
1304 big_picture.top_field_first = in_picture->top_field_first;
1306 big_picture.top_field_first = !!ost->top_field_first;
1309 /* handles same_quant here. This is not correct because it may
1310 not be a global option */
1311 big_picture.quality = quality;
1312 if (!enc->me_threshold)
1313 big_picture.pict_type = 0;
1314 // big_picture.pts = AV_NOPTS_VALUE;
1315 big_picture.pts= ost->sync_opts;
1316 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1317 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1318 if (ost->forced_kf_index < ost->forced_kf_count &&
1319 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1320 big_picture.pict_type = AV_PICTURE_TYPE_I;
1321 ost->forced_kf_index++;
1323 ret = avcodec_encode_video(enc,
1324 bit_buffer, bit_buffer_size,
1327 fprintf(stderr, "Video encoding failed\n");
1332 pkt.data= bit_buffer;
1334 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1335 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1336 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1337 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1338 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1340 if(enc->coded_frame->key_frame)
1341 pkt.flags |= AV_PKT_FLAG_KEY;
1342 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1345 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1346 // enc->frame_number-1, ret, enc->pict_type);
1347 /* if two pass, output log */
1348 if (ost->logfile && enc->stats_out) {
1349 fprintf(ost->logfile, "%s", enc->stats_out);
1354 ost->frame_number++;
1358 static double psnr(double d)
1360 return -10.0*log(d)/log(10.0);
1363 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1366 AVCodecContext *enc;
1368 double ti1, bitrate, avg_bitrate;
1370 /* this is executed just the first time do_video_stats is called */
1372 vstats_file = fopen(vstats_filename, "w");
1379 enc = ost->st->codec;
1380 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1381 frame_number = ost->frame_number;
1382 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1383 if (enc->flags&CODEC_FLAG_PSNR)
1384 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1386 fprintf(vstats_file,"f_size= %6d ", frame_size);
1387 /* compute pts value */
1388 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1392 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1393 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1394 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1395 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1396 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1400 static void print_report(OutputFile *output_files,
1401 OutputStream *ost_table, int nb_ostreams,
1402 int is_last_report, int64_t timer_start)
1406 AVFormatContext *oc;
1408 AVCodecContext *enc;
1409 int frame_number, vid, i;
1411 int64_t pts = INT64_MAX;
1412 static int64_t last_time = -1;
1413 static int qp_histogram[52];
1415 if (!is_last_report) {
1417 /* display the report every 0.5 seconds */
1418 cur_time = av_gettime();
1419 if (last_time == -1) {
1420 last_time = cur_time;
1423 if ((cur_time - last_time) < 500000)
1425 last_time = cur_time;
1429 oc = output_files[0].ctx;
1431 total_size = avio_size(oc->pb);
1432 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1433 total_size= avio_tell(oc->pb);
1437 for(i=0;i<nb_ostreams;i++) {
1439 ost = &ost_table[i];
1440 enc = ost->st->codec;
1441 if (!ost->st->stream_copy && enc->coded_frame)
1442 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1443 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1444 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1446 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1447 float t = (av_gettime()-timer_start) / 1000000.0;
1449 frame_number = ost->frame_number;
1450 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1451 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1453 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1457 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1460 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1462 if (enc->flags&CODEC_FLAG_PSNR){
1464 double error, error_sum=0;
1465 double scale, scale_sum=0;
1466 char type[3]= {'Y','U','V'};
1467 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1470 error= enc->error[j];
1471 scale= enc->width*enc->height*255.0*255.0*frame_number;
1473 error= enc->coded_frame->error[j];
1474 scale= enc->width*enc->height*255.0*255.0;
1479 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1481 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1485 /* compute min output value */
1486 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1487 ost->st->time_base, AV_TIME_BASE_Q));
1490 if (verbose > 0 || is_last_report) {
1491 int hours, mins, secs, us;
1492 secs = pts / AV_TIME_BASE;
1493 us = pts % AV_TIME_BASE;
1499 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1501 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1502 "size=%8.0fkB time=", total_size / 1024.0);
1503 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1504 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1505 (100 * us) / AV_TIME_BASE);
1506 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1507 "bitrate=%6.1fkbits/s", bitrate);
1509 if (nb_frames_dup || nb_frames_drop)
1510 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1511 nb_frames_dup, nb_frames_drop);
1514 fprintf(stderr, "%s \r", buf);
1519 if (is_last_report && verbose >= 0){
1520 int64_t raw= audio_size + video_size + extra_size;
1521 fprintf(stderr, "\n");
1522 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1526 100.0*(total_size - raw)/raw
1531 static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
1533 int fill_char = 0x00;
1534 if (sample_fmt == AV_SAMPLE_FMT_U8)
1536 memset(buf, fill_char, size);
1539 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1543 for (i = 0; i < nb_ostreams; i++) {
1544 OutputStream *ost = &ost_table[i];
1545 AVCodecContext *enc = ost->st->codec;
1546 AVFormatContext *os = output_files[ost->file_index].ctx;
1548 if (!ost->encoding_needed)
1551 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1553 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1559 av_init_packet(&pkt);
1560 pkt.stream_index= ost->index;
1562 switch (ost->st->codec->codec_type) {
1563 case AVMEDIA_TYPE_AUDIO:
1564 fifo_bytes = av_fifo_size(ost->fifo);
1566 /* encode any samples remaining in fifo */
1567 if (fifo_bytes > 0) {
1568 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1569 int fs_tmp = enc->frame_size;
1571 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1572 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1573 enc->frame_size = fifo_bytes / (osize * enc->channels);
1575 int frame_bytes = enc->frame_size*osize*enc->channels;
1576 if (allocated_audio_buf_size < frame_bytes)
1578 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1581 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1582 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1583 ost->st->time_base.num, enc->sample_rate);
1584 enc->frame_size = fs_tmp;
1587 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1590 fprintf(stderr, "Audio encoding failed\n");
1594 pkt.flags |= AV_PKT_FLAG_KEY;
1596 case AVMEDIA_TYPE_VIDEO:
1597 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1599 fprintf(stderr, "Video encoding failed\n");
1603 if(enc->coded_frame && enc->coded_frame->key_frame)
1604 pkt.flags |= AV_PKT_FLAG_KEY;
1605 if (ost->logfile && enc->stats_out) {
1606 fprintf(ost->logfile, "%s", enc->stats_out);
1615 pkt.data = bit_buffer;
1617 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1618 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1619 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1624 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1625 static int output_packet(InputStream *ist, int ist_index,
1626 OutputStream *ost_table, int nb_ostreams,
1627 const AVPacket *pkt)
1629 AVFormatContext *os;
1634 void *buffer_to_free = NULL;
1635 static unsigned int samples_size= 0;
1636 AVSubtitle subtitle, *subtitle_to_free;
1637 int64_t pkt_pts = AV_NOPTS_VALUE;
1639 int frame_available;
1644 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1646 if(ist->next_pts == AV_NOPTS_VALUE)
1647 ist->next_pts= ist->pts;
1651 av_init_packet(&avpkt);
1659 if(pkt->dts != AV_NOPTS_VALUE)
1660 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1661 if(pkt->pts != AV_NOPTS_VALUE)
1662 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1664 //while we have more to decode or while the decoder did output something on EOF
1665 while (avpkt.size > 0 || (!pkt && got_output)) {
1666 uint8_t *data_buf, *decoded_data_buf;
1667 int data_size, decoded_data_size;
1669 ist->pts= ist->next_pts;
1671 if(avpkt.size && avpkt.size != pkt->size &&
1672 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1673 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1674 ist->showed_multi_packet_warning=1;
1677 /* decode the packet if needed */
1678 decoded_data_buf = NULL; /* fail safe */
1679 decoded_data_size= 0;
1680 data_buf = avpkt.data;
1681 data_size = avpkt.size;
1682 subtitle_to_free = NULL;
1683 if (ist->decoding_needed) {
1684 switch(ist->st->codec->codec_type) {
1685 case AVMEDIA_TYPE_AUDIO:{
1686 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1687 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1689 samples= av_malloc(samples_size);
1691 decoded_data_size= samples_size;
1692 /* XXX: could avoid copy if PCM 16 bits with same
1693 endianness as CPU */
1694 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1701 got_output = decoded_data_size > 0;
1702 /* Some bug in mpeg audio decoder gives */
1703 /* decoded_data_size < 0, it seems they are overflows */
1705 /* no audio frame */
1708 decoded_data_buf = (uint8_t *)samples;
1709 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1710 (ist->st->codec->sample_rate * ist->st->codec->channels);
1712 case AVMEDIA_TYPE_VIDEO:
1713 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1714 /* XXX: allocate picture correctly */
1715 avcodec_get_frame_defaults(&picture);
1716 avpkt.pts = pkt_pts;
1717 avpkt.dts = ist->pts;
1718 pkt_pts = AV_NOPTS_VALUE;
1720 ret = avcodec_decode_video2(ist->st->codec,
1721 &picture, &got_output, &avpkt);
1722 quality = same_quant ? picture.quality : 0;
1726 /* no picture yet */
1727 goto discard_packet;
1729 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1730 if (ist->st->codec->time_base.num != 0) {
1731 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1732 ist->next_pts += ((int64_t)AV_TIME_BASE *
1733 ist->st->codec->time_base.num * ticks) /
1734 ist->st->codec->time_base.den;
1737 buffer_to_free = NULL;
1738 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1740 case AVMEDIA_TYPE_SUBTITLE:
1741 ret = avcodec_decode_subtitle2(ist->st->codec,
1742 &subtitle, &got_output, &avpkt);
1746 goto discard_packet;
1748 subtitle_to_free = &subtitle;
1755 switch(ist->st->codec->codec_type) {
1756 case AVMEDIA_TYPE_AUDIO:
1757 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1758 ist->st->codec->sample_rate;
1760 case AVMEDIA_TYPE_VIDEO:
1761 if (ist->st->codec->time_base.num != 0) {
1762 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1763 ist->next_pts += ((int64_t)AV_TIME_BASE *
1764 ist->st->codec->time_base.num * ticks) /
1765 ist->st->codec->time_base.den;
1773 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1774 for(i=0;i<nb_ostreams;i++) {
1775 OutputFile *of = &output_files[ost_table[i].file_index];
1776 if (of->start_time == 0 || ist->pts >= of->start_time) {
1777 ost = &ost_table[i];
1778 if (ost->input_video_filter && ost->source_index == ist_index) {
1779 if (!picture.sample_aspect_ratio.num)
1780 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1781 picture.pts = ist->pts;
1783 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1789 // preprocess audio (volume)
1790 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1791 if (audio_volume != 256) {
1794 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1795 int v = ((*volp) * audio_volume + 128) >> 8;
1796 *volp++ = av_clip_int16(v);
1801 /* frame rate emulation */
1802 if (input_files[ist->file_index].rate_emu) {
1803 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1804 int64_t now = av_gettime() - ist->start;
1808 /* if output time reached then transcode raw format,
1809 encode packets and output them */
1810 for (i = 0; i < nb_ostreams; i++) {
1811 OutputFile *of = &output_files[ost_table[i].file_index];
1814 ost = &ost_table[i];
1815 if (ost->source_index != ist_index)
1818 if (of->start_time && ist->pts < of->start_time)
1821 if (of->recording_time != INT64_MAX &&
1822 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1823 (AVRational){1, 1000000}) >= 0) {
1824 ost->is_past_recording_time = 1;
1829 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1830 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1831 while (frame_available) {
1832 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1833 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1834 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1837 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1838 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1842 os = output_files[ost->file_index].ctx;
1844 /* set the input output pts pairs */
1845 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1847 if (ost->encoding_needed) {
1848 av_assert0(ist->decoding_needed);
1849 switch(ost->st->codec->codec_type) {
1850 case AVMEDIA_TYPE_AUDIO:
1851 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1853 case AVMEDIA_TYPE_VIDEO:
1855 if (ost->picref->video && !ost->frame_aspect_ratio)
1856 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1858 do_video_out(os, ost, ist, &picture, &frame_size,
1859 same_quant ? quality : ost->st->codec->global_quality);
1860 if (vstats_filename && frame_size)
1861 do_video_stats(os, ost, frame_size);
1863 case AVMEDIA_TYPE_SUBTITLE:
1864 do_subtitle_out(os, ost, ist, &subtitle,
1871 AVFrame avframe; //FIXME/XXX remove this
1874 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1875 av_init_packet(&opkt);
1877 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1878 #if !CONFIG_AVFILTER
1884 /* no reencoding needed : output the packet directly */
1885 /* force the input stream PTS */
1887 avcodec_get_frame_defaults(&avframe);
1888 ost->st->codec->coded_frame= &avframe;
1889 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1891 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1892 audio_size += data_size;
1893 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1894 video_size += data_size;
1898 opkt.stream_index= ost->index;
1899 if(pkt->pts != AV_NOPTS_VALUE)
1900 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1902 opkt.pts= AV_NOPTS_VALUE;
1904 if (pkt->dts == AV_NOPTS_VALUE)
1905 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1907 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1908 opkt.dts -= ost_tb_start_time;
1910 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1911 opkt.flags= pkt->flags;
1913 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1914 if( ost->st->codec->codec_id != CODEC_ID_H264
1915 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1916 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1918 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1919 opkt.destruct= av_destruct_packet;
1921 opkt.data = data_buf;
1922 opkt.size = data_size;
1925 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1926 /* store AVPicture in AVPacket, as expected by the output format */
1927 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1928 opkt.data = (uint8_t *)&pict;
1929 opkt.size = sizeof(AVPicture);
1930 opkt.flags |= AV_PKT_FLAG_KEY;
1932 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1933 ost->st->codec->frame_number++;
1934 ost->frame_number++;
1935 av_free_packet(&opkt);
1939 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1940 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1941 avfilter_unref_buffer(ost->picref);
1946 av_free(buffer_to_free);
1947 /* XXX: allocate the subtitles in the codec ? */
1948 if (subtitle_to_free) {
1949 avsubtitle_free(subtitle_to_free);
1950 subtitle_to_free = NULL;
1958 static void print_sdp(OutputFile *output_files, int n)
1962 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1966 for (i = 0; i < n; i++)
1967 avc[i] = output_files[i].ctx;
1969 av_sdp_create(avc, n, sdp, sizeof(sdp));
1970 printf("SDP:\n%s\n", sdp);
1975 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1976 char *error, int error_len)
1978 InputStream *ist = &input_streams[ist_index];
1979 if (ist->decoding_needed) {
1980 AVCodec *codec = ist->dec;
1982 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
1983 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1984 return AVERROR(EINVAL);
1986 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1987 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1988 ist->file_index, ist->st->index);
1989 return AVERROR(EINVAL);
1991 assert_codec_experimental(ist->st->codec, 0);
1992 assert_avoptions(ist->opts);
1995 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;
1996 ist->next_pts = AV_NOPTS_VALUE;
2002 static int transcode_init(OutputFile *output_files, int nb_output_files,
2003 InputFile *input_files, int nb_input_files)
2005 int ret = 0, i, j, k;
2006 AVFormatContext *os;
2007 AVCodecContext *codec, *icodec;
2013 /* init framerate emulation */
2014 for (i = 0; i < nb_input_files; i++) {
2015 InputFile *ifile = &input_files[i];
2016 if (ifile->rate_emu)
2017 for (j = 0; j < ifile->nb_streams; j++)
2018 input_streams[j + ifile->ist_index].start = av_gettime();
2021 /* output stream init */
2022 for(i=0;i<nb_output_files;i++) {
2023 os = output_files[i].ctx;
2024 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2025 av_dump_format(os, i, os->filename, 1);
2026 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2027 return AVERROR(EINVAL);
2031 /* for each output stream, we compute the right encoding parameters */
2032 for (i = 0; i < nb_output_streams; i++) {
2033 ost = &output_streams[i];
2034 os = output_files[ost->file_index].ctx;
2035 ist = &input_streams[ost->source_index];
2037 codec = ost->st->codec;
2038 icodec = ist->st->codec;
2040 ost->st->disposition = ist->st->disposition;
2041 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2042 codec->chroma_sample_location = icodec->chroma_sample_location;
2044 if (ost->st->stream_copy) {
2045 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2047 if (extra_size > INT_MAX) {
2048 return AVERROR(EINVAL);
2051 /* if stream_copy is selected, no need to decode or encode */
2052 codec->codec_id = icodec->codec_id;
2053 codec->codec_type = icodec->codec_type;
2055 if(!codec->codec_tag){
2056 if( !os->oformat->codec_tag
2057 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2058 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2059 codec->codec_tag = icodec->codec_tag;
2062 codec->bit_rate = icodec->bit_rate;
2063 codec->rc_max_rate = icodec->rc_max_rate;
2064 codec->rc_buffer_size = icodec->rc_buffer_size;
2065 codec->extradata= av_mallocz(extra_size);
2066 if (!codec->extradata) {
2067 return AVERROR(ENOMEM);
2069 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2070 codec->extradata_size= icodec->extradata_size;
2072 codec->time_base = ist->st->time_base;
2073 if(!strcmp(os->oformat->name, "avi")) {
2074 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){
2075 codec->time_base = icodec->time_base;
2076 codec->time_base.num *= icodec->ticks_per_frame;
2077 codec->time_base.den *= 2;
2079 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2080 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){
2081 codec->time_base = icodec->time_base;
2082 codec->time_base.num *= icodec->ticks_per_frame;
2085 av_reduce(&codec->time_base.num, &codec->time_base.den,
2086 codec->time_base.num, codec->time_base.den, INT_MAX);
2088 switch(codec->codec_type) {
2089 case AVMEDIA_TYPE_AUDIO:
2090 if(audio_volume != 256) {
2091 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2094 codec->channel_layout = icodec->channel_layout;
2095 codec->sample_rate = icodec->sample_rate;
2096 codec->channels = icodec->channels;
2097 codec->frame_size = icodec->frame_size;
2098 codec->audio_service_type = icodec->audio_service_type;
2099 codec->block_align= icodec->block_align;
2100 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2101 codec->block_align= 0;
2102 if(codec->codec_id == CODEC_ID_AC3)
2103 codec->block_align= 0;
2105 case AVMEDIA_TYPE_VIDEO:
2106 codec->pix_fmt = icodec->pix_fmt;
2107 codec->width = icodec->width;
2108 codec->height = icodec->height;
2109 codec->has_b_frames = icodec->has_b_frames;
2110 if (!codec->sample_aspect_ratio.num) {
2111 codec->sample_aspect_ratio =
2112 ost->st->sample_aspect_ratio =
2113 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2114 ist->st->codec->sample_aspect_ratio.num ?
2115 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2118 case AVMEDIA_TYPE_SUBTITLE:
2119 codec->width = icodec->width;
2120 codec->height = icodec->height;
2122 case AVMEDIA_TYPE_DATA:
2129 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2130 switch(codec->codec_type) {
2131 case AVMEDIA_TYPE_AUDIO:
2132 ost->fifo= av_fifo_alloc(1024);
2134 return AVERROR(ENOMEM);
2136 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2137 if (!codec->sample_rate) {
2138 codec->sample_rate = icodec->sample_rate;
2140 choose_sample_rate(ost->st, ost->enc);
2141 codec->time_base = (AVRational){1, codec->sample_rate};
2142 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2143 codec->sample_fmt = icodec->sample_fmt;
2144 choose_sample_fmt(ost->st, ost->enc);
2145 if (!codec->channels) {
2146 codec->channels = icodec->channels;
2147 codec->channel_layout = icodec->channel_layout;
2149 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2150 codec->channel_layout = 0;
2151 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2152 icodec->request_channels = codec->channels;
2153 ist->decoding_needed = 1;
2154 ost->encoding_needed = 1;
2155 ost->resample_sample_fmt = icodec->sample_fmt;
2156 ost->resample_sample_rate = icodec->sample_rate;
2157 ost->resample_channels = icodec->channels;
2159 case AVMEDIA_TYPE_VIDEO:
2160 if (codec->pix_fmt == PIX_FMT_NONE)
2161 codec->pix_fmt = icodec->pix_fmt;
2162 choose_pixel_fmt(ost->st, ost->enc);
2164 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2165 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2169 if (!codec->width || !codec->height) {
2170 codec->width = icodec->width;
2171 codec->height = icodec->height;
2174 ost->video_resample = codec->width != icodec->width ||
2175 codec->height != icodec->height ||
2176 codec->pix_fmt != icodec->pix_fmt;
2177 if (ost->video_resample) {
2178 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2181 ost->resample_height = icodec->height;
2182 ost->resample_width = icodec->width;
2183 ost->resample_pix_fmt= icodec->pix_fmt;
2184 ost->encoding_needed = 1;
2185 ist->decoding_needed = 1;
2187 if (!ost->frame_rate.num)
2188 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2189 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2190 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2191 ost->frame_rate = ost->enc->supported_framerates[idx];
2193 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2194 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2195 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2196 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2197 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2201 if (configure_video_filters(ist, ost)) {
2202 fprintf(stderr, "Error opening filters!\n");
2207 case AVMEDIA_TYPE_SUBTITLE:
2208 ost->encoding_needed = 1;
2209 ist->decoding_needed = 1;
2216 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2217 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2218 char logfilename[1024];
2221 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2222 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2224 if (codec->flags & CODEC_FLAG_PASS1) {
2225 f = fopen(logfilename, "wb");
2227 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2233 size_t logbuffer_size;
2234 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2235 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2238 codec->stats_in = logbuffer;
2242 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2243 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2244 int size= codec->width * codec->height;
2245 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2250 bit_buffer = av_malloc(bit_buffer_size);
2252 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2254 return AVERROR(ENOMEM);
2257 /* open each encoder */
2258 for (i = 0; i < nb_output_streams; i++) {
2259 ost = &output_streams[i];
2260 if (ost->encoding_needed) {
2261 AVCodec *codec = ost->enc;
2262 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2264 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2265 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2266 ret = AVERROR(EINVAL);
2269 if (dec->subtitle_header) {
2270 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2271 if (!ost->st->codec->subtitle_header) {
2272 ret = AVERROR(ENOMEM);
2275 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2276 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2278 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2279 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2280 ost->file_index, ost->index);
2281 ret = AVERROR(EINVAL);
2284 assert_codec_experimental(ost->st->codec, 1);
2285 assert_avoptions(ost->opts);
2286 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2287 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2288 "It takes bits/s as argument, not kbits/s\n");
2289 extra_size += ost->st->codec->extradata_size;
2291 if (ost->st->codec->me_threshold)
2292 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2296 /* init input streams */
2297 for (i = 0; i < nb_input_streams; i++)
2298 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2301 /* discard unused programs */
2302 for (i = 0; i < nb_input_files; i++) {
2303 InputFile *ifile = &input_files[i];
2304 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2305 AVProgram *p = ifile->ctx->programs[j];
2306 int discard = AVDISCARD_ALL;
2308 for (k = 0; k < p->nb_stream_indexes; k++)
2309 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2310 discard = AVDISCARD_DEFAULT;
2313 p->discard = discard;
2317 /* open files and write file headers */
2318 for (i = 0; i < nb_output_files; i++) {
2319 os = output_files[i].ctx;
2320 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2321 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2322 ret = AVERROR(EINVAL);
2325 // assert_avoptions(output_files[i].opts);
2326 if (strcmp(os->oformat->name, "rtp")) {
2332 /* dump the file output parameters - cannot be done before in case
2334 for(i=0;i<nb_output_files;i++) {
2335 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2338 /* dump the stream mapping */
2340 fprintf(stderr, "Stream mapping:\n");
2341 for (i = 0; i < nb_output_streams;i ++) {
2342 ost = &output_streams[i];
2343 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2344 input_streams[ost->source_index].file_index,
2345 input_streams[ost->source_index].st->index,
2348 if (ost->sync_ist != &input_streams[ost->source_index])
2349 fprintf(stderr, " [sync #%d.%d]",
2350 ost->sync_ist->file_index,
2351 ost->sync_ist->st->index);
2352 if (ost->st->stream_copy)
2353 fprintf(stderr, " (copy)");
2355 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2356 input_streams[ost->source_index].dec->name : "?",
2357 ost->enc ? ost->enc->name : "?");
2358 fprintf(stderr, "\n");
2363 fprintf(stderr, "%s\n", error);
2368 print_sdp(output_files, nb_output_files);
2375 * The following code is the main loop of the file converter
2377 static int transcode(OutputFile *output_files, int nb_output_files,
2378 InputFile *input_files, int nb_input_files)
2381 AVFormatContext *is, *os;
2385 int no_packet_count=0;
2386 int64_t timer_start;
2389 if (!(no_packet = av_mallocz(nb_input_files)))
2392 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2398 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2399 avio_set_interrupt_cb(decode_interrupt_cb);
2403 timer_start = av_gettime();
2405 for(; received_sigterm == 0;) {
2406 int file_index, ist_index;
2411 ipts_min= INT64_MAX;
2413 /* if 'q' pressed, exits */
2417 /* read_key() returns 0 on EOF */
2421 if (key == '+') verbose++;
2422 if (key == '-') verbose--;
2423 if (key == 's') qp_hist ^= 1;
2426 do_hex_dump = do_pkt_dump = 0;
2427 } else if(do_pkt_dump){
2431 av_log_set_level(AV_LOG_DEBUG);
2434 if (key == 'c' || key == 'C'){
2435 char ret[4096], target[64], cmd[256], arg[256]={0};
2438 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2440 while((k=read_key()) !='\n' && k!='\r' && i<sizeof(ret)-1)
2441 if(k>0) ret[i++]= k;
2443 if(k>0 && sscanf(ret, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &ts, cmd, arg) >= 3){
2444 for(i=0;i<nb_output_streams;i++) {
2446 ost = &output_streams[i];
2449 r= avfilter_graph_send_command(ost->graph, target, cmd, arg, ret, sizeof(ret), key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2450 fprintf(stderr, "Command reply for %d: %d, %s\n", i, r, ret);
2452 r= avfilter_graph_queue_command(ost->graph, target, cmd, arg, 0, ts);
2457 fprintf(stderr, "Parse error\n");
2461 if (key == 'd' || key == 'D'){
2464 debug = input_streams[0].st->codec->debug<<1;
2465 if(!debug) debug = 1;
2466 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2469 scanf("%d", &debug);
2470 for(i=0;i<nb_input_streams;i++) {
2471 input_streams[i].st->codec->debug = debug;
2473 for(i=0;i<nb_output_streams;i++) {
2474 ost = &output_streams[i];
2475 ost->st->codec->debug = debug;
2477 if(debug) av_log_set_level(AV_LOG_DEBUG);
2478 fprintf(stderr,"debug=%d\n", debug);
2481 fprintf(stderr, "key function\n"
2482 "? show this help\n"
2483 "+ increase verbosity\n"
2484 "- decrease verbosity\n"
2485 "c Send command to filtergraph\n"
2486 "D cycle through available debug modes\n"
2487 "h dump packets/hex press to cycle through the 3 states\n"
2489 "s Show QP histogram\n"
2494 /* select the stream that we must read now by looking at the
2495 smallest output pts */
2497 for (i = 0; i < nb_output_streams; i++) {
2501 ost = &output_streams[i];
2502 of = &output_files[ost->file_index];
2503 os = output_files[ost->file_index].ctx;
2504 ist = &input_streams[ost->source_index];
2505 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2506 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2508 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2510 if (!input_files[ist->file_index].eof_reached){
2511 if(ipts < ipts_min) {
2513 if(input_sync ) file_index = ist->file_index;
2515 if(opts < opts_min) {
2517 if(!input_sync) file_index = ist->file_index;
2520 if (ost->frame_number >= ost->max_frames) {
2522 for (j = of->ost_index; j < of->ctx->nb_streams; j++)
2523 output_streams[j].is_past_recording_time = 1;
2527 /* if none, if is finished */
2528 if (file_index < 0) {
2529 if(no_packet_count){
2531 memset(no_packet, 0, nb_input_files);
2538 /* read a frame from it and output it in the fifo */
2539 is = input_files[file_index].ctx;
2540 ret= av_read_frame(is, &pkt);
2541 if(ret == AVERROR(EAGAIN)){
2542 no_packet[file_index]=1;
2547 input_files[file_index].eof_reached = 1;
2555 memset(no_packet, 0, nb_input_files);
2558 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2559 is->streams[pkt.stream_index]);
2561 /* the following test is needed in case new streams appear
2562 dynamically in stream : we ignore them */
2563 if (pkt.stream_index >= input_files[file_index].nb_streams)
2564 goto discard_packet;
2565 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2566 ist = &input_streams[ist_index];
2568 goto discard_packet;
2570 if (pkt.dts != AV_NOPTS_VALUE)
2571 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2572 if (pkt.pts != AV_NOPTS_VALUE)
2573 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2575 if(pkt.pts != AV_NOPTS_VALUE)
2576 pkt.pts *= ist->ts_scale;
2577 if(pkt.dts != AV_NOPTS_VALUE)
2578 pkt.dts *= ist->ts_scale;
2580 // 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);
2581 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2582 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2583 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2584 int64_t delta= pkt_dts - ist->next_pts;
2585 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2586 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2587 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2588 pkt_dts+1<ist->pts)&& !copy_ts){
2589 input_files[ist->file_index].ts_offset -= delta;
2591 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2592 delta, input_files[ist->file_index].ts_offset);
2593 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2594 if(pkt.pts != AV_NOPTS_VALUE)
2595 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2599 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2600 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2603 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2604 ist->file_index, ist->st->index);
2607 av_free_packet(&pkt);
2612 av_free_packet(&pkt);
2614 /* dump report by using the output first video and audio streams */
2615 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2618 /* at the end of stream, we must flush the decoder buffers */
2619 for (i = 0; i < nb_input_streams; i++) {
2620 ist = &input_streams[i];
2621 if (ist->decoding_needed) {
2622 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2625 flush_encoders(output_streams, nb_output_streams);
2629 /* write the trailer if needed and close file */
2630 for(i=0;i<nb_output_files;i++) {
2631 os = output_files[i].ctx;
2632 av_write_trailer(os);
2635 /* dump report by using the first video and audio streams */
2636 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2638 /* close each encoder */
2639 for (i = 0; i < nb_output_streams; i++) {
2640 ost = &output_streams[i];
2641 if (ost->encoding_needed) {
2642 av_freep(&ost->st->codec->stats_in);
2643 avcodec_close(ost->st->codec);
2646 avfilter_graph_free(&ost->graph);
2650 /* close each decoder */
2651 for (i = 0; i < nb_input_streams; i++) {
2652 ist = &input_streams[i];
2653 if (ist->decoding_needed) {
2654 avcodec_close(ist->st->codec);
2662 av_freep(&bit_buffer);
2663 av_freep(&no_packet);
2665 if (output_streams) {
2666 for (i = 0; i < nb_output_streams; i++) {
2667 ost = &output_streams[i];
2669 if (ost->st->stream_copy)
2670 av_freep(&ost->st->codec->extradata);
2672 fclose(ost->logfile);
2673 ost->logfile = NULL;
2675 av_fifo_free(ost->fifo); /* works even if fifo is not
2676 initialized but set to zero */
2677 av_freep(&ost->st->codec->subtitle_header);
2678 av_free(ost->resample_frame.data[0]);
2679 av_free(ost->forced_kf_pts);
2680 if (ost->video_resample)
2681 sws_freeContext(ost->img_resample_ctx);
2683 audio_resample_close(ost->resample);
2684 if (ost->reformat_ctx)
2685 av_audio_convert_free(ost->reformat_ctx);
2686 av_dict_free(&ost->opts);
2693 static int opt_verbose(const char *opt, const char *arg)
2695 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2699 static int opt_frame_crop(const char *opt, const char *arg)
2701 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2702 return AVERROR(EINVAL);
2705 static int opt_pad(const char *opt, const char *arg)
2707 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2711 static double parse_frame_aspect_ratio(const char *arg)
2718 p = strchr(arg, ':');
2720 x = strtol(arg, &end, 10);
2722 y = strtol(end+1, &end, 10);
2724 ar = (double)x / (double)y;
2726 ar = strtod(arg, NULL);
2729 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2735 static int opt_video_channel(const char *opt, const char *arg)
2737 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2738 return opt_default("channel", arg);
2741 static int opt_video_standard(const char *opt, const char *arg)
2743 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2744 return opt_default("standard", arg);
2747 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2749 audio_codec_name = arg;
2750 return parse_option(o, "codec:a", arg, options);
2753 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2755 video_codec_name = arg;
2756 return parse_option(o, "codec:v", arg, options);
2759 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2761 subtitle_codec_name = arg;
2762 return parse_option(o, "codec:s", arg, options);
2765 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2767 return parse_option(o, "codec:d", arg, options);
2770 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2772 StreamMap *m = NULL;
2773 int i, negative = 0, file_idx;
2774 int sync_file_idx = -1, sync_stream_idx;
2782 map = av_strdup(arg);
2784 /* parse sync stream first, just pick first matching stream */
2785 if (sync = strchr(map, ',')) {
2787 sync_file_idx = strtol(sync + 1, &sync, 0);
2788 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2789 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2794 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2795 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2796 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2797 sync_stream_idx = i;
2800 if (i == input_files[sync_file_idx].nb_streams) {
2801 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2802 "match any streams.\n", arg);
2808 file_idx = strtol(map, &p, 0);
2809 if (file_idx >= nb_input_files || file_idx < 0) {
2810 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2814 /* disable some already defined maps */
2815 for (i = 0; i < o->nb_stream_maps; i++) {
2816 m = &o->stream_maps[i];
2817 if (check_stream_specifier(input_files[m->file_index].ctx,
2818 input_files[m->file_index].ctx->streams[m->stream_index],
2819 *p == ':' ? p + 1 : p) > 0)
2823 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2824 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2825 *p == ':' ? p + 1 : p) <= 0)
2827 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2828 &o->nb_stream_maps, o->nb_stream_maps + 1);
2829 m = &o->stream_maps[o->nb_stream_maps - 1];
2831 m->file_index = file_idx;
2832 m->stream_index = i;
2834 if (sync_file_idx >= 0) {
2835 m->sync_file_index = sync_file_idx;
2836 m->sync_stream_index = sync_stream_idx;
2838 m->sync_file_index = file_idx;
2839 m->sync_stream_index = i;
2844 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2852 static void parse_meta_type(char *arg, char *type, int *index)
2862 if (*(++arg) == ':')
2863 *index = strtol(++arg, NULL, 0);
2866 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2873 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2875 MetadataMap *m, *m1;
2878 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2879 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2881 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2882 m->file = strtol(arg, &p, 0);
2883 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2885 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2886 if (p = strchr(opt, ':'))
2887 parse_meta_type(p + 1, &m1->type, &m1->index);
2891 if (m->type == 'g' || m1->type == 'g')
2892 o->metadata_global_manual = 1;
2893 if (m->type == 's' || m1->type == 's')
2894 o->metadata_streams_manual = 1;
2895 if (m->type == 'c' || m1->type == 'c')
2896 o->metadata_chapters_manual = 1;
2901 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2903 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2904 "Use -map_metadata instead.\n");
2905 return opt_map_metadata(o, opt, arg);
2908 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
2911 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2912 struct tm time = *gmtime((time_t*)&recording_timestamp);
2913 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2914 parse_option(o, "metadata", buf, options);
2916 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2917 "tag instead.\n", opt);
2921 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2923 const char *codec_string = encoder ? "encoder" : "decoder";
2927 return CODEC_ID_NONE;
2929 avcodec_find_encoder_by_name(name) :
2930 avcodec_find_decoder_by_name(name);
2932 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2935 if(codec->type != type) {
2936 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2942 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2944 char *codec_name = NULL;
2946 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2950 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2951 return avcodec_find_encoder(st->codec->codec_id);
2953 } else if (!strcmp(codec_name, "copy"))
2954 st->stream_copy = 1;
2956 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2957 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2958 avcodec_find_decoder_by_name(codec_name);
2965 * Add all the streams from the given input file to the global
2966 * list of input streams.
2968 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2970 int i, rfps, rfps_base;
2972 for (i = 0; i < ic->nb_streams; i++) {
2973 AVStream *st = ic->streams[i];
2974 AVCodecContext *dec = st->codec;
2978 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2979 ist = &input_streams[nb_input_streams - 1];
2981 ist->file_index = nb_input_files;
2983 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2985 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2986 ist->ts_scale = scale;
2988 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2990 ist->dec = avcodec_find_decoder(dec->codec_id);
2992 switch (dec->codec_type) {
2993 case AVMEDIA_TYPE_AUDIO:
2995 ist->dec = avcodec_find_decoder(dec->codec_id);
2996 if(o->audio_disable)
2997 st->discard= AVDISCARD_ALL;
2999 case AVMEDIA_TYPE_VIDEO:
3001 ist->dec = avcodec_find_decoder(dec->codec_id);
3002 rfps = ic->streams[i]->r_frame_rate.num;
3003 rfps_base = ic->streams[i]->r_frame_rate.den;
3005 dec->flags |= CODEC_FLAG_EMU_EDGE;
3008 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3011 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3012 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3014 (float)rfps / rfps_base, rfps, rfps_base);
3017 if (o->video_disable)
3018 st->discard= AVDISCARD_ALL;
3019 else if(video_discard)
3020 st->discard= video_discard;
3022 case AVMEDIA_TYPE_DATA:
3024 case AVMEDIA_TYPE_SUBTITLE:
3026 ist->dec = avcodec_find_decoder(dec->codec_id);
3027 if(o->subtitle_disable)
3028 st->discard = AVDISCARD_ALL;
3030 case AVMEDIA_TYPE_ATTACHMENT:
3031 case AVMEDIA_TYPE_UNKNOWN:
3039 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3041 AVFormatContext *ic;
3042 AVInputFormat *file_iformat = NULL;
3046 AVDictionary **opts;
3047 int orig_nb_streams; // number of streams before avformat_find_stream_info
3050 if (!(file_iformat = av_find_input_format(o->format))) {
3051 fprintf(stderr, "Unknown input format: '%s'\n", o->format);
3056 if (!strcmp(filename, "-"))
3059 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3060 !strcmp(filename, "/dev/stdin");
3062 /* get default parameters from command line */
3063 ic = avformat_alloc_context();
3065 print_error(filename, AVERROR(ENOMEM));
3068 if (o->nb_audio_sample_rate) {
3069 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3070 av_dict_set(&format_opts, "sample_rate", buf, 0);
3072 if (o->nb_audio_channels) {
3073 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3074 av_dict_set(&format_opts, "channels", buf, 0);
3076 if (o->nb_frame_rates) {
3077 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3079 if (o->nb_frame_sizes) {
3080 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3082 if (o->nb_frame_pix_fmts)
3083 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3085 ic->flags |= AVFMT_FLAG_NONBLOCK;
3088 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3089 ic->loop_input = loop_input;
3092 /* open the input file with generic libav function */
3093 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3095 print_error(filename, err);
3098 assert_avoptions(format_opts);
3100 /* apply forced codec ids */
3101 for (i = 0; i < ic->nb_streams; i++)
3102 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3104 /* Set AVCodecContext options for avformat_find_stream_info */
3105 opts = setup_find_stream_info_opts(ic, codec_opts);
3106 orig_nb_streams = ic->nb_streams;
3108 /* If not enough info to get the stream parameters, we decode the
3109 first frames to get it. (used in mpeg case for example) */
3110 ret = avformat_find_stream_info(ic, opts);
3111 if (ret < 0 && verbose >= 0) {
3112 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3113 av_close_input_file(ic);
3117 timestamp = o->start_time;
3118 /* add the stream start time */
3119 if (ic->start_time != AV_NOPTS_VALUE)
3120 timestamp += ic->start_time;
3122 /* if seeking requested, we execute it */
3123 if (o->start_time != 0) {
3124 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3126 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3127 filename, (double)timestamp / AV_TIME_BASE);
3131 /* update the current parameters so that they match the one of the input stream */
3132 add_input_streams(o, ic);
3134 /* dump the file content */
3136 av_dump_format(ic, nb_input_files, filename, 0);
3138 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3139 input_files[nb_input_files - 1].ctx = ic;
3140 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3141 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3142 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3143 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3145 for (i = 0; i < orig_nb_streams; i++)
3146 av_dict_free(&opts[i]);
3149 reset_options(o, 1);
3153 static void parse_forced_key_frames(char *kf, OutputStream *ost, AVCodecContext *avctx)
3159 for (p = kf; *p; p++)
3162 ost->forced_kf_count = n;
3163 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3164 if (!ost->forced_kf_pts) {
3165 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3168 for (i = 0; i < n; i++) {
3169 p = i ? strchr(p, ',') + 1 : kf;
3170 t = parse_time_or_die("force_key_frames", p, 1);
3171 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3175 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3178 AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
3179 int idx = oc->nb_streams - 1;
3180 int64_t max_frames = INT64_MAX;
3181 char *bsf = NULL, *next, *codec_tag = NULL;
3182 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3186 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3190 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3191 nb_output_streams + 1);
3192 ost = &output_streams[nb_output_streams - 1];
3193 ost->file_index = nb_output_files;
3196 st->codec->codec_type = type;
3197 ost->enc = choose_codec(o, oc, st, type);
3199 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3202 avcodec_get_context_defaults3(st->codec, ost->enc);
3203 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3205 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3206 ost->max_frames = max_frames;
3208 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3210 if (next = strchr(bsf, ','))
3212 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3213 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter %s\n", bsf);
3217 bsfc_prev->next = bsfc;
3219 ost->bitstream_filters = bsfc;
3225 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3227 uint32_t tag = strtol(codec_tag, &next, 0);
3229 tag = AV_RL32(codec_tag);
3230 st->codec->codec_tag = tag;
3233 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3234 if (qscale >= 0 || same_quant) {
3235 st->codec->flags |= CODEC_FLAG_QSCALE;
3236 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3239 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3243 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3246 const char *p = str;
3253 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3260 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3264 AVCodecContext *video_enc;
3266 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3268 video_enc = st->codec;
3270 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3271 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3274 if (!st->stream_copy) {
3275 const char *p = NULL;
3276 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3277 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3278 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3279 int i, force_fps = 0, top_field_first = -1;
3281 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3282 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3283 av_log(NULL, AV_LOG_ERROR, "Invalid framerate value: %s\n", frame_rate);
3287 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3288 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3289 av_log(NULL, AV_LOG_ERROR, "Invalid frame size: %s.\n", frame_size);
3293 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3294 if (frame_aspect_ratio)
3295 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3297 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3298 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3299 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3300 av_log(NULL, AV_LOG_ERROR, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3303 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3306 video_enc->gop_size = 0;
3307 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3309 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3310 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for intra matrix.\n");
3313 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3315 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3317 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3318 av_log(NULL, AV_LOG_ERROR, "Could not allocate memory for inter matrix.\n");
3321 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3324 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3327 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3329 fprintf(stderr, "error parsing rc_override\n");
3332 video_enc->rc_override=
3333 av_realloc(video_enc->rc_override,
3334 sizeof(RcOverride)*(i+1));
3335 video_enc->rc_override[i].start_frame= start;
3336 video_enc->rc_override[i].end_frame = end;
3338 video_enc->rc_override[i].qscale= q;
3339 video_enc->rc_override[i].quality_factor= 1.0;
3342 video_enc->rc_override[i].qscale= 0;
3343 video_enc->rc_override[i].quality_factor= -q/100.0;
3348 video_enc->rc_override_count=i;
3349 if (!video_enc->rc_initial_buffer_occupancy)
3350 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3351 video_enc->intra_dc_precision= intra_dc_precision - 8;
3356 video_enc->flags |= CODEC_FLAG_PASS1;
3358 video_enc->flags |= CODEC_FLAG_PASS2;
3362 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3363 if (forced_key_frames)
3364 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3366 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3367 ost->force_fps = force_fps;
3369 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3370 ost->top_field_first = top_field_first;
3373 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3375 ost->avfilter = av_strdup(filters);
3382 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3386 AVCodecContext *audio_enc;
3388 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3391 audio_enc = st->codec;
3392 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3394 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3395 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3397 if (!st->stream_copy) {
3398 char *sample_fmt = NULL;
3400 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3402 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3404 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3405 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", sample_fmt);
3409 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3415 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3419 AVCodecContext *data_enc;
3421 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3423 data_enc = st->codec;
3424 if (!st->stream_copy) {
3425 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3429 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3430 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3436 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3440 AVCodecContext *subtitle_enc;
3442 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3444 subtitle_enc = st->codec;
3446 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3448 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3449 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3455 /* arg format is "output-stream-index:streamid-value". */
3456 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3462 av_strlcpy(idx_str, arg, sizeof(idx_str));
3463 p = strchr(idx_str, ':');
3466 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3471 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3472 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3473 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3477 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3479 AVFormatContext *is = ifile->ctx;
3480 AVFormatContext *os = ofile->ctx;
3483 for (i = 0; i < is->nb_chapters; i++) {
3484 AVChapter *in_ch = is->chapters[i], *out_ch;
3485 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3486 AV_TIME_BASE_Q, in_ch->time_base);
3487 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3488 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3491 if (in_ch->end < ts_off)
3493 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3496 out_ch = av_mallocz(sizeof(AVChapter));
3498 return AVERROR(ENOMEM);
3500 out_ch->id = in_ch->id;
3501 out_ch->time_base = in_ch->time_base;
3502 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3503 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3506 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3509 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3511 return AVERROR(ENOMEM);
3512 os->chapters[os->nb_chapters - 1] = out_ch;
3517 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3520 AVFormatContext *ic = NULL;
3522 err = avformat_open_input(&ic, filename, NULL, NULL);
3525 /* copy stream format */
3526 for(i=0;i<ic->nb_streams;i++) {
3531 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3532 ost = new_output_stream(o, s, codec->type);
3535 // FIXME: a more elegant solution is needed
3536 memcpy(st, ic->streams[i], sizeof(AVStream));
3537 st->info = av_malloc(sizeof(*st->info));
3538 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3539 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3541 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3542 choose_sample_fmt(st, codec);
3543 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3544 choose_pixel_fmt(st, codec);
3547 av_close_input_file(ic);
3551 static void opt_output_file(void *optctx, const char *filename)
3553 OptionsContext *o = optctx;
3554 AVFormatContext *oc;
3556 AVOutputFormat *file_oformat;
3560 if (!strcmp(filename, "-"))
3563 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3565 print_error(filename, err);
3568 file_oformat= oc->oformat;
3570 if (!strcmp(file_oformat->name, "ffm") &&
3571 av_strstart(filename, "http:", NULL)) {
3572 /* special case for files sent to ffserver: we get the stream
3573 parameters from ffserver */
3574 int err = read_ffserver_streams(o, oc, filename);
3576 print_error(filename, err);
3579 } else if (!o->nb_stream_maps) {
3580 /* pick the "best" stream of each type */
3581 #define NEW_STREAM(type, index)\
3583 ost = new_ ## type ## _stream(o, oc);\
3584 ost->source_index = index;\
3585 ost->sync_ist = &input_streams[index];\
3586 input_streams[index].discard = 0;\
3589 /* video: highest resolution */
3590 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3591 int area = 0, idx = -1;
3592 for (i = 0; i < nb_input_streams; i++) {
3593 ist = &input_streams[i];
3594 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3595 ist->st->codec->width * ist->st->codec->height > area) {
3596 area = ist->st->codec->width * ist->st->codec->height;
3600 NEW_STREAM(video, idx);
3603 /* audio: most channels */
3604 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3605 int channels = 0, idx = -1;
3606 for (i = 0; i < nb_input_streams; i++) {
3607 ist = &input_streams[i];
3608 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3609 ist->st->codec->channels > channels) {
3610 channels = ist->st->codec->channels;
3614 NEW_STREAM(audio, idx);
3617 /* subtitles: pick first */
3618 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3619 for (i = 0; i < nb_input_streams; i++)
3620 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3621 NEW_STREAM(subtitle, i);
3625 /* do something with data? */
3627 for (i = 0; i < o->nb_stream_maps; i++) {
3628 StreamMap *map = &o->stream_maps[i];
3633 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3634 switch (ist->st->codec->codec_type) {
3635 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3636 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3637 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3638 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3640 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3641 map->file_index, map->stream_index);
3645 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3646 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3647 map->sync_stream_index];
3652 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3653 output_files[nb_output_files - 1].ctx = oc;
3654 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3655 output_files[nb_output_files - 1].recording_time = o->recording_time;
3656 output_files[nb_output_files - 1].start_time = o->start_time;
3657 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3658 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3660 /* check filename in case of an image number is expected */
3661 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3662 if (!av_filename_number_test(oc->filename)) {
3663 print_error(oc->filename, AVERROR(EINVAL));
3668 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3669 /* test if it already exists to avoid loosing precious files */
3670 if (!file_overwrite &&
3671 (strchr(filename, ':') == NULL ||
3672 filename[1] == ':' ||
3673 av_strstart(filename, "file:", NULL))) {
3674 if (avio_check(filename, 0) == 0) {
3676 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3678 if (!read_yesno()) {
3679 fprintf(stderr, "Not overwriting - exiting\n");
3684 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3691 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3692 print_error(filename, err);
3697 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3698 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3700 if (loop_output >= 0) {
3701 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3702 oc->loop_output = loop_output;
3706 if (o->chapters_input_file >= nb_input_files) {
3707 if (o->chapters_input_file == INT_MAX) {
3708 /* copy chapters from the first input file that has them*/
3709 o->chapters_input_file = -1;
3710 for (i = 0; i < nb_input_files; i++)
3711 if (input_files[i].ctx->nb_chapters) {
3712 o->chapters_input_file = i;
3716 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3717 o->chapters_input_file);
3721 if (o->chapters_input_file >= 0)
3722 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3723 !o->metadata_chapters_manual);
3726 for (i = 0; i < o->nb_meta_data_maps; i++) {
3727 AVFormatContext *files[2];
3728 AVDictionary **meta[2];
3731 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3732 if ((index) < 0 || (index) >= (nb_elems)) {\
3733 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3738 int in_file_index = o->meta_data_maps[i][1].file;
3739 if (in_file_index < 0)
3741 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3744 files[1] = input_files[in_file_index].ctx;
3746 for (j = 0; j < 2; j++) {
3747 MetadataMap *map = &o->meta_data_maps[i][j];
3749 switch (map->type) {
3751 meta[j] = &files[j]->metadata;
3754 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3755 meta[j] = &files[j]->streams[map->index]->metadata;
3758 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3759 meta[j] = &files[j]->chapters[map->index]->metadata;
3762 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3763 meta[j] = &files[j]->programs[map->index]->metadata;
3768 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3771 /* copy global metadata by default */
3772 if (!o->metadata_global_manual && nb_input_files){
3773 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3774 AV_DICT_DONT_OVERWRITE);
3775 if(o->recording_time != INT64_MAX)
3776 av_dict_set(&oc->metadata, "duration", NULL, 0);
3778 if (!o->metadata_streams_manual)
3779 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3780 InputStream *ist = &input_streams[output_streams[i].source_index];
3781 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3784 /* process manually set metadata */
3785 for (i = 0; i < o->nb_metadata; i++) {
3790 val = strchr(o->metadata[i].u.str, '=');
3792 av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3793 o->metadata[i].u.str);
3798 parse_meta_type(o->metadata[i].specifier, &type, &index);
3804 if (index < 0 || index >= oc->nb_streams) {
3805 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3808 m = &oc->streams[index]->metadata;
3811 if (index < 0 || index >= oc->nb_chapters) {
3812 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3815 m = &oc->chapters[index]->metadata;
3818 av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3822 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3825 reset_options(o, 0);
3828 /* same option as mencoder */
3829 static int opt_pass(const char *opt, const char *arg)
3831 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3835 static int64_t getutime(void)
3838 struct rusage rusage;
3840 getrusage(RUSAGE_SELF, &rusage);
3841 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3842 #elif HAVE_GETPROCESSTIMES
3844 FILETIME c, e, k, u;
3845 proc = GetCurrentProcess();
3846 GetProcessTimes(proc, &c, &e, &k, &u);
3847 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3849 return av_gettime();
3853 static int64_t getmaxrss(void)
3855 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3856 struct rusage rusage;
3857 getrusage(RUSAGE_SELF, &rusage);
3858 return (int64_t)rusage.ru_maxrss * 1024;
3859 #elif HAVE_GETPROCESSMEMORYINFO
3861 PROCESS_MEMORY_COUNTERS memcounters;
3862 proc = GetCurrentProcess();
3863 memcounters.cb = sizeof(memcounters);
3864 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3865 return memcounters.PeakPagefileUsage;
3871 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3873 return parse_option(o, "q:a", arg, options);
3876 static void show_usage(void)
3878 printf("Hyper fast Audio and Video encoder\n");
3879 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3883 static int opt_help(const char *opt, const char *arg)
3886 AVOutputFormat *oformat = NULL;
3887 AVInputFormat *iformat = NULL;
3888 const AVClass *class;
3890 av_log_set_callback(log_callback_help);
3892 show_help_options(options, "Main options:\n",
3893 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3894 show_help_options(options, "\nAdvanced options:\n",
3895 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3897 show_help_options(options, "\nVideo options:\n",
3898 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3900 show_help_options(options, "\nAdvanced Video options:\n",
3901 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3902 OPT_VIDEO | OPT_EXPERT);
3903 show_help_options(options, "\nAudio options:\n",
3904 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3906 show_help_options(options, "\nAdvanced Audio options:\n",
3907 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3908 OPT_AUDIO | OPT_EXPERT);
3909 show_help_options(options, "\nSubtitle options:\n",
3910 OPT_SUBTITLE | OPT_GRAB,
3912 show_help_options(options, "\nAudio/Video grab options:\n",
3916 class = avcodec_get_class();
3917 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3920 /* individual codec options */
3922 while ((c = av_codec_next(c))) {
3923 if (c->priv_class) {
3924 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3929 class = avformat_get_class();
3930 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3933 /* individual muxer options */
3934 while ((oformat = av_oformat_next(oformat))) {
3935 if (oformat->priv_class) {
3936 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3941 /* individual demuxer options */
3942 while ((iformat = av_iformat_next(iformat))) {
3943 if (iformat->priv_class) {
3944 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3949 class = sws_get_class();
3950 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3954 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3956 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3957 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3959 if(!strncmp(arg, "pal-", 4)) {
3962 } else if(!strncmp(arg, "ntsc-", 5)) {
3965 } else if(!strncmp(arg, "film-", 5)) {
3969 /* Try to determine PAL/NTSC by peeking in the input files */
3970 if(nb_input_files) {
3972 for (j = 0; j < nb_input_files; j++) {
3973 for (i = 0; i < input_files[j].nb_streams; i++) {
3974 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3975 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3977 fr = c->time_base.den * 1000 / c->time_base.num;
3981 } else if((fr == 29970) || (fr == 23976)) {
3990 if(verbose > 0 && norm != UNKNOWN)
3991 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3994 if(norm == UNKNOWN) {
3995 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3996 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3997 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4001 if(!strcmp(arg, "vcd")) {
4002 opt_video_codec(o, "c:v", "mpeg1video");
4003 opt_audio_codec(o, "c:a", "mp2");
4004 parse_option(o, "f", "vcd", options);
4006 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4007 parse_option(o, "r", frame_rates[norm], options);
4008 opt_default("g", norm == PAL ? "15" : "18");
4010 opt_default("b", "1150000");
4011 opt_default("maxrate", "1150000");
4012 opt_default("minrate", "1150000");
4013 opt_default("bufsize", "327680"); // 40*1024*8;
4015 opt_default("b:a", "224000");
4016 parse_option(o, "ar", "44100", options);
4017 parse_option(o, "ac", "2", options);
4019 opt_default("packetsize", "2324");
4020 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4022 /* We have to offset the PTS, so that it is consistent with the SCR.
4023 SCR starts at 36000, but the first two packs contain only padding
4024 and the first pack from the other stream, respectively, may also have
4025 been written before.
4026 So the real data starts at SCR 36000+3*1200. */
4027 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4028 } else if(!strcmp(arg, "svcd")) {
4030 opt_video_codec(o, "c:v", "mpeg2video");
4031 opt_audio_codec(o, "c:a", "mp2");
4032 parse_option(o, "f", "svcd", options);
4034 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4035 parse_option(o, "r", frame_rates[norm], options);
4036 parse_option(o, "pix_fmt", "yuv420p", options);
4037 opt_default("g", norm == PAL ? "15" : "18");
4039 opt_default("b", "2040000");
4040 opt_default("maxrate", "2516000");
4041 opt_default("minrate", "0"); //1145000;
4042 opt_default("bufsize", "1835008"); //224*1024*8;
4043 opt_default("flags", "+scan_offset");
4046 opt_default("b:a", "224000");
4047 parse_option(o, "ar", "44100", options);
4049 opt_default("packetsize", "2324");
4051 } else if(!strcmp(arg, "dvd")) {
4053 opt_video_codec(o, "c:v", "mpeg2video");
4054 opt_audio_codec(o, "c:a", "ac3");
4055 parse_option(o, "f", "dvd", options);
4057 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4058 parse_option(o, "r", frame_rates[norm], options);
4059 parse_option(o, "pix_fmt", "yuv420p", options);
4060 opt_default("g", norm == PAL ? "15" : "18");
4062 opt_default("b", "6000000");
4063 opt_default("maxrate", "9000000");
4064 opt_default("minrate", "0"); //1500000;
4065 opt_default("bufsize", "1835008"); //224*1024*8;
4067 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4068 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4070 opt_default("b:a", "448000");
4071 parse_option(o, "ar", "48000", options);
4073 } else if(!strncmp(arg, "dv", 2)) {
4075 parse_option(o, "f", "dv", options);
4077 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4078 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4079 norm == PAL ? "yuv420p" : "yuv411p", options);
4080 parse_option(o, "r", frame_rates[norm], options);
4082 parse_option(o, "ar", "48000", options);
4083 parse_option(o, "ac", "2", options);
4086 fprintf(stderr, "Unknown target: %s\n", arg);
4087 return AVERROR(EINVAL);
4092 static int opt_vstats_file(const char *opt, const char *arg)
4094 av_free (vstats_filename);
4095 vstats_filename=av_strdup (arg);
4099 static int opt_vstats(const char *opt, const char *arg)
4102 time_t today2 = time(NULL);
4103 struct tm *today = localtime(&today2);
4105 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4107 return opt_vstats_file(opt, filename);
4110 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4112 return parse_option(o, "frames:v", arg, options);
4115 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4117 return parse_option(o, "frames:a", arg, options);
4120 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4122 return parse_option(o, "frames:d", arg, options);
4125 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4128 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4129 const char *codec_name = *opt == 'v' ? video_codec_name :
4130 *opt == 'a' ? audio_codec_name :
4131 subtitle_codec_name;
4133 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4134 fprintf(stderr, "File for preset '%s' not found\n", arg);
4139 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4140 if(line[0] == '#' && !e)
4142 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4144 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4147 if(!strcmp(tmp, "acodec")){
4148 opt_audio_codec(o, tmp, tmp2);
4149 }else if(!strcmp(tmp, "vcodec")){
4150 opt_video_codec(o, tmp, tmp2);
4151 }else if(!strcmp(tmp, "scodec")){
4152 opt_subtitle_codec(o, tmp, tmp2);
4153 }else if(!strcmp(tmp, "dcodec")){
4154 opt_data_codec(o, tmp, tmp2);
4155 }else if(opt_default(tmp, tmp2) < 0){
4156 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4166 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4170 static int opt_passlogfile(const char *opt, const char *arg)
4172 pass_logfilename_prefix = arg;
4173 #if CONFIG_LIBX264_ENCODER
4174 return opt_default("passlogfile", arg);
4180 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4182 char *s= av_malloc(strlen(opt)+2);
4183 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4184 return parse_option(o, s, arg, options);
4187 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4189 return parse_option(o, "filter:v", arg, options);
4192 #define OFFSET(x) offsetof(OptionsContext, x)
4193 static const OptionDef options[] = {
4195 #include "cmdutils_common_opts.h"
4196 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4197 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4198 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4199 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4200 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4201 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4202 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4203 "outfile[,metadata]:infile[,metadata]" },
4204 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4205 "outfile[,metadata]:infile[,metadata]" },
4206 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4207 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4208 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4209 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4210 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4211 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4212 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4213 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4214 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4215 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4216 "add timings for benchmarking" },
4217 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4218 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4219 "dump each input packet" },
4220 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4221 "when dumping packets, also dump the payload" },
4222 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4223 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4224 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4225 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4226 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4227 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4228 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4229 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4230 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4231 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4232 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4233 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4234 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4235 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4236 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4237 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4238 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4239 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4241 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4245 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4246 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4247 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4248 { "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" },
4249 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4250 { "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" },
4251 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4252 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4253 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4254 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4255 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4256 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4257 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4258 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4259 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4260 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4261 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4262 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4263 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4264 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4265 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4266 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4267 "use same quantizer as source (implies VBR)" },
4268 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4269 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4270 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4271 "deinterlace pictures" },
4272 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4273 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4275 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4277 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4278 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4279 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4280 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4281 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4282 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4283 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4284 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4285 { "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" },
4288 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4289 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4290 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4291 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4292 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4293 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4294 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4295 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4296 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4298 /* subtitle options */
4299 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4300 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4301 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4304 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4305 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4306 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4309 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4310 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4312 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4313 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4314 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4316 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4317 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4318 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4319 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4320 /* data codec support */
4321 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4323 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4327 int main(int argc, char **argv)
4329 OptionsContext o = { 0 };
4332 reset_options(&o, 0);
4334 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4336 if(argc>1 && !strcmp(argv[1], "-d")){
4339 av_log_set_callback(log_callback_null);
4344 avcodec_register_all();
4346 avdevice_register_all();
4349 avfilter_register_all();
4354 if(isatty(STDIN_FILENO))
4355 avio_set_interrupt_cb(decode_interrupt_cb);
4362 parse_options(&o, argc, argv, options, opt_output_file);
4364 if(nb_output_files <= 0 && nb_input_files == 0) {
4366 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4370 /* file converter / grab */
4371 if (nb_output_files <= 0) {
4372 fprintf(stderr, "At least one output file must be specified\n");
4376 if (nb_input_files == 0) {
4377 fprintf(stderr, "At least one input file must be specified\n");
4382 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4384 ti = getutime() - ti;
4386 int maxrss = getmaxrss() / 1024;
4387 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);