3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
48 #include "libswresample/swresample.h"
50 #include "libavformat/ffm.h" // not public API
53 # include "libavfilter/avcodec.h"
54 # include "libavfilter/avfilter.h"
55 # include "libavfilter/avfiltergraph.h"
56 # include "libavfilter/buffersink.h"
57 # include "libavfilter/vsrc_buffer.h"
60 #if HAVE_SYS_RESOURCE_H
61 #include <sys/types.h>
63 #include <sys/resource.h>
64 #elif HAVE_GETPROCESSTIMES
67 #if HAVE_GETPROCESSMEMORYINFO
73 #include <sys/select.h>
78 #include <sys/ioctl.h>
88 #include "libavutil/avassert.h"
90 const char program_name[] = "ffmpeg";
91 const int program_birth_year = 2000;
93 /* select an input stream for an output stream */
94 typedef struct StreamMap {
95 int disabled; /** 1 is this mapping is disabled by a negative map */
99 int sync_stream_index;
103 * select an input file for an output file
105 typedef struct MetadataMap {
106 int file; ///< file index
107 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
108 int index; ///< stream/chapter/program number
111 static const OptionDef options[];
113 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
115 static int frame_bits_per_raw_sample = 0;
116 static int video_discard = 0;
117 static int same_quant = 0;
118 static int do_deinterlace = 0;
119 static int intra_dc_precision = 8;
120 static int loop_input = 0;
121 static int loop_output = AVFMT_NOOUTPUTLOOP;
122 static int qp_hist = 0;
123 static int intra_only = 0;
124 static const char *video_codec_name = NULL;
125 static const char *audio_codec_name = NULL;
126 static const char *subtitle_codec_name = NULL;
128 static int file_overwrite = 0;
129 static int do_benchmark = 0;
130 static int do_hex_dump = 0;
131 static int do_pkt_dump = 0;
132 static int do_pass = 0;
133 static const char *pass_logfilename_prefix;
134 static int video_sync_method= -1;
135 static int audio_sync_method= 0;
136 static float audio_drift_threshold= 0.1;
137 static int copy_ts= 0;
138 static int copy_tb= 0;
139 static int opt_shortest = 0;
140 static char *vstats_filename;
141 static FILE *vstats_file;
142 static int copy_initial_nonkeyframes = 0;
144 static int audio_volume = 256;
146 static int exit_on_error = 0;
147 static int using_stdin = 0;
148 static int 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 int resample_sample_fmt;
233 int resample_channels;
234 int resample_sample_rate;
235 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
238 struct SwrContext *swr;
241 AVFilterContext *output_video_filter;
242 AVFilterContext *input_video_filter;
243 AVFilterBufferRef *picref;
245 AVFilterGraph *graph;
250 int is_past_recording_time;
256 /* init terminal so that we can grab keys */
257 static struct termios oldtty;
260 typedef struct OutputFile {
261 AVFormatContext *ctx;
263 int ost_index; /* index of the first stream in output_streams */
264 int64_t recording_time; /* desired length of the resulting file in microseconds */
265 int64_t start_time; /* start time in microseconds */
266 uint64_t limit_filesize;
269 static InputStream *input_streams = NULL;
270 static int nb_input_streams = 0;
271 static InputFile *input_files = NULL;
272 static int nb_input_files = 0;
274 static OutputStream *output_streams = NULL;
275 static int nb_output_streams = 0;
276 static OutputFile *output_files = NULL;
277 static int nb_output_files = 0;
279 typedef struct OptionsContext {
280 /* input/output options */
284 SpecifierOpt *codec_names;
286 SpecifierOpt *audio_channels;
287 int nb_audio_channels;
288 SpecifierOpt *audio_sample_rate;
289 int nb_audio_sample_rate;
290 SpecifierOpt *frame_rates;
292 SpecifierOpt *frame_sizes;
294 SpecifierOpt *frame_pix_fmts;
295 int nb_frame_pix_fmts;
298 int64_t input_ts_offset;
301 SpecifierOpt *ts_scale;
305 StreamMap *stream_maps;
307 /* first item specifies output metadata, second is input */
308 MetadataMap (*meta_data_maps)[2];
309 int nb_meta_data_maps;
310 int metadata_global_manual;
311 int metadata_streams_manual;
312 int metadata_chapters_manual;
314 int chapters_input_file;
316 int64_t recording_time;
317 uint64_t limit_filesize;
323 int subtitle_disable;
326 /* indexed by output file stream index */
330 SpecifierOpt *metadata;
332 SpecifierOpt *max_frames;
334 SpecifierOpt *bitstream_filters;
335 int nb_bitstream_filters;
336 SpecifierOpt *codec_tags;
338 SpecifierOpt *sample_fmts;
340 SpecifierOpt *qscale;
342 SpecifierOpt *forced_key_frames;
343 int nb_forced_key_frames;
344 SpecifierOpt *force_fps;
346 SpecifierOpt *frame_aspect_ratios;
347 int nb_frame_aspect_ratios;
348 SpecifierOpt *rc_overrides;
350 SpecifierOpt *intra_matrices;
351 int nb_intra_matrices;
352 SpecifierOpt *inter_matrices;
353 int nb_inter_matrices;
354 SpecifierOpt *top_field_first;
355 int nb_top_field_first;
357 SpecifierOpt *filters;
362 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
365 for (i = 0; i < o->nb_ ## name; i++) {\
366 char *spec = o->name[i].specifier;\
367 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
368 outvar = o->name[i].u.type;\
374 static void reset_options(OptionsContext *o, int is_input)
376 const OptionDef *po = options;
377 OptionsContext bak= *o;
379 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
381 void *dst = (uint8_t*)o + po->u.off;
383 if (po->flags & OPT_SPEC) {
384 SpecifierOpt **so = dst;
385 int i, *count = (int*)(so + 1);
386 for (i = 0; i < *count; i++) {
387 av_freep(&(*so)[i].specifier);
388 if (po->flags & OPT_STRING)
389 av_freep(&(*so)[i].u.str);
393 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
398 av_freep(&o->stream_maps);
399 av_freep(&o->meta_data_maps);
400 av_freep(&o->streamid_map);
402 memset(o, 0, sizeof(*o));
404 if(is_input) o->recording_time = bak.recording_time;
405 else o->recording_time = INT64_MAX;
406 o->mux_preload = 0.5;
407 o->mux_max_delay = 0.7;
408 o->limit_filesize = UINT64_MAX;
409 o->chapters_input_file = INT_MAX;
417 static int configure_video_filters(InputStream *ist, OutputStream *ost)
419 AVFilterContext *last_filter, *filter;
420 /** filter graph containing all filters including input & output */
421 AVCodecContext *codec = ost->st->codec;
422 AVCodecContext *icodec = ist->st->codec;
423 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
424 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
425 AVRational sample_aspect_ratio;
429 ost->graph = avfilter_graph_alloc();
431 if (ist->st->sample_aspect_ratio.num){
432 sample_aspect_ratio = ist->st->sample_aspect_ratio;
434 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
436 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
437 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
438 sample_aspect_ratio.num, sample_aspect_ratio.den);
440 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
441 "src", args, NULL, ost->graph);
444 #if FF_API_OLD_VSINK_API
445 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
446 "out", NULL, pix_fmts, ost->graph);
448 buffersink_params->pixel_fmts = pix_fmts;
449 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
450 "out", NULL, buffersink_params, ost->graph);
452 av_freep(&buffersink_params);
455 last_filter = ost->input_video_filter;
457 if (codec->width != icodec->width || codec->height != icodec->height) {
458 snprintf(args, 255, "%d:%d:flags=0x%X",
462 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
463 NULL, args, NULL, ost->graph)) < 0)
465 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
467 last_filter = filter;
470 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
471 ost->graph->scale_sws_opts = av_strdup(args);
474 AVFilterInOut *outputs = avfilter_inout_alloc();
475 AVFilterInOut *inputs = avfilter_inout_alloc();
477 outputs->name = av_strdup("in");
478 outputs->filter_ctx = last_filter;
479 outputs->pad_idx = 0;
480 outputs->next = NULL;
482 inputs->name = av_strdup("out");
483 inputs->filter_ctx = ost->output_video_filter;
487 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
489 av_freep(&ost->avfilter);
491 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
495 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
498 codec->width = ost->output_video_filter->inputs[0]->w;
499 codec->height = ost->output_video_filter->inputs[0]->h;
500 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
501 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
502 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
503 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
507 #endif /* CONFIG_AVFILTER */
509 static void term_exit(void)
511 av_log(NULL, AV_LOG_QUIET, "%s", "");
514 tcsetattr (0, TCSANOW, &oldtty);
518 static volatile int received_sigterm = 0;
520 static void sigterm_handler(int sig)
522 received_sigterm = sig;
527 static void term_init(void)
537 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
538 |INLCR|IGNCR|ICRNL|IXON);
539 tty.c_oflag |= OPOST;
540 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
541 tty.c_cflag &= ~(CSIZE|PARENB);
546 tcsetattr (0, TCSANOW, &tty);
547 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
551 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
552 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
554 signal(SIGXCPU, sigterm_handler);
558 /* read a key without blocking */
559 static int read_key(void)
574 n = select(1, &rfds, NULL, NULL, &tv);
583 # if HAVE_PEEKNAMEDPIPE
585 static HANDLE input_handle;
588 input_handle = GetStdHandle(STD_INPUT_HANDLE);
589 is_pipe = !GetConsoleMode(input_handle, &dw);
592 if (stdin->_cnt > 0) {
597 /* When running under a GUI, you will end here. */
598 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
615 static int decode_interrupt_cb(void)
617 q_pressed += read_key() == 'q';
618 return q_pressed > 1;
621 void exit_program(int ret)
626 for(i=0;i<nb_output_files;i++) {
627 AVFormatContext *s = output_files[i].ctx;
628 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
630 avformat_free_context(s);
631 av_dict_free(&output_files[i].opts);
633 for(i=0;i<nb_input_files;i++) {
634 av_close_input_file(input_files[i].ctx);
636 for (i = 0; i < nb_input_streams; i++)
637 av_dict_free(&input_streams[i].opts);
641 av_free(vstats_filename);
643 av_freep(&input_streams);
644 av_freep(&input_files);
645 av_freep(&output_streams);
646 av_freep(&output_files);
651 allocated_audio_buf_size= allocated_audio_out_size= 0;
658 av_freep(&input_tmp);
660 if (received_sigterm) {
661 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
662 (int) received_sigterm);
666 exit(ret); /* not all OS-es handle main() return value */
669 static void assert_avoptions(AVDictionary *m)
671 AVDictionaryEntry *t;
672 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
673 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
678 static void assert_codec_experimental(AVCodecContext *c, int encoder)
680 const char *codec_string = encoder ? "encoder" : "decoder";
682 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
683 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
684 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
685 "results.\nAdd '-strict experimental' if you want to use it.\n",
686 codec_string, c->codec->name);
687 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
688 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
689 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
690 codec_string, codec->name);
695 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
697 if(codec && codec->sample_fmts){
698 const enum AVSampleFormat *p= codec->sample_fmts;
700 if(*p == st->codec->sample_fmt)
704 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
705 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
706 if(av_get_sample_fmt_name(st->codec->sample_fmt))
707 av_log(NULL, AV_LOG_WARNING,
708 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
709 av_get_sample_fmt_name(st->codec->sample_fmt),
711 av_get_sample_fmt_name(codec->sample_fmts[0]));
712 st->codec->sample_fmt = codec->sample_fmts[0];
717 static void choose_sample_rate(AVStream *st, AVCodec *codec)
719 if(codec && codec->supported_samplerates){
720 const int *p= codec->supported_samplerates;
722 int best_dist=INT_MAX;
724 int dist= abs(st->codec->sample_rate - *p);
725 if(dist < best_dist){
731 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
733 st->codec->sample_rate= best;
737 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
739 if(codec && codec->pix_fmts){
740 const enum PixelFormat *p= codec->pix_fmts;
741 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
742 if(st->codec->codec_id==CODEC_ID_MJPEG){
743 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
744 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
745 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};
749 if(*p == st->codec->pix_fmt)
753 if(st->codec->pix_fmt != PIX_FMT_NONE)
754 av_log(NULL, AV_LOG_WARNING,
755 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
756 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
758 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
759 st->codec->pix_fmt = codec->pix_fmts[0];
764 static double get_sync_ipts(const OutputStream *ost)
766 const InputStream *ist = ost->sync_ist;
767 OutputFile *of = &output_files[ost->file_index];
768 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
771 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
776 AVPacket new_pkt= *pkt;
777 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
778 &new_pkt.data, &new_pkt.size,
779 pkt->data, pkt->size,
780 pkt->flags & AV_PKT_FLAG_KEY);
783 new_pkt.destruct= av_destruct_packet;
785 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
786 bsfc->filter->name, pkt->stream_index,
787 avctx->codec ? avctx->codec->name : "copy");
797 ret= av_interleaved_write_frame(s, pkt);
799 print_error("av_interleaved_write_frame()", ret);
804 static void do_audio_out(AVFormatContext *s,
807 unsigned char *buf, int size)
810 int64_t audio_out_size, audio_buf_size;
811 int64_t allocated_for_size= size;
813 int size_out, frame_bytes, ret, resample_changed;
814 AVCodecContext *enc= ost->st->codec;
815 AVCodecContext *dec= ist->st->codec;
816 int osize = av_get_bytes_per_sample(enc->sample_fmt);
817 int isize = av_get_bytes_per_sample(dec->sample_fmt);
818 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
821 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
822 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
823 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
824 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
825 audio_buf_size*= osize*enc->channels;
827 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
828 if(coded_bps > 8*osize)
829 audio_out_size= audio_out_size * coded_bps / (8*osize);
830 audio_out_size += FF_MIN_BUFFER_SIZE;
832 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
833 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
837 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
838 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
839 if (!audio_buf || !audio_out){
840 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
844 if (enc->channels != dec->channels
845 || enc->sample_fmt != dec->sample_fmt)
846 ost->audio_resample = 1;
848 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
849 ost->resample_channels != dec->channels ||
850 ost->resample_sample_rate != dec->sample_rate;
852 if ((ost->audio_resample && !ost->swr) || resample_changed) {
853 if (resample_changed) {
854 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",
855 ist->file_index, ist->st->index,
856 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
857 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
858 ost->resample_sample_fmt = dec->sample_fmt;
859 ost->resample_channels = dec->channels;
860 ost->resample_sample_rate = dec->sample_rate;
863 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
864 if (audio_sync_method <= 1 &&
865 ost->resample_sample_fmt == enc->sample_fmt &&
866 ost->resample_channels == enc->channels &&
867 ost->resample_sample_rate == enc->sample_rate) {
869 ost->audio_resample = 0;
871 ost->swr = swr_alloc2(ost->swr,
872 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
873 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
875 av_set_int(ost->swr, "ich", dec->channels);
876 av_set_int(ost->swr, "och", enc->channels);
877 if(audio_sync_method>1) av_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE);
878 if(ost->swr && swr_init(ost->swr) < 0){
879 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
884 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
885 dec->channels, dec->sample_rate,
886 enc->channels, enc->sample_rate);
892 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
894 if(audio_sync_method){
895 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
896 - av_fifo_size(ost->fifo)/(enc->channels * 2);
897 double idelta= delta*dec->sample_rate / enc->sample_rate;
898 int byte_delta= ((int)idelta)*2*dec->channels;
900 //FIXME resample delay
901 if(fabs(delta) > 50){
902 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
904 byte_delta= FFMAX(byte_delta, -size);
907 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
912 input_tmp= av_realloc(input_tmp, byte_delta + size);
914 if(byte_delta > allocated_for_size - size){
915 allocated_for_size= byte_delta + (int64_t)size;
920 memset(input_tmp, 0, byte_delta);
921 memcpy(input_tmp + byte_delta, buf, size);
924 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
926 }else if(audio_sync_method>1){
927 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
928 av_assert0(ost->audio_resample);
929 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
930 delta, comp, enc->sample_rate);
931 // 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));
932 swr_compensate(ost->swr, comp, enc->sample_rate);
936 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
937 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
939 if (ost->audio_resample) {
941 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
942 (const uint8_t*[]){buf }, size / (dec->channels * isize));
943 size_out = size_out * enc->channels * osize;
949 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
951 /* now encode as many frames as possible */
952 if (enc->frame_size > 1) {
953 /* output resampled raw samples */
954 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
955 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
958 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
960 frame_bytes = enc->frame_size * osize * enc->channels;
962 while (av_fifo_size(ost->fifo) >= frame_bytes) {
964 av_init_packet(&pkt);
966 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
968 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
970 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
973 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
977 pkt.stream_index= ost->index;
980 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
981 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
982 pkt.flags |= AV_PKT_FLAG_KEY;
983 write_frame(s, &pkt, enc, ost->bitstream_filters);
985 ost->sync_opts += enc->frame_size;
989 av_init_packet(&pkt);
991 ost->sync_opts += size_out / (osize * enc->channels);
993 /* output a pcm frame */
994 /* determine the size of the coded buffer */
997 size_out = size_out*coded_bps/8;
999 if(size_out > audio_out_size){
1000 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1004 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1005 ret = avcodec_encode_audio(enc, audio_out, size_out,
1008 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1012 pkt.stream_index= ost->index;
1013 pkt.data= audio_out;
1015 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1016 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1017 pkt.flags |= AV_PKT_FLAG_KEY;
1018 write_frame(s, &pkt, enc, ost->bitstream_filters);
1022 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1024 AVCodecContext *dec;
1025 AVPicture *picture2;
1026 AVPicture picture_tmp;
1029 dec = ist->st->codec;
1031 /* deinterlace : must be done before any resize */
1032 if (do_deinterlace) {
1035 /* create temporary picture */
1036 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1037 buf = av_malloc(size);
1041 picture2 = &picture_tmp;
1042 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1044 if(avpicture_deinterlace(picture2, picture,
1045 dec->pix_fmt, dec->width, dec->height) < 0) {
1046 /* if error, do not deinterlace */
1047 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1056 if (picture != picture2)
1057 *picture = *picture2;
1061 static void do_subtitle_out(AVFormatContext *s,
1067 static uint8_t *subtitle_out = NULL;
1068 int subtitle_out_max_size = 1024 * 1024;
1069 int subtitle_out_size, nb, i;
1070 AVCodecContext *enc;
1073 if (pts == AV_NOPTS_VALUE) {
1074 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1080 enc = ost->st->codec;
1082 if (!subtitle_out) {
1083 subtitle_out = av_malloc(subtitle_out_max_size);
1086 /* Note: DVB subtitle need one packet to draw them and one other
1087 packet to clear them */
1088 /* XXX: signal it in the codec context ? */
1089 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1094 for(i = 0; i < nb; i++) {
1095 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1096 // start_display_time is required to be 0
1097 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1098 sub->end_display_time -= sub->start_display_time;
1099 sub->start_display_time = 0;
1100 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1101 subtitle_out_max_size, sub);
1102 if (subtitle_out_size < 0) {
1103 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1107 av_init_packet(&pkt);
1108 pkt.stream_index = ost->index;
1109 pkt.data = subtitle_out;
1110 pkt.size = subtitle_out_size;
1111 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1112 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1113 /* XXX: the pts correction is handled here. Maybe handling
1114 it in the codec would be better */
1116 pkt.pts += 90 * sub->start_display_time;
1118 pkt.pts += 90 * sub->end_display_time;
1120 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1124 static int bit_buffer_size= 1024*256;
1125 static uint8_t *bit_buffer= NULL;
1127 static void do_video_resample(OutputStream *ost,
1129 AVFrame *in_picture,
1130 AVFrame **out_picture)
1133 *out_picture = in_picture;
1135 AVCodecContext *dec = ist->st->codec;
1136 AVCodecContext *enc = ost->st->codec;
1137 int resample_changed = ost->resample_width != dec->width ||
1138 ost->resample_height != dec->height ||
1139 ost->resample_pix_fmt != dec->pix_fmt;
1141 *out_picture = in_picture;
1142 if (resample_changed) {
1143 av_log(NULL, AV_LOG_INFO,
1144 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1145 ist->file_index, ist->st->index,
1146 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1147 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1148 ost->resample_width = dec->width;
1149 ost->resample_height = dec->height;
1150 ost->resample_pix_fmt = dec->pix_fmt;
1153 ost->video_resample = dec->width != enc->width ||
1154 dec->height != enc->height ||
1155 dec->pix_fmt != enc->pix_fmt;
1157 if (ost->video_resample) {
1158 *out_picture = &ost->resample_frame;
1159 if (!ost->img_resample_ctx || resample_changed) {
1160 /* initialize the destination picture */
1161 if (!ost->resample_frame.data[0]) {
1162 avcodec_get_frame_defaults(&ost->resample_frame);
1163 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1164 enc->width, enc->height)) {
1165 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1169 /* initialize a new scaler context */
1170 sws_freeContext(ost->img_resample_ctx);
1171 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1172 enc->width, enc->height, enc->pix_fmt,
1173 ost->sws_flags, NULL, NULL, NULL);
1174 if (ost->img_resample_ctx == NULL) {
1175 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1179 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1180 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1186 static void do_video_out(AVFormatContext *s,
1189 AVFrame *in_picture,
1190 int *frame_size, float quality)
1192 int nb_frames, i, ret, format_video_sync;
1193 AVFrame *final_picture;
1194 AVCodecContext *enc;
1196 double duration = 0;
1198 enc = ost->st->codec;
1200 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1201 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1202 if(ist->st->avg_frame_rate.num)
1203 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1205 duration /= av_q2d(enc->time_base);
1208 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1210 /* by default, we output a single frame */
1215 format_video_sync = video_sync_method;
1216 if (format_video_sync < 0)
1217 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1219 if (format_video_sync) {
1220 double vdelta = sync_ipts - ost->sync_opts + duration;
1221 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1224 else if (format_video_sync == 2) {
1227 }else if(vdelta>0.6)
1228 ost->sync_opts= lrintf(sync_ipts);
1229 }else if (vdelta > 1.1)
1230 nb_frames = lrintf(vdelta);
1231 //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);
1232 if (nb_frames == 0){
1234 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1235 }else if (nb_frames > 1) {
1236 nb_frames_dup += nb_frames - 1;
1237 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1240 ost->sync_opts= lrintf(sync_ipts);
1242 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1246 do_video_resample(ost, ist, in_picture, &final_picture);
1248 /* duplicates frame if needed */
1249 for(i=0;i<nb_frames;i++) {
1251 av_init_packet(&pkt);
1252 pkt.stream_index= ost->index;
1254 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1255 /* raw pictures are written as AVPicture structure to
1256 avoid any copies. We support temporarily the older
1258 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1259 enc->coded_frame->top_field_first = in_picture->top_field_first;
1260 pkt.data= (uint8_t *)final_picture;
1261 pkt.size= sizeof(AVPicture);
1262 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1263 pkt.flags |= AV_PKT_FLAG_KEY;
1265 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1267 AVFrame big_picture;
1269 big_picture= *final_picture;
1270 /* better than nothing: use input picture interlaced
1272 big_picture.interlaced_frame = in_picture->interlaced_frame;
1273 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1274 if (ost->top_field_first == -1)
1275 big_picture.top_field_first = in_picture->top_field_first;
1277 big_picture.top_field_first = !!ost->top_field_first;
1280 /* handles same_quant here. This is not correct because it may
1281 not be a global option */
1282 big_picture.quality = quality;
1283 if (!enc->me_threshold)
1284 big_picture.pict_type = 0;
1285 // big_picture.pts = AV_NOPTS_VALUE;
1286 big_picture.pts= ost->sync_opts;
1287 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1288 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1289 if (ost->forced_kf_index < ost->forced_kf_count &&
1290 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1291 big_picture.pict_type = AV_PICTURE_TYPE_I;
1292 ost->forced_kf_index++;
1294 ret = avcodec_encode_video(enc,
1295 bit_buffer, bit_buffer_size,
1298 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1303 pkt.data= bit_buffer;
1305 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1306 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1307 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1308 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1309 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1311 if(enc->coded_frame->key_frame)
1312 pkt.flags |= AV_PKT_FLAG_KEY;
1313 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1316 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1317 // enc->frame_number-1, ret, enc->pict_type);
1318 /* if two pass, output log */
1319 if (ost->logfile && enc->stats_out) {
1320 fprintf(ost->logfile, "%s", enc->stats_out);
1325 ost->frame_number++;
1329 static double psnr(double d)
1331 return -10.0*log(d)/log(10.0);
1334 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1337 AVCodecContext *enc;
1339 double ti1, bitrate, avg_bitrate;
1341 /* this is executed just the first time do_video_stats is called */
1343 vstats_file = fopen(vstats_filename, "w");
1350 enc = ost->st->codec;
1351 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1352 frame_number = ost->frame_number;
1353 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1354 if (enc->flags&CODEC_FLAG_PSNR)
1355 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1357 fprintf(vstats_file,"f_size= %6d ", frame_size);
1358 /* compute pts value */
1359 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1363 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1364 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1365 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1366 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1367 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1371 static void print_report(OutputFile *output_files,
1372 OutputStream *ost_table, int nb_ostreams,
1373 int is_last_report, int64_t timer_start)
1377 AVFormatContext *oc;
1379 AVCodecContext *enc;
1380 int frame_number, vid, i;
1382 int64_t pts = INT64_MAX;
1383 static int64_t last_time = -1;
1384 static int qp_histogram[52];
1385 int hours, mins, secs, us;
1387 if (!is_last_report) {
1389 /* display the report every 0.5 seconds */
1390 cur_time = av_gettime();
1391 if (last_time == -1) {
1392 last_time = cur_time;
1395 if ((cur_time - last_time) < 500000)
1397 last_time = cur_time;
1401 oc = output_files[0].ctx;
1403 total_size = avio_size(oc->pb);
1404 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1405 total_size= avio_tell(oc->pb);
1409 for(i=0;i<nb_ostreams;i++) {
1411 ost = &ost_table[i];
1412 enc = ost->st->codec;
1413 if (!ost->st->stream_copy && enc->coded_frame)
1414 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1415 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1416 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1418 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1419 float t = (av_gettime()-timer_start) / 1000000.0;
1421 frame_number = ost->frame_number;
1422 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1423 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1425 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1429 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1432 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1434 if (enc->flags&CODEC_FLAG_PSNR){
1436 double error, error_sum=0;
1437 double scale, scale_sum=0;
1438 char type[3]= {'Y','U','V'};
1439 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1442 error= enc->error[j];
1443 scale= enc->width*enc->height*255.0*255.0*frame_number;
1445 error= enc->coded_frame->error[j];
1446 scale= enc->width*enc->height*255.0*255.0;
1451 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1453 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1457 /* compute min output value */
1458 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1459 ost->st->time_base, AV_TIME_BASE_Q));
1462 secs = pts / AV_TIME_BASE;
1463 us = pts % AV_TIME_BASE;
1469 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1471 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1472 "size=%8.0fkB time=", total_size / 1024.0);
1473 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1474 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1475 (100 * us) / AV_TIME_BASE);
1476 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1477 "bitrate=%6.1fkbits/s", bitrate);
1479 if (nb_frames_dup || nb_frames_drop)
1480 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1481 nb_frames_dup, nb_frames_drop);
1483 av_log(NULL, is_last_report ? AV_LOG_WARNING : AV_LOG_INFO, "%s \r", buf);
1487 if (is_last_report) {
1488 int64_t raw= audio_size + video_size + extra_size;
1489 av_log(NULL, AV_LOG_INFO, "\n");
1490 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1494 100.0*(total_size - raw)/raw
1499 static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
1501 int fill_char = 0x00;
1502 if (sample_fmt == AV_SAMPLE_FMT_U8)
1504 memset(buf, fill_char, size);
1507 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1511 for (i = 0; i < nb_ostreams; i++) {
1512 OutputStream *ost = &ost_table[i];
1513 AVCodecContext *enc = ost->st->codec;
1514 AVFormatContext *os = output_files[ost->file_index].ctx;
1516 if (!ost->encoding_needed)
1519 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1521 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1527 av_init_packet(&pkt);
1528 pkt.stream_index= ost->index;
1530 switch (ost->st->codec->codec_type) {
1531 case AVMEDIA_TYPE_AUDIO:
1532 fifo_bytes = av_fifo_size(ost->fifo);
1534 /* encode any samples remaining in fifo */
1535 if (fifo_bytes > 0) {
1536 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1537 int fs_tmp = enc->frame_size;
1539 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1540 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1541 enc->frame_size = fifo_bytes / (osize * enc->channels);
1543 int frame_bytes = enc->frame_size*osize*enc->channels;
1544 if (allocated_audio_buf_size < frame_bytes)
1546 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1549 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1550 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1551 ost->st->time_base.num, enc->sample_rate);
1552 enc->frame_size = fs_tmp;
1555 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1558 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1562 pkt.flags |= AV_PKT_FLAG_KEY;
1564 case AVMEDIA_TYPE_VIDEO:
1565 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1567 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1571 if(enc->coded_frame && enc->coded_frame->key_frame)
1572 pkt.flags |= AV_PKT_FLAG_KEY;
1573 if (ost->logfile && enc->stats_out) {
1574 fprintf(ost->logfile, "%s", enc->stats_out);
1583 pkt.data = bit_buffer;
1585 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1586 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1587 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1592 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1593 static int output_packet(InputStream *ist, int ist_index,
1594 OutputStream *ost_table, int nb_ostreams,
1595 const AVPacket *pkt)
1597 AVFormatContext *os;
1601 void *buffer_to_free = NULL;
1602 static unsigned int samples_size= 0;
1603 AVSubtitle subtitle, *subtitle_to_free;
1604 int64_t pkt_pts = AV_NOPTS_VALUE;
1606 int frame_available;
1611 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1613 if(ist->next_pts == AV_NOPTS_VALUE)
1614 ist->next_pts= ist->pts;
1618 av_init_packet(&avpkt);
1626 if(pkt->dts != AV_NOPTS_VALUE)
1627 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1628 if(pkt->pts != AV_NOPTS_VALUE)
1629 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1631 //while we have more to decode or while the decoder did output something on EOF
1632 while (avpkt.size > 0 || (!pkt && got_output)) {
1633 uint8_t *data_buf, *decoded_data_buf;
1634 int data_size, decoded_data_size;
1635 AVFrame *decoded_frame, *filtered_frame;
1637 ist->pts= ist->next_pts;
1639 if(avpkt.size && avpkt.size != pkt->size)
1640 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1641 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1642 ist->showed_multi_packet_warning=1;
1644 /* decode the packet if needed */
1645 decoded_frame = filtered_frame = NULL;
1646 decoded_data_buf = NULL; /* fail safe */
1647 decoded_data_size= 0;
1648 data_buf = avpkt.data;
1649 data_size = avpkt.size;
1650 subtitle_to_free = NULL;
1651 if (ist->decoding_needed) {
1652 switch(ist->st->codec->codec_type) {
1653 case AVMEDIA_TYPE_AUDIO:{
1654 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1655 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1657 samples= av_malloc(samples_size);
1659 decoded_data_size= samples_size;
1660 /* XXX: could avoid copy if PCM 16 bits with same
1661 endianness as CPU */
1662 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1669 got_output = decoded_data_size > 0;
1670 /* Some bug in mpeg audio decoder gives */
1671 /* decoded_data_size < 0, it seems they are overflows */
1673 /* no audio frame */
1676 decoded_data_buf = (uint8_t *)samples;
1677 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1678 (ist->st->codec->sample_rate * ist->st->codec->channels);
1680 case AVMEDIA_TYPE_VIDEO:
1681 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1682 if (!(decoded_frame = avcodec_alloc_frame()))
1683 return AVERROR(ENOMEM);
1684 avpkt.pts = pkt_pts;
1685 avpkt.dts = ist->pts;
1686 pkt_pts = AV_NOPTS_VALUE;
1688 ret = avcodec_decode_video2(ist->st->codec,
1689 decoded_frame, &got_output, &avpkt);
1690 quality = same_quant ? decoded_frame->quality : 0;
1694 /* no picture yet */
1695 av_freep(&decoded_frame);
1696 goto discard_packet;
1698 ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
1699 if (ist->st->codec->time_base.num != 0) {
1700 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1701 ist->next_pts += ((int64_t)AV_TIME_BASE *
1702 ist->st->codec->time_base.num * ticks) /
1703 ist->st->codec->time_base.den;
1706 buffer_to_free = NULL;
1707 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1709 case AVMEDIA_TYPE_SUBTITLE:
1710 ret = avcodec_decode_subtitle2(ist->st->codec,
1711 &subtitle, &got_output, &avpkt);
1715 goto discard_packet;
1717 subtitle_to_free = &subtitle;
1724 switch(ist->st->codec->codec_type) {
1725 case AVMEDIA_TYPE_AUDIO:
1726 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1727 ist->st->codec->sample_rate;
1729 case AVMEDIA_TYPE_VIDEO:
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;
1742 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1743 for(i=0;i<nb_ostreams;i++) {
1744 OutputFile *of = &output_files[ost_table[i].file_index];
1745 if (of->start_time == 0 || ist->pts >= of->start_time) {
1746 ost = &ost_table[i];
1747 if (ost->input_video_filter && ost->source_index == ist_index) {
1748 if (!decoded_frame->sample_aspect_ratio.num)
1749 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1750 decoded_frame->pts = ist->pts;
1752 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
1758 // preprocess audio (volume)
1759 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1760 if (audio_volume != 256) {
1763 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1764 int v = ((*volp) * audio_volume + 128) >> 8;
1765 *volp++ = av_clip_int16(v);
1770 /* frame rate emulation */
1771 if (input_files[ist->file_index].rate_emu) {
1772 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1773 int64_t now = av_gettime() - ist->start;
1777 /* if output time reached then transcode raw format,
1778 encode packets and output them */
1779 for (i = 0; i < nb_ostreams; i++) {
1780 OutputFile *of = &output_files[ost_table[i].file_index];
1783 ost = &ost_table[i];
1784 if (ost->source_index != ist_index)
1787 if (of->start_time && ist->pts < of->start_time)
1790 if (of->recording_time != INT64_MAX &&
1791 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1792 (AVRational){1, 1000000}) >= 0) {
1793 ost->is_past_recording_time = 1;
1798 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1799 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1800 while (frame_available) {
1801 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1802 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1803 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1805 if (!filtered_frame && !(filtered_frame = avcodec_alloc_frame())) {
1806 ret = AVERROR(ENOMEM);
1809 *filtered_frame= *decoded_frame; //for me_threshold
1811 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
1812 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1816 filtered_frame = decoded_frame;
1818 os = output_files[ost->file_index].ctx;
1820 /* set the input output pts pairs */
1821 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1823 if (ost->encoding_needed) {
1824 av_assert0(ist->decoding_needed);
1825 switch(ost->st->codec->codec_type) {
1826 case AVMEDIA_TYPE_AUDIO:
1827 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1829 case AVMEDIA_TYPE_VIDEO:
1831 if (ost->picref->video && !ost->frame_aspect_ratio)
1832 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1834 do_video_out(os, ost, ist, filtered_frame, &frame_size,
1835 same_quant ? quality : ost->st->codec->global_quality);
1836 if (vstats_filename && frame_size)
1837 do_video_stats(os, ost, frame_size);
1839 case AVMEDIA_TYPE_SUBTITLE:
1840 do_subtitle_out(os, ost, ist, &subtitle,
1849 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1850 av_init_packet(&opkt);
1852 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1853 #if !CONFIG_AVFILTER
1859 /* no reencoding needed : output the packet directly */
1860 /* force the input stream PTS */
1862 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1863 audio_size += data_size;
1864 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1865 video_size += data_size;
1869 opkt.stream_index= ost->index;
1870 if(pkt->pts != AV_NOPTS_VALUE)
1871 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1873 opkt.pts= AV_NOPTS_VALUE;
1875 if (pkt->dts == AV_NOPTS_VALUE)
1876 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1878 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1879 opkt.dts -= ost_tb_start_time;
1881 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1882 opkt.flags= pkt->flags;
1884 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1885 if( ost->st->codec->codec_id != CODEC_ID_H264
1886 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1887 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1889 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1890 opkt.destruct= av_destruct_packet;
1892 opkt.data = data_buf;
1893 opkt.size = data_size;
1896 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1897 /* store AVPicture in AVPacket, as expected by the output format */
1898 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1899 opkt.data = (uint8_t *)&pict;
1900 opkt.size = sizeof(AVPicture);
1901 opkt.flags |= AV_PKT_FLAG_KEY;
1903 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1904 ost->st->codec->frame_number++;
1905 ost->frame_number++;
1906 av_free_packet(&opkt);
1910 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1911 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1912 avfilter_unref_buffer(ost->picref);
1914 av_freep(&filtered_frame);
1919 av_free(buffer_to_free);
1920 /* XXX: allocate the subtitles in the codec ? */
1921 if (subtitle_to_free) {
1922 avsubtitle_free(subtitle_to_free);
1923 subtitle_to_free = NULL;
1925 av_freep(&decoded_frame);
1934 static void print_sdp(OutputFile *output_files, int n)
1938 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1942 for (i = 0; i < n; i++)
1943 avc[i] = output_files[i].ctx;
1945 av_sdp_create(avc, n, sdp, sizeof(sdp));
1946 printf("SDP:\n%s\n", sdp);
1951 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1952 char *error, int error_len)
1954 InputStream *ist = &input_streams[ist_index];
1955 if (ist->decoding_needed) {
1956 AVCodec *codec = ist->dec;
1958 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
1959 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1960 return AVERROR(EINVAL);
1962 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1963 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1964 ist->file_index, ist->st->index);
1965 return AVERROR(EINVAL);
1967 assert_codec_experimental(ist->st->codec, 0);
1968 assert_avoptions(ist->opts);
1971 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;
1972 ist->next_pts = AV_NOPTS_VALUE;
1978 static int transcode_init(OutputFile *output_files, int nb_output_files,
1979 InputFile *input_files, int nb_input_files)
1981 int ret = 0, i, j, k;
1982 AVFormatContext *os;
1983 AVCodecContext *codec, *icodec;
1989 /* init framerate emulation */
1990 for (i = 0; i < nb_input_files; i++) {
1991 InputFile *ifile = &input_files[i];
1992 if (ifile->rate_emu)
1993 for (j = 0; j < ifile->nb_streams; j++)
1994 input_streams[j + ifile->ist_index].start = av_gettime();
1997 /* output stream init */
1998 for(i=0;i<nb_output_files;i++) {
1999 os = output_files[i].ctx;
2000 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2001 av_dump_format(os, i, os->filename, 1);
2002 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2003 return AVERROR(EINVAL);
2007 /* for each output stream, we compute the right encoding parameters */
2008 for (i = 0; i < nb_output_streams; i++) {
2009 ost = &output_streams[i];
2010 os = output_files[ost->file_index].ctx;
2011 ist = &input_streams[ost->source_index];
2013 codec = ost->st->codec;
2014 icodec = ist->st->codec;
2016 ost->st->disposition = ist->st->disposition;
2017 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2018 codec->chroma_sample_location = icodec->chroma_sample_location;
2020 if (ost->st->stream_copy) {
2021 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2023 if (extra_size > INT_MAX) {
2024 return AVERROR(EINVAL);
2027 /* if stream_copy is selected, no need to decode or encode */
2028 codec->codec_id = icodec->codec_id;
2029 codec->codec_type = icodec->codec_type;
2031 if(!codec->codec_tag){
2032 if( !os->oformat->codec_tag
2033 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2034 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2035 codec->codec_tag = icodec->codec_tag;
2038 codec->bit_rate = icodec->bit_rate;
2039 codec->rc_max_rate = icodec->rc_max_rate;
2040 codec->rc_buffer_size = icodec->rc_buffer_size;
2041 codec->extradata= av_mallocz(extra_size);
2042 if (!codec->extradata) {
2043 return AVERROR(ENOMEM);
2045 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2046 codec->extradata_size= icodec->extradata_size;
2048 codec->time_base = ist->st->time_base;
2049 if(!strcmp(os->oformat->name, "avi")) {
2050 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){
2051 codec->time_base = icodec->time_base;
2052 codec->time_base.num *= icodec->ticks_per_frame;
2053 codec->time_base.den *= 2;
2055 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2056 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){
2057 codec->time_base = icodec->time_base;
2058 codec->time_base.num *= icodec->ticks_per_frame;
2061 av_reduce(&codec->time_base.num, &codec->time_base.den,
2062 codec->time_base.num, codec->time_base.den, INT_MAX);
2064 switch(codec->codec_type) {
2065 case AVMEDIA_TYPE_AUDIO:
2066 if(audio_volume != 256) {
2067 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2070 codec->channel_layout = icodec->channel_layout;
2071 codec->sample_rate = icodec->sample_rate;
2072 codec->channels = icodec->channels;
2073 codec->frame_size = icodec->frame_size;
2074 codec->audio_service_type = icodec->audio_service_type;
2075 codec->block_align= icodec->block_align;
2076 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2077 codec->block_align= 0;
2078 if(codec->codec_id == CODEC_ID_AC3)
2079 codec->block_align= 0;
2081 case AVMEDIA_TYPE_VIDEO:
2082 codec->pix_fmt = icodec->pix_fmt;
2083 codec->width = icodec->width;
2084 codec->height = icodec->height;
2085 codec->has_b_frames = icodec->has_b_frames;
2086 if (!codec->sample_aspect_ratio.num) {
2087 codec->sample_aspect_ratio =
2088 ost->st->sample_aspect_ratio =
2089 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2090 ist->st->codec->sample_aspect_ratio.num ?
2091 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2094 case AVMEDIA_TYPE_SUBTITLE:
2095 codec->width = icodec->width;
2096 codec->height = icodec->height;
2098 case AVMEDIA_TYPE_DATA:
2099 case AVMEDIA_TYPE_ATTACHMENT:
2106 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2107 switch(codec->codec_type) {
2108 case AVMEDIA_TYPE_AUDIO:
2109 ost->fifo= av_fifo_alloc(1024);
2111 return AVERROR(ENOMEM);
2113 if (!codec->sample_rate) {
2114 codec->sample_rate = icodec->sample_rate;
2116 choose_sample_rate(ost->st, ost->enc);
2117 codec->time_base = (AVRational){1, codec->sample_rate};
2118 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2119 codec->sample_fmt = icodec->sample_fmt;
2120 choose_sample_fmt(ost->st, ost->enc);
2121 if (!codec->channels) {
2122 codec->channels = icodec->channels;
2123 codec->channel_layout = icodec->channel_layout;
2125 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2126 codec->channel_layout = 0;
2127 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2128 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2129 || codec->channel_layout != icodec->channel_layout;
2130 icodec->request_channels = codec->channels;
2131 ist->decoding_needed = 1;
2132 ost->encoding_needed = 1;
2133 ost->resample_sample_fmt = icodec->sample_fmt;
2134 ost->resample_sample_rate = icodec->sample_rate;
2135 ost->resample_channels = icodec->channels;
2137 case AVMEDIA_TYPE_VIDEO:
2138 if (codec->pix_fmt == PIX_FMT_NONE)
2139 codec->pix_fmt = icodec->pix_fmt;
2140 choose_pixel_fmt(ost->st, ost->enc);
2142 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2143 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2147 if (!codec->width || !codec->height) {
2148 codec->width = icodec->width;
2149 codec->height = icodec->height;
2152 ost->video_resample = codec->width != icodec->width ||
2153 codec->height != icodec->height ||
2154 codec->pix_fmt != icodec->pix_fmt;
2155 if (ost->video_resample) {
2156 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2159 ost->resample_height = icodec->height;
2160 ost->resample_width = icodec->width;
2161 ost->resample_pix_fmt= icodec->pix_fmt;
2162 ost->encoding_needed = 1;
2163 ist->decoding_needed = 1;
2165 if (!ost->frame_rate.num)
2166 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2167 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2168 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2169 ost->frame_rate = ost->enc->supported_framerates[idx];
2171 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2172 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2173 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2174 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2175 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2179 if (configure_video_filters(ist, ost)) {
2180 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2185 case AVMEDIA_TYPE_SUBTITLE:
2186 ost->encoding_needed = 1;
2187 ist->decoding_needed = 1;
2194 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2195 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2196 char logfilename[1024];
2199 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2200 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2202 if (codec->flags & CODEC_FLAG_PASS1) {
2203 f = fopen(logfilename, "wb");
2205 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2206 logfilename, strerror(errno));
2212 size_t logbuffer_size;
2213 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2214 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2218 codec->stats_in = logbuffer;
2222 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2223 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2224 int size= codec->width * codec->height;
2225 bit_buffer_size= FFMAX(bit_buffer_size, 7*size + 10000);
2230 bit_buffer = av_malloc(bit_buffer_size);
2232 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2234 return AVERROR(ENOMEM);
2237 /* open each encoder */
2238 for (i = 0; i < nb_output_streams; i++) {
2239 ost = &output_streams[i];
2240 if (ost->encoding_needed) {
2241 AVCodec *codec = ost->enc;
2242 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2244 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2245 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2246 ret = AVERROR(EINVAL);
2249 if (dec->subtitle_header) {
2250 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2251 if (!ost->st->codec->subtitle_header) {
2252 ret = AVERROR(ENOMEM);
2255 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2256 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2258 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2259 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2260 ost->file_index, ost->index);
2261 ret = AVERROR(EINVAL);
2264 assert_codec_experimental(ost->st->codec, 1);
2265 assert_avoptions(ost->opts);
2266 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2267 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2268 "It takes bits/s as argument, not kbits/s\n");
2269 extra_size += ost->st->codec->extradata_size;
2271 if (ost->st->codec->me_threshold)
2272 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2276 /* init input streams */
2277 for (i = 0; i < nb_input_streams; i++)
2278 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2281 /* discard unused programs */
2282 for (i = 0; i < nb_input_files; i++) {
2283 InputFile *ifile = &input_files[i];
2284 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2285 AVProgram *p = ifile->ctx->programs[j];
2286 int discard = AVDISCARD_ALL;
2288 for (k = 0; k < p->nb_stream_indexes; k++)
2289 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2290 discard = AVDISCARD_DEFAULT;
2293 p->discard = discard;
2297 /* open files and write file headers */
2298 for (i = 0; i < nb_output_files; i++) {
2299 os = output_files[i].ctx;
2300 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2301 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2302 ret = AVERROR(EINVAL);
2305 // assert_avoptions(output_files[i].opts);
2306 if (strcmp(os->oformat->name, "rtp")) {
2312 /* dump the file output parameters - cannot be done before in case
2314 for(i=0;i<nb_output_files;i++) {
2315 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2318 /* dump the stream mapping */
2319 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2320 for (i = 0; i < nb_output_streams; i++) {
2321 ost = &output_streams[i];
2322 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d -> #%d.%d",
2323 input_streams[ost->source_index].file_index,
2324 input_streams[ost->source_index].st->index,
2327 if (ost->sync_ist != &input_streams[ost->source_index])
2328 av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
2329 ost->sync_ist->file_index,
2330 ost->sync_ist->st->index);
2331 if (ost->st->stream_copy)
2332 av_log(NULL, AV_LOG_INFO, " (copy)");
2334 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2335 input_streams[ost->source_index].dec->name : "?",
2336 ost->enc ? ost->enc->name : "?");
2337 av_log(NULL, AV_LOG_INFO, "\n");
2341 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2346 print_sdp(output_files, nb_output_files);
2353 * The following code is the main loop of the file converter
2355 static int transcode(OutputFile *output_files, int nb_output_files,
2356 InputFile *input_files, int nb_input_files)
2359 AVFormatContext *is, *os;
2363 int no_packet_count=0;
2364 int64_t timer_start;
2367 if (!(no_packet = av_mallocz(nb_input_files)))
2370 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2375 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2376 avio_set_interrupt_cb(decode_interrupt_cb);
2380 timer_start = av_gettime();
2382 for(; received_sigterm == 0;) {
2383 int file_index, ist_index;
2388 ipts_min= INT64_MAX;
2390 /* if 'q' pressed, exits */
2394 /* read_key() returns 0 on EOF */
2398 if (key == '+') av_log_set_level(av_log_get_level()+10);
2399 if (key == '-') av_log_set_level(av_log_get_level()-10);
2400 if (key == 's') qp_hist ^= 1;
2403 do_hex_dump = do_pkt_dump = 0;
2404 } else if(do_pkt_dump){
2408 av_log_set_level(AV_LOG_DEBUG);
2411 if (key == 'c' || key == 'C'){
2412 char buf[4096], target[64], command[256], arg[256] = {0};
2415 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2417 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2422 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2423 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2424 target, time, command, arg);
2425 for (i = 0; i < nb_output_streams; i++) {
2426 ost = &output_streams[i];
2429 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2430 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2431 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2433 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2438 av_log(NULL, AV_LOG_ERROR,
2439 "Parse error, at least 3 arguments were expected, "
2440 "only %d given in string '%s'\n", n, buf);
2444 if (key == 'd' || key == 'D'){
2447 debug = input_streams[0].st->codec->debug<<1;
2448 if(!debug) debug = 1;
2449 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2452 scanf("%d", &debug);
2453 for(i=0;i<nb_input_streams;i++) {
2454 input_streams[i].st->codec->debug = debug;
2456 for(i=0;i<nb_output_streams;i++) {
2457 ost = &output_streams[i];
2458 ost->st->codec->debug = debug;
2460 if(debug) av_log_set_level(AV_LOG_DEBUG);
2461 fprintf(stderr,"debug=%d\n", debug);
2464 fprintf(stderr, "key function\n"
2465 "? show this help\n"
2466 "+ increase verbosity\n"
2467 "- decrease verbosity\n"
2468 "c Send command to filtergraph\n"
2469 "D cycle through available debug modes\n"
2470 "h dump packets/hex press to cycle through the 3 states\n"
2472 "s Show QP histogram\n"
2477 /* select the stream that we must read now by looking at the
2478 smallest output pts */
2480 for (i = 0; i < nb_output_streams; i++) {
2484 ost = &output_streams[i];
2485 of = &output_files[ost->file_index];
2486 os = output_files[ost->file_index].ctx;
2487 ist = &input_streams[ost->source_index];
2488 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2489 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2491 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2493 if (!input_files[ist->file_index].eof_reached){
2494 if(ipts < ipts_min) {
2496 if(input_sync ) file_index = ist->file_index;
2498 if(opts < opts_min) {
2500 if(!input_sync) file_index = ist->file_index;
2503 if (ost->frame_number >= ost->max_frames) {
2505 for (j = 0; j < of->ctx->nb_streams; j++)
2506 output_streams[of->ost_index + j].is_past_recording_time = 1;
2510 /* if none, if is finished */
2511 if (file_index < 0) {
2512 if(no_packet_count){
2514 memset(no_packet, 0, nb_input_files);
2521 /* read a frame from it and output it in the fifo */
2522 is = input_files[file_index].ctx;
2523 ret= av_read_frame(is, &pkt);
2524 if(ret == AVERROR(EAGAIN)){
2525 no_packet[file_index]=1;
2530 input_files[file_index].eof_reached = 1;
2538 memset(no_packet, 0, nb_input_files);
2541 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2542 is->streams[pkt.stream_index]);
2544 /* the following test is needed in case new streams appear
2545 dynamically in stream : we ignore them */
2546 if (pkt.stream_index >= input_files[file_index].nb_streams)
2547 goto discard_packet;
2548 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2549 ist = &input_streams[ist_index];
2551 goto discard_packet;
2553 if (pkt.dts != AV_NOPTS_VALUE)
2554 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2555 if (pkt.pts != AV_NOPTS_VALUE)
2556 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2558 if(pkt.pts != AV_NOPTS_VALUE)
2559 pkt.pts *= ist->ts_scale;
2560 if(pkt.dts != AV_NOPTS_VALUE)
2561 pkt.dts *= ist->ts_scale;
2563 // 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);
2564 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2565 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2566 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2567 int64_t delta= pkt_dts - ist->next_pts;
2568 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2569 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2570 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2571 pkt_dts+1<ist->pts)&& !copy_ts){
2572 input_files[ist->file_index].ts_offset -= delta;
2573 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2574 delta, input_files[ist->file_index].ts_offset);
2575 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2576 if(pkt.pts != AV_NOPTS_VALUE)
2577 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2581 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2582 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2584 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d.%d\n",
2585 ist->file_index, ist->st->index);
2588 av_free_packet(&pkt);
2593 av_free_packet(&pkt);
2595 /* dump report by using the output first video and audio streams */
2596 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2599 /* at the end of stream, we must flush the decoder buffers */
2600 for (i = 0; i < nb_input_streams; i++) {
2601 ist = &input_streams[i];
2602 if (ist->decoding_needed) {
2603 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2606 flush_encoders(output_streams, nb_output_streams);
2610 /* write the trailer if needed and close file */
2611 for(i=0;i<nb_output_files;i++) {
2612 os = output_files[i].ctx;
2613 av_write_trailer(os);
2616 /* dump report by using the first video and audio streams */
2617 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2619 /* close each encoder */
2620 for (i = 0; i < nb_output_streams; i++) {
2621 ost = &output_streams[i];
2622 if (ost->encoding_needed) {
2623 av_freep(&ost->st->codec->stats_in);
2624 avcodec_close(ost->st->codec);
2627 avfilter_graph_free(&ost->graph);
2631 /* close each decoder */
2632 for (i = 0; i < nb_input_streams; i++) {
2633 ist = &input_streams[i];
2634 if (ist->decoding_needed) {
2635 avcodec_close(ist->st->codec);
2643 av_freep(&bit_buffer);
2644 av_freep(&no_packet);
2646 if (output_streams) {
2647 for (i = 0; i < nb_output_streams; i++) {
2648 ost = &output_streams[i];
2650 if (ost->st->stream_copy)
2651 av_freep(&ost->st->codec->extradata);
2653 fclose(ost->logfile);
2654 ost->logfile = NULL;
2656 av_fifo_free(ost->fifo); /* works even if fifo is not
2657 initialized but set to zero */
2658 av_freep(&ost->st->codec->subtitle_header);
2659 av_free(ost->resample_frame.data[0]);
2660 av_free(ost->forced_kf_pts);
2661 if (ost->video_resample)
2662 sws_freeContext(ost->img_resample_ctx);
2663 swr_free(&ost->swr);
2664 av_dict_free(&ost->opts);
2671 static int opt_verbose(const char *opt, const char *arg)
2673 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -loglevel\n", opt);
2677 static int opt_frame_crop(const char *opt, const char *arg)
2679 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2680 return AVERROR(EINVAL);
2683 static int opt_pad(const char *opt, const char *arg)
2685 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2689 static double parse_frame_aspect_ratio(const char *arg)
2696 p = strchr(arg, ':');
2698 x = strtol(arg, &end, 10);
2700 y = strtol(end+1, &end, 10);
2702 ar = (double)x / (double)y;
2704 ar = strtod(arg, NULL);
2707 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2713 static int opt_video_channel(const char *opt, const char *arg)
2715 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2716 return opt_default("channel", arg);
2719 static int opt_video_standard(const char *opt, const char *arg)
2721 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2722 return opt_default("standard", arg);
2725 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2727 audio_codec_name = arg;
2728 return parse_option(o, "codec:a", arg, options);
2731 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2733 video_codec_name = arg;
2734 return parse_option(o, "codec:v", arg, options);
2737 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2739 subtitle_codec_name = arg;
2740 return parse_option(o, "codec:s", arg, options);
2743 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2745 return parse_option(o, "codec:d", arg, options);
2748 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2750 StreamMap *m = NULL;
2751 int i, negative = 0, file_idx;
2752 int sync_file_idx = -1, sync_stream_idx;
2760 map = av_strdup(arg);
2762 /* parse sync stream first, just pick first matching stream */
2763 if (sync = strchr(map, ',')) {
2765 sync_file_idx = strtol(sync + 1, &sync, 0);
2766 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2767 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2772 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2773 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2774 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2775 sync_stream_idx = i;
2778 if (i == input_files[sync_file_idx].nb_streams) {
2779 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2780 "match any streams.\n", arg);
2786 file_idx = strtol(map, &p, 0);
2787 if (file_idx >= nb_input_files || file_idx < 0) {
2788 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2792 /* disable some already defined maps */
2793 for (i = 0; i < o->nb_stream_maps; i++) {
2794 m = &o->stream_maps[i];
2795 if (check_stream_specifier(input_files[m->file_index].ctx,
2796 input_files[m->file_index].ctx->streams[m->stream_index],
2797 *p == ':' ? p + 1 : p) > 0)
2801 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2802 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2803 *p == ':' ? p + 1 : p) <= 0)
2805 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2806 &o->nb_stream_maps, o->nb_stream_maps + 1);
2807 m = &o->stream_maps[o->nb_stream_maps - 1];
2809 m->file_index = file_idx;
2810 m->stream_index = i;
2812 if (sync_file_idx >= 0) {
2813 m->sync_file_index = sync_file_idx;
2814 m->sync_stream_index = sync_stream_idx;
2816 m->sync_file_index = file_idx;
2817 m->sync_stream_index = i;
2822 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2830 static void parse_meta_type(char *arg, char *type, int *index)
2840 if (*(++arg) == ':')
2841 *index = strtol(++arg, NULL, 0);
2844 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2851 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2853 MetadataMap *m, *m1;
2856 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2857 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2859 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2860 m->file = strtol(arg, &p, 0);
2861 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2863 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2864 if (p = strchr(opt, ':'))
2865 parse_meta_type(p + 1, &m1->type, &m1->index);
2869 if (m->type == 'g' || m1->type == 'g')
2870 o->metadata_global_manual = 1;
2871 if (m->type == 's' || m1->type == 's')
2872 o->metadata_streams_manual = 1;
2873 if (m->type == 'c' || m1->type == 'c')
2874 o->metadata_chapters_manual = 1;
2879 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2881 av_log(NULL, AV_LOG_WARNING, "-map_meta_data is deprecated and will be removed soon. "
2882 "Use -map_metadata instead.\n");
2883 return opt_map_metadata(o, opt, arg);
2886 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
2889 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2890 struct tm time = *gmtime((time_t*)&recording_timestamp);
2891 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2892 parse_option(o, "metadata", buf, options);
2894 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2895 "tag instead.\n", opt);
2899 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2901 const char *codec_string = encoder ? "encoder" : "decoder";
2905 return CODEC_ID_NONE;
2907 avcodec_find_encoder_by_name(name) :
2908 avcodec_find_decoder_by_name(name);
2910 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2913 if(codec->type != type) {
2914 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2920 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2922 char *codec_name = NULL;
2924 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2928 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2929 return avcodec_find_encoder(st->codec->codec_id);
2931 } else if (!strcmp(codec_name, "copy"))
2932 st->stream_copy = 1;
2934 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2935 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2936 avcodec_find_decoder_by_name(codec_name);
2943 * Add all the streams from the given input file to the global
2944 * list of input streams.
2946 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2948 int i, rfps, rfps_base;
2950 for (i = 0; i < ic->nb_streams; i++) {
2951 AVStream *st = ic->streams[i];
2952 AVCodecContext *dec = st->codec;
2956 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2957 ist = &input_streams[nb_input_streams - 1];
2959 ist->file_index = nb_input_files;
2961 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2963 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2964 ist->ts_scale = scale;
2966 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2968 ist->dec = avcodec_find_decoder(dec->codec_id);
2970 switch (dec->codec_type) {
2971 case AVMEDIA_TYPE_AUDIO:
2973 ist->dec = avcodec_find_decoder(dec->codec_id);
2974 if(o->audio_disable)
2975 st->discard= AVDISCARD_ALL;
2977 case AVMEDIA_TYPE_VIDEO:
2979 ist->dec = avcodec_find_decoder(dec->codec_id);
2980 rfps = ic->streams[i]->r_frame_rate.num;
2981 rfps_base = ic->streams[i]->r_frame_rate.den;
2983 dec->flags |= CODEC_FLAG_EMU_EDGE;
2986 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2988 av_log(NULL, AV_LOG_INFO,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2989 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2990 (float)rfps / rfps_base, rfps, rfps_base);
2993 if (o->video_disable)
2994 st->discard= AVDISCARD_ALL;
2995 else if(video_discard)
2996 st->discard= video_discard;
2998 case AVMEDIA_TYPE_DATA:
3000 case AVMEDIA_TYPE_SUBTITLE:
3002 ist->dec = avcodec_find_decoder(dec->codec_id);
3003 if(o->subtitle_disable)
3004 st->discard = AVDISCARD_ALL;
3006 case AVMEDIA_TYPE_ATTACHMENT:
3007 case AVMEDIA_TYPE_UNKNOWN:
3015 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3017 AVFormatContext *ic;
3018 AVInputFormat *file_iformat = NULL;
3022 AVDictionary **opts;
3023 int orig_nb_streams; // number of streams before avformat_find_stream_info
3026 if (!(file_iformat = av_find_input_format(o->format))) {
3027 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3032 if (!strcmp(filename, "-"))
3035 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3036 !strcmp(filename, "/dev/stdin");
3038 /* get default parameters from command line */
3039 ic = avformat_alloc_context();
3041 print_error(filename, AVERROR(ENOMEM));
3044 if (o->nb_audio_sample_rate) {
3045 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3046 av_dict_set(&format_opts, "sample_rate", buf, 0);
3048 if (o->nb_audio_channels) {
3049 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3050 av_dict_set(&format_opts, "channels", buf, 0);
3052 if (o->nb_frame_rates) {
3053 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3055 if (o->nb_frame_sizes) {
3056 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3058 if (o->nb_frame_pix_fmts)
3059 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3061 ic->flags |= AVFMT_FLAG_NONBLOCK;
3064 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3065 ic->loop_input = loop_input;
3068 /* open the input file with generic libav function */
3069 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3071 print_error(filename, err);
3074 assert_avoptions(format_opts);
3076 /* apply forced codec ids */
3077 for (i = 0; i < ic->nb_streams; i++)
3078 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3080 /* Set AVCodecContext options for avformat_find_stream_info */
3081 opts = setup_find_stream_info_opts(ic, codec_opts);
3082 orig_nb_streams = ic->nb_streams;
3084 /* If not enough info to get the stream parameters, we decode the
3085 first frames to get it. (used in mpeg case for example) */
3086 ret = avformat_find_stream_info(ic, opts);
3088 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3089 av_close_input_file(ic);
3093 timestamp = o->start_time;
3094 /* add the stream start time */
3095 if (ic->start_time != AV_NOPTS_VALUE)
3096 timestamp += ic->start_time;
3098 /* if seeking requested, we execute it */
3099 if (o->start_time != 0) {
3100 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3102 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3103 filename, (double)timestamp / AV_TIME_BASE);
3107 /* update the current parameters so that they match the one of the input stream */
3108 add_input_streams(o, ic);
3110 /* dump the file content */
3111 av_dump_format(ic, nb_input_files, filename, 0);
3113 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3114 input_files[nb_input_files - 1].ctx = ic;
3115 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3116 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3117 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3118 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3120 for (i = 0; i < orig_nb_streams; i++)
3121 av_dict_free(&opts[i]);
3124 reset_options(o, 1);
3128 static void parse_forced_key_frames(char *kf, OutputStream *ost, AVCodecContext *avctx)
3134 for (p = kf; *p; p++)
3137 ost->forced_kf_count = n;
3138 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3139 if (!ost->forced_kf_pts) {
3140 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3143 for (i = 0; i < n; i++) {
3144 p = i ? strchr(p, ',') + 1 : kf;
3145 t = parse_time_or_die("force_key_frames", p, 1);
3146 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3150 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3153 AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
3154 int idx = oc->nb_streams - 1;
3155 int64_t max_frames = INT64_MAX;
3156 char *bsf = NULL, *next, *codec_tag = NULL;
3157 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3161 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3165 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3166 nb_output_streams + 1);
3167 ost = &output_streams[nb_output_streams - 1];
3168 ost->file_index = nb_output_files;
3171 st->codec->codec_type = type;
3172 ost->enc = choose_codec(o, oc, st, type);
3174 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3177 avcodec_get_context_defaults3(st->codec, ost->enc);
3178 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3180 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3181 ost->max_frames = max_frames;
3183 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3185 if (next = strchr(bsf, ','))
3187 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3188 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3192 bsfc_prev->next = bsfc;
3194 ost->bitstream_filters = bsfc;
3200 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3202 uint32_t tag = strtol(codec_tag, &next, 0);
3204 tag = AV_RL32(codec_tag);
3205 st->codec->codec_tag = tag;
3208 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3209 if (qscale >= 0 || same_quant) {
3210 st->codec->flags |= CODEC_FLAG_QSCALE;
3211 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3214 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3215 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3217 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3221 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3224 const char *p = str;
3231 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3238 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3242 AVCodecContext *video_enc;
3244 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3246 video_enc = st->codec;
3248 if (!st->stream_copy) {
3249 const char *p = NULL;
3250 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3251 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3252 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3253 int i, force_fps = 0, top_field_first = -1;
3255 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3256 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3257 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3261 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3262 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3263 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3267 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3268 if (frame_aspect_ratio)
3269 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3271 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3272 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3273 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3274 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3277 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3280 video_enc->gop_size = 0;
3281 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3283 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3284 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3287 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3289 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3291 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3292 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3295 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3298 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3301 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3303 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3306 video_enc->rc_override=
3307 av_realloc(video_enc->rc_override,
3308 sizeof(RcOverride)*(i+1));
3309 video_enc->rc_override[i].start_frame= start;
3310 video_enc->rc_override[i].end_frame = end;
3312 video_enc->rc_override[i].qscale= q;
3313 video_enc->rc_override[i].quality_factor= 1.0;
3316 video_enc->rc_override[i].qscale= 0;
3317 video_enc->rc_override[i].quality_factor= -q/100.0;
3322 video_enc->rc_override_count=i;
3323 if (!video_enc->rc_initial_buffer_occupancy)
3324 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3325 video_enc->intra_dc_precision= intra_dc_precision - 8;
3330 video_enc->flags |= CODEC_FLAG_PASS1;
3332 video_enc->flags |= CODEC_FLAG_PASS2;
3336 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3337 if (forced_key_frames)
3338 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3340 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3341 ost->force_fps = force_fps;
3343 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3344 ost->top_field_first = top_field_first;
3347 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3349 ost->avfilter = av_strdup(filters);
3356 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3360 AVCodecContext *audio_enc;
3362 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3365 audio_enc = st->codec;
3366 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3368 if (!st->stream_copy) {
3369 char *sample_fmt = NULL;
3371 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3373 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3375 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3376 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3380 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3386 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3391 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3393 if (!st->stream_copy) {
3394 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3401 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3403 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3404 ost->st->stream_copy = 1;
3408 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3412 AVCodecContext *subtitle_enc;
3414 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3416 subtitle_enc = st->codec;
3418 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3423 /* arg format is "output-stream-index:streamid-value". */
3424 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3430 av_strlcpy(idx_str, arg, sizeof(idx_str));
3431 p = strchr(idx_str, ':');
3433 av_log(NULL, AV_LOG_FATAL,
3434 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3439 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3440 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3441 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3445 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3447 AVFormatContext *is = ifile->ctx;
3448 AVFormatContext *os = ofile->ctx;
3451 for (i = 0; i < is->nb_chapters; i++) {
3452 AVChapter *in_ch = is->chapters[i], *out_ch;
3453 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3454 AV_TIME_BASE_Q, in_ch->time_base);
3455 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3456 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3459 if (in_ch->end < ts_off)
3461 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3464 out_ch = av_mallocz(sizeof(AVChapter));
3466 return AVERROR(ENOMEM);
3468 out_ch->id = in_ch->id;
3469 out_ch->time_base = in_ch->time_base;
3470 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3471 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3474 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3477 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3479 return AVERROR(ENOMEM);
3480 os->chapters[os->nb_chapters - 1] = out_ch;
3485 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3488 AVFormatContext *ic = NULL;
3490 err = avformat_open_input(&ic, filename, NULL, NULL);
3493 /* copy stream format */
3494 for(i=0;i<ic->nb_streams;i++) {
3499 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3500 ost = new_output_stream(o, s, codec->type);
3503 // FIXME: a more elegant solution is needed
3504 memcpy(st, ic->streams[i], sizeof(AVStream));
3505 st->info = av_malloc(sizeof(*st->info));
3506 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3507 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3509 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3510 choose_sample_fmt(st, codec);
3511 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3512 choose_pixel_fmt(st, codec);
3515 av_close_input_file(ic);
3519 static void opt_output_file(void *optctx, const char *filename)
3521 OptionsContext *o = optctx;
3522 AVFormatContext *oc;
3524 AVOutputFormat *file_oformat;
3528 if (!strcmp(filename, "-"))
3531 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3533 print_error(filename, err);
3536 file_oformat= oc->oformat;
3538 if (!strcmp(file_oformat->name, "ffm") &&
3539 av_strstart(filename, "http:", NULL)) {
3540 /* special case for files sent to ffserver: we get the stream
3541 parameters from ffserver */
3542 int err = read_ffserver_streams(o, oc, filename);
3544 print_error(filename, err);
3547 } else if (!o->nb_stream_maps) {
3548 /* pick the "best" stream of each type */
3549 #define NEW_STREAM(type, index)\
3551 ost = new_ ## type ## _stream(o, oc);\
3552 ost->source_index = index;\
3553 ost->sync_ist = &input_streams[index];\
3554 input_streams[index].discard = 0;\
3557 /* video: highest resolution */
3558 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3559 int area = 0, idx = -1;
3560 for (i = 0; i < nb_input_streams; i++) {
3561 ist = &input_streams[i];
3562 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3563 ist->st->codec->width * ist->st->codec->height > area) {
3564 area = ist->st->codec->width * ist->st->codec->height;
3568 NEW_STREAM(video, idx);
3571 /* audio: most channels */
3572 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3573 int channels = 0, idx = -1;
3574 for (i = 0; i < nb_input_streams; i++) {
3575 ist = &input_streams[i];
3576 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3577 ist->st->codec->channels > channels) {
3578 channels = ist->st->codec->channels;
3582 NEW_STREAM(audio, idx);
3585 /* subtitles: pick first */
3586 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3587 for (i = 0; i < nb_input_streams; i++)
3588 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3589 NEW_STREAM(subtitle, i);
3593 /* do something with data? */
3595 for (i = 0; i < o->nb_stream_maps; i++) {
3596 StreamMap *map = &o->stream_maps[i];
3601 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3602 switch (ist->st->codec->codec_type) {
3603 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3604 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3605 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3606 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3607 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3609 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3610 map->file_index, map->stream_index);
3614 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3615 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3616 map->sync_stream_index];
3621 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3622 output_files[nb_output_files - 1].ctx = oc;
3623 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3624 output_files[nb_output_files - 1].recording_time = o->recording_time;
3625 output_files[nb_output_files - 1].start_time = o->start_time;
3626 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3627 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3629 /* check filename in case of an image number is expected */
3630 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3631 if (!av_filename_number_test(oc->filename)) {
3632 print_error(oc->filename, AVERROR(EINVAL));
3637 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3638 /* test if it already exists to avoid loosing precious files */
3639 if (!file_overwrite &&
3640 (strchr(filename, ':') == NULL ||
3641 filename[1] == ':' ||
3642 av_strstart(filename, "file:", NULL))) {
3643 if (avio_check(filename, 0) == 0) {
3645 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3647 if (!read_yesno()) {
3648 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3653 av_log(0, AV_LOG_FATAL,"File '%s' already exists. Exiting.\n", filename);
3660 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3661 print_error(filename, err);
3666 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3667 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3669 if (loop_output >= 0) {
3670 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3671 oc->loop_output = loop_output;
3675 if (o->chapters_input_file >= nb_input_files) {
3676 if (o->chapters_input_file == INT_MAX) {
3677 /* copy chapters from the first input file that has them*/
3678 o->chapters_input_file = -1;
3679 for (i = 0; i < nb_input_files; i++)
3680 if (input_files[i].ctx->nb_chapters) {
3681 o->chapters_input_file = i;
3685 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3686 o->chapters_input_file);
3690 if (o->chapters_input_file >= 0)
3691 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3692 !o->metadata_chapters_manual);
3695 for (i = 0; i < o->nb_meta_data_maps; i++) {
3696 AVFormatContext *files[2];
3697 AVDictionary **meta[2];
3700 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3701 if ((index) < 0 || (index) >= (nb_elems)) {\
3702 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3707 int in_file_index = o->meta_data_maps[i][1].file;
3708 if (in_file_index < 0)
3710 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3713 files[1] = input_files[in_file_index].ctx;
3715 for (j = 0; j < 2; j++) {
3716 MetadataMap *map = &o->meta_data_maps[i][j];
3718 switch (map->type) {
3720 meta[j] = &files[j]->metadata;
3723 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3724 meta[j] = &files[j]->streams[map->index]->metadata;
3727 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3728 meta[j] = &files[j]->chapters[map->index]->metadata;
3731 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3732 meta[j] = &files[j]->programs[map->index]->metadata;
3737 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3740 /* copy global metadata by default */
3741 if (!o->metadata_global_manual && nb_input_files){
3742 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3743 AV_DICT_DONT_OVERWRITE);
3744 if(o->recording_time != INT64_MAX)
3745 av_dict_set(&oc->metadata, "duration", NULL, 0);
3747 if (!o->metadata_streams_manual)
3748 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3749 InputStream *ist = &input_streams[output_streams[i].source_index];
3750 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3753 /* process manually set metadata */
3754 for (i = 0; i < o->nb_metadata; i++) {
3759 val = strchr(o->metadata[i].u.str, '=');
3761 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3762 o->metadata[i].u.str);
3767 parse_meta_type(o->metadata[i].specifier, &type, &index);
3773 if (index < 0 || index >= oc->nb_streams) {
3774 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3777 m = &oc->streams[index]->metadata;
3780 if (index < 0 || index >= oc->nb_chapters) {
3781 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3784 m = &oc->chapters[index]->metadata;
3787 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3791 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3794 reset_options(o, 0);
3797 /* same option as mencoder */
3798 static int opt_pass(const char *opt, const char *arg)
3800 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3804 static int64_t getutime(void)
3807 struct rusage rusage;
3809 getrusage(RUSAGE_SELF, &rusage);
3810 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3811 #elif HAVE_GETPROCESSTIMES
3813 FILETIME c, e, k, u;
3814 proc = GetCurrentProcess();
3815 GetProcessTimes(proc, &c, &e, &k, &u);
3816 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3818 return av_gettime();
3822 static int64_t getmaxrss(void)
3824 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3825 struct rusage rusage;
3826 getrusage(RUSAGE_SELF, &rusage);
3827 return (int64_t)rusage.ru_maxrss * 1024;
3828 #elif HAVE_GETPROCESSMEMORYINFO
3830 PROCESS_MEMORY_COUNTERS memcounters;
3831 proc = GetCurrentProcess();
3832 memcounters.cb = sizeof(memcounters);
3833 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3834 return memcounters.PeakPagefileUsage;
3840 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3842 return parse_option(o, "q:a", arg, options);
3845 static void show_usage(void)
3847 printf("Hyper fast Audio and Video encoder\n");
3848 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3852 static int opt_help(const char *opt, const char *arg)
3855 AVOutputFormat *oformat = NULL;
3856 AVInputFormat *iformat = NULL;
3857 const AVClass *class;
3859 av_log_set_callback(log_callback_help);
3861 show_help_options(options, "Main options:\n",
3862 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3863 show_help_options(options, "\nAdvanced options:\n",
3864 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3866 show_help_options(options, "\nVideo options:\n",
3867 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3869 show_help_options(options, "\nAdvanced Video options:\n",
3870 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3871 OPT_VIDEO | OPT_EXPERT);
3872 show_help_options(options, "\nAudio options:\n",
3873 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3875 show_help_options(options, "\nAdvanced Audio options:\n",
3876 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3877 OPT_AUDIO | OPT_EXPERT);
3878 show_help_options(options, "\nSubtitle options:\n",
3879 OPT_SUBTITLE | OPT_GRAB,
3881 show_help_options(options, "\nAudio/Video grab options:\n",
3885 class = avcodec_get_class();
3886 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3889 /* individual codec options */
3891 while ((c = av_codec_next(c))) {
3892 if (c->priv_class) {
3893 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3898 class = avformat_get_class();
3899 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3902 /* individual muxer options */
3903 while ((oformat = av_oformat_next(oformat))) {
3904 if (oformat->priv_class) {
3905 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3910 /* individual demuxer options */
3911 while ((iformat = av_iformat_next(iformat))) {
3912 if (iformat->priv_class) {
3913 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3918 class = sws_get_class();
3919 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3923 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3925 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3926 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3928 if(!strncmp(arg, "pal-", 4)) {
3931 } else if(!strncmp(arg, "ntsc-", 5)) {
3934 } else if(!strncmp(arg, "film-", 5)) {
3938 /* Try to determine PAL/NTSC by peeking in the input files */
3939 if(nb_input_files) {
3941 for (j = 0; j < nb_input_files; j++) {
3942 for (i = 0; i < input_files[j].nb_streams; i++) {
3943 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3944 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3946 fr = c->time_base.den * 1000 / c->time_base.num;
3950 } else if((fr == 29970) || (fr == 23976)) {
3959 if (norm != UNKNOWN)
3960 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3963 if(norm == UNKNOWN) {
3964 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3965 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3966 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3970 if(!strcmp(arg, "vcd")) {
3971 opt_video_codec(o, "c:v", "mpeg1video");
3972 opt_audio_codec(o, "c:a", "mp2");
3973 parse_option(o, "f", "vcd", options);
3975 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3976 parse_option(o, "r", frame_rates[norm], options);
3977 opt_default("g", norm == PAL ? "15" : "18");
3979 opt_default("b", "1150000");
3980 opt_default("maxrate", "1150000");
3981 opt_default("minrate", "1150000");
3982 opt_default("bufsize", "327680"); // 40*1024*8;
3984 opt_default("b:a", "224000");
3985 parse_option(o, "ar", "44100", options);
3986 parse_option(o, "ac", "2", options);
3988 opt_default("packetsize", "2324");
3989 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3991 /* We have to offset the PTS, so that it is consistent with the SCR.
3992 SCR starts at 36000, but the first two packs contain only padding
3993 and the first pack from the other stream, respectively, may also have
3994 been written before.
3995 So the real data starts at SCR 36000+3*1200. */
3996 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3997 } else if(!strcmp(arg, "svcd")) {
3999 opt_video_codec(o, "c:v", "mpeg2video");
4000 opt_audio_codec(o, "c:a", "mp2");
4001 parse_option(o, "f", "svcd", options);
4003 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4004 parse_option(o, "r", frame_rates[norm], options);
4005 parse_option(o, "pix_fmt", "yuv420p", options);
4006 opt_default("g", norm == PAL ? "15" : "18");
4008 opt_default("b", "2040000");
4009 opt_default("maxrate", "2516000");
4010 opt_default("minrate", "0"); //1145000;
4011 opt_default("bufsize", "1835008"); //224*1024*8;
4012 opt_default("flags", "+scan_offset");
4015 opt_default("b:a", "224000");
4016 parse_option(o, "ar", "44100", options);
4018 opt_default("packetsize", "2324");
4020 } else if(!strcmp(arg, "dvd")) {
4022 opt_video_codec(o, "c:v", "mpeg2video");
4023 opt_audio_codec(o, "c:a", "ac3");
4024 parse_option(o, "f", "dvd", options);
4026 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4027 parse_option(o, "r", frame_rates[norm], options);
4028 parse_option(o, "pix_fmt", "yuv420p", options);
4029 opt_default("g", norm == PAL ? "15" : "18");
4031 opt_default("b", "6000000");
4032 opt_default("maxrate", "9000000");
4033 opt_default("minrate", "0"); //1500000;
4034 opt_default("bufsize", "1835008"); //224*1024*8;
4036 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4037 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4039 opt_default("b:a", "448000");
4040 parse_option(o, "ar", "48000", options);
4042 } else if(!strncmp(arg, "dv", 2)) {
4044 parse_option(o, "f", "dv", options);
4046 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4047 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4048 norm == PAL ? "yuv420p" : "yuv411p", options);
4049 parse_option(o, "r", frame_rates[norm], options);
4051 parse_option(o, "ar", "48000", options);
4052 parse_option(o, "ac", "2", options);
4055 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4056 return AVERROR(EINVAL);
4061 static int opt_vstats_file(const char *opt, const char *arg)
4063 av_free (vstats_filename);
4064 vstats_filename=av_strdup (arg);
4068 static int opt_vstats(const char *opt, const char *arg)
4071 time_t today2 = time(NULL);
4072 struct tm *today = localtime(&today2);
4074 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4076 return opt_vstats_file(opt, filename);
4079 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4081 return parse_option(o, "frames:v", arg, options);
4084 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4086 return parse_option(o, "frames:a", arg, options);
4089 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4091 return parse_option(o, "frames:d", arg, options);
4094 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4097 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4098 const char *codec_name = *opt == 'v' ? video_codec_name :
4099 *opt == 'a' ? audio_codec_name :
4100 subtitle_codec_name;
4102 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4103 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4104 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4106 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4111 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4112 if(line[0] == '#' && !e)
4114 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4116 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4119 if(!strcmp(tmp, "acodec")){
4120 opt_audio_codec(o, tmp, tmp2);
4121 }else if(!strcmp(tmp, "vcodec")){
4122 opt_video_codec(o, tmp, tmp2);
4123 }else if(!strcmp(tmp, "scodec")){
4124 opt_subtitle_codec(o, tmp, tmp2);
4125 }else if(!strcmp(tmp, "dcodec")){
4126 opt_data_codec(o, tmp, tmp2);
4127 }else if(opt_default(tmp, tmp2) < 0){
4128 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4138 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4142 static int opt_passlogfile(const char *opt, const char *arg)
4144 pass_logfilename_prefix = arg;
4145 #if CONFIG_LIBX264_ENCODER
4146 return opt_default("passlogfile", arg);
4152 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4154 char *s= av_malloc(strlen(opt)+2);
4155 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4156 return parse_option(o, s, arg, options);
4159 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4161 if(!strcmp(opt, "b")){
4162 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4163 return parse_option(o, av_strdup("b:v"), arg, options);
4165 return opt_default(opt, arg);
4168 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4170 return parse_option(o, "filter:v", arg, options);
4173 #define OFFSET(x) offsetof(OptionsContext, x)
4174 static const OptionDef options[] = {
4176 #include "cmdutils_common_opts.h"
4177 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4178 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4179 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4180 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4181 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4182 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4183 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4184 "outfile[,metadata]:infile[,metadata]" },
4185 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4186 "outfile[,metadata]:infile[,metadata]" },
4187 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4188 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4189 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4190 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4191 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4192 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4193 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4194 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4195 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4196 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4197 "add timings for benchmarking" },
4198 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4199 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4200 "dump each input packet" },
4201 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4202 "when dumping packets, also dump the payload" },
4203 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4204 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4205 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4206 { "v", HAS_ARG, {(void*)opt_verbose}, "deprecated, use -loglevel instead", "number" },
4207 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4208 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4209 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4210 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4211 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4212 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4213 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4214 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4215 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4216 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4217 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4218 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4219 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4220 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4222 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4226 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4227 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4228 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4229 { "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" },
4230 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4231 { "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" },
4232 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4233 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4234 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4235 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4236 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4237 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4238 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4239 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4240 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4241 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4242 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4243 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4244 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4245 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4246 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4247 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4248 "use same quantizer as source (implies VBR)" },
4249 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4250 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4251 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4252 "deinterlace pictures" },
4253 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4254 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4256 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4258 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4259 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4260 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4261 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4262 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4263 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4264 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4265 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4266 { "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" },
4267 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4270 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4271 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4272 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4273 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4274 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4275 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4276 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4277 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4278 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4280 /* subtitle options */
4281 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4282 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4283 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4286 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4287 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4288 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4291 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4292 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4294 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4295 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4296 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4298 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4299 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4300 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4301 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4302 /* data codec support */
4303 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4305 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4309 int main(int argc, char **argv)
4311 OptionsContext o = { 0 };
4314 reset_options(&o, 0);
4316 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4317 parse_loglevel(argc, argv, options);
4319 if(argc>1 && !strcmp(argv[1], "-d")){
4321 av_log_set_callback(log_callback_null);
4326 avcodec_register_all();
4328 avdevice_register_all();
4331 avfilter_register_all();
4336 if(isatty(STDIN_FILENO))
4337 avio_set_interrupt_cb(decode_interrupt_cb);
4343 parse_options(&o, argc, argv, options, opt_output_file);
4345 if(nb_output_files <= 0 && nb_input_files == 0) {
4347 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4351 /* file converter / grab */
4352 if (nb_output_files <= 0) {
4353 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4357 if (nb_input_files == 0) {
4358 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4363 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4365 ti = getutime() - ti;
4367 int maxrss = getmaxrss() / 1024;
4368 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);