3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
49 #include "libavformat/ffm.h" // not public API
52 # include "libavfilter/avcodec.h"
53 # include "libavfilter/avfilter.h"
54 # include "libavfilter/avfiltergraph.h"
55 # include "libavfilter/buffersink.h"
56 # include "libavfilter/vsrc_buffer.h"
59 #if HAVE_SYS_RESOURCE_H
60 #include <sys/types.h>
62 #include <sys/resource.h>
63 #elif HAVE_GETPROCESSTIMES
66 #if HAVE_GETPROCESSMEMORYINFO
72 #include <sys/select.h>
77 #include <sys/ioctl.h>
87 #include "libavutil/avassert.h"
89 const char program_name[] = "ffmpeg";
90 const int program_birth_year = 2000;
92 /* select an input stream for an output stream */
93 typedef struct StreamMap {
94 int disabled; /** 1 is this mapping is disabled by a negative map */
98 int sync_stream_index;
102 * select an input file for an output file
104 typedef struct MetadataMap {
105 int file; ///< file index
106 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
107 int index; ///< stream/chapter/program number
110 static const OptionDef options[];
112 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
114 /* indexed by output file stream index */
115 static int *streamid_map = NULL;
116 static int nb_streamid_map = 0;
118 static int frame_width = 0;
119 static int frame_height = 0;
120 static float frame_aspect_ratio = 0;
121 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
122 static int frame_bits_per_raw_sample = 0;
123 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
124 static AVRational frame_rate;
125 static float video_qscale = 0;
126 static uint16_t *intra_matrix = NULL;
127 static uint16_t *inter_matrix = NULL;
128 static const char *video_rc_override_string=NULL;
129 static int video_disable = 0;
130 static int video_discard = 0;
131 static char *video_codec_name = NULL;
132 static unsigned int video_codec_tag = 0;
133 static char *video_language = NULL;
134 static int same_quant = 0;
135 static int do_deinterlace = 0;
136 static int top_field_first = -1;
137 static int me_threshold = 0;
138 static int intra_dc_precision = 8;
139 static int loop_input = 0;
140 static int loop_output = AVFMT_NOOUTPUTLOOP;
141 static int qp_hist = 0;
143 static char *vfilters = NULL;
146 static int intra_only = 0;
147 static int audio_sample_rate = 0;
148 #define QSCALE_NONE -99999
149 static float audio_qscale = QSCALE_NONE;
150 static int audio_disable = 0;
151 static int audio_channels = 0;
152 static char *audio_codec_name = NULL;
153 static unsigned int audio_codec_tag = 0;
154 static char *audio_language = NULL;
156 static int subtitle_disable = 0;
157 static char *subtitle_codec_name = NULL;
158 static char *subtitle_language = NULL;
159 static unsigned int subtitle_codec_tag = 0;
161 static int data_disable = 0;
162 static char *data_codec_name = NULL;
163 static unsigned int data_codec_tag = 0;
165 static int file_overwrite = 0;
166 static int do_benchmark = 0;
167 static int do_hex_dump = 0;
168 static int do_pkt_dump = 0;
169 static int do_psnr = 0;
170 static int do_pass = 0;
171 static const char *pass_logfilename_prefix;
172 static int video_sync_method= -1;
173 static int audio_sync_method= 0;
174 static float audio_drift_threshold= 0.1;
175 static int copy_ts= 0;
176 static int copy_tb= 0;
177 static int opt_shortest = 0;
178 static char *vstats_filename;
179 static FILE *vstats_file;
180 static int opt_programid = 0;
181 static int copy_initial_nonkeyframes = 0;
183 static int audio_volume = 256;
185 static int exit_on_error = 0;
186 static int using_stdin = 0;
187 static int verbose = 1;
188 static int run_as_daemon = 0;
189 static int thread_count= 1;
190 static int q_pressed = 0;
191 static int64_t video_size = 0;
192 static int64_t audio_size = 0;
193 static int64_t extra_size = 0;
194 static int nb_frames_dup = 0;
195 static int nb_frames_drop = 0;
196 static int input_sync;
197 static int force_fps = 0;
198 static char *forced_key_frames = NULL;
200 static float dts_delta_threshold = 10;
202 static uint8_t *audio_buf;
203 static uint8_t *audio_out;
204 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
206 static short *samples;
207 static uint8_t *input_tmp= NULL;
209 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
211 typedef struct InputStream {
214 int discard; /* true if stream data should be discarded */
215 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
218 int64_t start; /* time when read started */
219 int64_t next_pts; /* synthetic pts for cases where pkt.pts
221 int64_t pts; /* current pts */
223 int is_start; /* is 1 at the start and after a discontinuity */
224 int showed_multi_packet_warning;
228 typedef struct InputFile {
229 AVFormatContext *ctx;
230 int eof_reached; /* true if eof reached */
231 int ist_index; /* index of first stream in ist_table */
232 int buffer_size; /* current total buffer size */
234 int nb_streams; /* number of stream that avconv is aware of; may be different
235 from ctx.nb_streams if new streams appear during av_read_frame() */
239 typedef struct OutputStream {
240 int file_index; /* file index */
241 int index; /* stream index in the output file */
242 int source_index; /* InputStream index */
243 AVStream *st; /* stream in the output file */
244 int encoding_needed; /* true if encoding needed for this stream */
246 /* input pts and corresponding output pts
248 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
249 struct InputStream *sync_ist; /* input stream to sync against */
250 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
251 AVBitStreamFilterContext *bitstream_filters;
257 AVFrame resample_frame; /* temporary frame for image resampling */
258 struct SwsContext *img_resample_ctx; /* for image resampling */
261 int resample_pix_fmt;
262 AVRational frame_rate;
264 float frame_aspect_ratio;
266 /* forced key frames */
267 int64_t *forced_kf_pts;
273 ReSampleContext *resample; /* for audio resampling */
274 int resample_sample_fmt;
275 int resample_channels;
276 int resample_sample_rate;
278 AVAudioConvert *reformat_ctx;
279 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
283 AVFilterContext *output_video_filter;
284 AVFilterContext *input_video_filter;
285 AVFilterBufferRef *picref;
287 AVFilterGraph *graph;
292 int is_past_recording_time;
298 /* init terminal so that we can grab keys */
299 static struct termios oldtty;
302 typedef struct OutputFile {
303 AVFormatContext *ctx;
305 int ost_index; /* index of the first stream in output_streams */
306 int64_t recording_time; /* desired length of the resulting file in microseconds */
307 int64_t start_time; /* start time in microseconds */
308 uint64_t limit_filesize;
311 static InputStream *input_streams = NULL;
312 static int nb_input_streams = 0;
313 static InputFile *input_files = NULL;
314 static int nb_input_files = 0;
316 static OutputStream *output_streams = NULL;
317 static int nb_output_streams = 0;
318 static OutputFile *output_files = NULL;
319 static int nb_output_files = 0;
321 typedef struct OptionsContext {
322 /* input/output options */
326 SpecifierOpt *codec_names;
330 int64_t input_ts_offset;
333 SpecifierOpt *ts_scale;
337 StreamMap *stream_maps;
339 /* first item specifies output metadata, second is input */
340 MetadataMap (*meta_data_maps)[2];
341 int nb_meta_data_maps;
342 int metadata_global_manual;
343 int metadata_streams_manual;
344 int metadata_chapters_manual;
346 int chapters_input_file;
348 int64_t recording_time;
349 uint64_t limit_filesize;
353 SpecifierOpt *metadata;
355 SpecifierOpt *max_frames;
357 SpecifierOpt *bitstream_filters;
358 int nb_bitstream_filters;
361 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
364 for (i = 0; i < o->nb_ ## name; i++) {\
365 char *spec = o->name[i].specifier;\
366 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
367 outvar = o->name[i].u.type;\
373 static void reset_options(OptionsContext *o, int is_input)
375 const OptionDef *po = options;
376 OptionsContext bak= *o;
378 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
380 void *dst = (uint8_t*)o + po->u.off;
382 if (po->flags & OPT_SPEC) {
383 SpecifierOpt **so = dst;
384 int i, *count = (int*)(so + 1);
385 for (i = 0; i < *count; i++) {
386 av_freep(&(*so)[i].specifier);
387 if (po->flags & OPT_STRING)
388 av_freep(&(*so)[i].u.str);
392 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
397 av_freep(&o->stream_maps);
398 av_freep(&o->meta_data_maps);
400 memset(o, 0, sizeof(*o));
402 if(is_input) o->recording_time = bak.recording_time;
403 else o->recording_time = INT64_MAX;
404 o->mux_preload = 0.5;
405 o->mux_max_delay = 0.7;
406 o->limit_filesize = UINT64_MAX;
407 o->chapters_input_file = INT_MAX;
415 static int configure_video_filters(InputStream *ist, OutputStream *ost)
417 AVFilterContext *last_filter, *filter;
418 /** filter graph containing all filters including input & output */
419 AVCodecContext *codec = ost->st->codec;
420 AVCodecContext *icodec = ist->st->codec;
421 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
422 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
423 AVRational sample_aspect_ratio;
427 ost->graph = avfilter_graph_alloc();
429 if (ist->st->sample_aspect_ratio.num){
430 sample_aspect_ratio = ist->st->sample_aspect_ratio;
432 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
434 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
435 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
436 sample_aspect_ratio.num, sample_aspect_ratio.den);
438 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
439 "src", args, NULL, ost->graph);
442 #if FF_API_OLD_VSINK_API
443 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
444 "out", NULL, pix_fmts, ost->graph);
446 buffersink_params->pixel_fmts = pix_fmts;
447 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
448 "out", NULL, buffersink_params, ost->graph);
450 av_freep(&buffersink_params);
453 last_filter = ost->input_video_filter;
455 if (codec->width != icodec->width || codec->height != icodec->height) {
456 snprintf(args, 255, "%d:%d:flags=0x%X",
460 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
461 NULL, args, NULL, ost->graph)) < 0)
463 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
465 last_filter = filter;
468 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
469 ost->graph->scale_sws_opts = av_strdup(args);
472 AVFilterInOut *outputs = avfilter_inout_alloc();
473 AVFilterInOut *inputs = avfilter_inout_alloc();
475 outputs->name = av_strdup("in");
476 outputs->filter_ctx = last_filter;
477 outputs->pad_idx = 0;
478 outputs->next = NULL;
480 inputs->name = av_strdup("out");
481 inputs->filter_ctx = ost->output_video_filter;
485 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
487 av_freep(&ost->avfilter);
489 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
493 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
496 codec->width = ost->output_video_filter->inputs[0]->w;
497 codec->height = ost->output_video_filter->inputs[0]->h;
498 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
499 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
500 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
501 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
505 #endif /* CONFIG_AVFILTER */
507 static void term_exit(void)
509 av_log(NULL, AV_LOG_QUIET, "%s", "");
512 tcsetattr (0, TCSANOW, &oldtty);
516 static volatile int received_sigterm = 0;
519 sigterm_handler(int sig)
521 received_sigterm = sig;
526 static void term_init(void)
536 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
537 |INLCR|IGNCR|ICRNL|IXON);
538 tty.c_oflag |= OPOST;
539 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
540 tty.c_cflag &= ~(CSIZE|PARENB);
545 tcsetattr (0, TCSANOW, &tty);
546 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
550 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
551 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
553 signal(SIGXCPU, sigterm_handler);
557 /* read a key without blocking */
558 static int read_key(void)
573 n = select(1, &rfds, NULL, NULL, &tv);
582 # if HAVE_PEEKNAMEDPIPE
584 static HANDLE input_handle;
587 input_handle = GetStdHandle(STD_INPUT_HANDLE);
588 is_pipe = !GetConsoleMode(input_handle, &dw);
591 if (stdin->_cnt > 0) {
596 /* When running under a GUI, you will end here. */
597 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
614 static int decode_interrupt_cb(void)
616 q_pressed += read_key() == 'q';
617 return q_pressed > 1;
620 void exit_program(int ret)
625 for(i=0;i<nb_output_files;i++) {
626 AVFormatContext *s = output_files[i].ctx;
627 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
629 avformat_free_context(s);
630 av_dict_free(&output_files[i].opts);
632 for(i=0;i<nb_input_files;i++) {
633 av_close_input_file(input_files[i].ctx);
635 for (i = 0; i < nb_input_streams; i++)
636 av_dict_free(&input_streams[i].opts);
638 av_free(intra_matrix);
639 av_free(inter_matrix);
643 av_free(vstats_filename);
645 av_freep(&input_streams);
646 av_freep(&input_files);
647 av_freep(&output_streams);
648 av_freep(&output_files);
653 allocated_audio_buf_size= allocated_audio_out_size= 0;
660 av_freep(&input_tmp);
662 if (received_sigterm) {
664 "Received signal %d: terminating.\n",
665 (int) received_sigterm);
669 exit(ret); /* not all OS-es handle main() return value */
672 static void assert_avoptions(AVDictionary *m)
674 AVDictionaryEntry *t;
675 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
676 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
681 static void assert_codec_experimental(AVCodecContext *c, int encoder)
683 const char *codec_string = encoder ? "encoder" : "decoder";
685 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
686 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
687 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
688 "results.\nAdd '-strict experimental' if you want to use it.\n",
689 codec_string, c->codec->name);
690 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
691 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
692 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
693 codec_string, codec->name);
698 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
700 if(codec && codec->sample_fmts){
701 const enum AVSampleFormat *p= codec->sample_fmts;
703 if(*p == st->codec->sample_fmt)
707 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
708 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
709 if(av_get_sample_fmt_name(st->codec->sample_fmt))
710 av_log(NULL, AV_LOG_WARNING,
711 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
712 av_get_sample_fmt_name(st->codec->sample_fmt),
714 av_get_sample_fmt_name(codec->sample_fmts[0]));
715 st->codec->sample_fmt = codec->sample_fmts[0];
720 static void choose_sample_rate(AVStream *st, AVCodec *codec)
722 if(codec && codec->supported_samplerates){
723 const int *p= codec->supported_samplerates;
725 int best_dist=INT_MAX;
727 int dist= abs(st->codec->sample_rate - *p);
728 if(dist < best_dist){
734 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
736 st->codec->sample_rate= best;
740 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
742 if(codec && codec->pix_fmts){
743 const enum PixelFormat *p= codec->pix_fmts;
744 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
745 if(st->codec->codec_id==CODEC_ID_MJPEG){
746 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
747 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
748 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};
752 if(*p == st->codec->pix_fmt)
756 if(st->codec->pix_fmt != PIX_FMT_NONE)
757 av_log(NULL, AV_LOG_WARNING,
758 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
759 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
761 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
762 st->codec->pix_fmt = codec->pix_fmts[0];
768 get_sync_ipts(const OutputStream *ost)
770 const InputStream *ist = ost->sync_ist;
771 OutputFile *of = &output_files[ost->file_index];
772 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
775 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
779 AVPacket new_pkt= *pkt;
780 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
781 &new_pkt.data, &new_pkt.size,
782 pkt->data, pkt->size,
783 pkt->flags & AV_PKT_FLAG_KEY);
786 new_pkt.destruct= av_destruct_packet;
788 fprintf(stderr, "%s failed for stream %d, codec %s",
789 bsfc->filter->name, pkt->stream_index,
790 avctx->codec ? avctx->codec->name : "copy");
800 ret= av_interleaved_write_frame(s, pkt);
802 print_error("av_interleaved_write_frame()", ret);
807 static void do_audio_out(AVFormatContext *s,
810 unsigned char *buf, int size)
813 int64_t audio_out_size, audio_buf_size;
814 int64_t allocated_for_size= size;
816 int size_out, frame_bytes, ret, resample_changed;
817 AVCodecContext *enc= ost->st->codec;
818 AVCodecContext *dec= ist->st->codec;
819 int osize = av_get_bytes_per_sample(enc->sample_fmt);
820 int isize = av_get_bytes_per_sample(dec->sample_fmt);
821 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
824 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
825 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
826 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
827 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
828 audio_buf_size*= osize*enc->channels;
830 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
831 if(coded_bps > 8*osize)
832 audio_out_size= audio_out_size * coded_bps / (8*osize);
833 audio_out_size += FF_MIN_BUFFER_SIZE;
835 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
836 fprintf(stderr, "Buffer sizes too large\n");
840 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
841 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
842 if (!audio_buf || !audio_out){
843 fprintf(stderr, "Out of memory in do_audio_out\n");
847 if (enc->channels != dec->channels)
848 ost->audio_resample = 1;
850 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
851 ost->resample_channels != dec->channels ||
852 ost->resample_sample_rate != dec->sample_rate;
854 if ((ost->audio_resample && !ost->resample) || resample_changed) {
855 if (resample_changed) {
856 av_log(NULL, AV_LOG_INFO, "Input stream #%d.%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
857 ist->file_index, ist->st->index,
858 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
859 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
860 ost->resample_sample_fmt = dec->sample_fmt;
861 ost->resample_channels = dec->channels;
862 ost->resample_sample_rate = dec->sample_rate;
864 audio_resample_close(ost->resample);
866 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
867 if (audio_sync_method <= 1 &&
868 ost->resample_sample_fmt == enc->sample_fmt &&
869 ost->resample_channels == enc->channels &&
870 ost->resample_sample_rate == enc->sample_rate) {
871 ost->resample = NULL;
872 ost->audio_resample = 0;
874 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
875 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
876 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
877 enc->sample_rate, dec->sample_rate,
878 enc->sample_fmt, dec->sample_fmt,
880 if (!ost->resample) {
881 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
882 dec->channels, dec->sample_rate,
883 enc->channels, enc->sample_rate);
889 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
890 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
891 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
892 if (ost->reformat_ctx)
893 av_audio_convert_free(ost->reformat_ctx);
894 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
895 dec->sample_fmt, 1, NULL, 0);
896 if (!ost->reformat_ctx) {
897 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
898 av_get_sample_fmt_name(dec->sample_fmt),
899 av_get_sample_fmt_name(enc->sample_fmt));
902 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
905 if(audio_sync_method){
906 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
907 - av_fifo_size(ost->fifo)/(enc->channels * 2);
908 double idelta= delta*dec->sample_rate / enc->sample_rate;
909 int byte_delta= ((int)idelta)*2*dec->channels;
911 //FIXME resample delay
912 if(fabs(delta) > 50){
913 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
915 byte_delta= FFMAX(byte_delta, -size);
919 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
924 input_tmp= av_realloc(input_tmp, byte_delta + size);
926 if(byte_delta > allocated_for_size - size){
927 allocated_for_size= byte_delta + (int64_t)size;
932 memset(input_tmp, 0, byte_delta);
933 memcpy(input_tmp + byte_delta, buf, size);
937 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
939 }else if(audio_sync_method>1){
940 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
941 av_assert0(ost->audio_resample);
943 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
944 // 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));
945 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
949 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
950 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
952 if (ost->audio_resample) {
954 size_out = audio_resample(ost->resample,
955 (short *)buftmp, (short *)buf,
956 size / (dec->channels * isize));
957 size_out = size_out * enc->channels * osize;
963 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
964 const void *ibuf[6]= {buftmp};
965 void *obuf[6]= {audio_buf};
966 int istride[6]= {isize};
967 int ostride[6]= {osize};
968 int len= size_out/istride[0];
969 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
970 printf("av_audio_convert() failed\n");
976 size_out = len*osize;
979 /* now encode as many frames as possible */
980 if (enc->frame_size > 1) {
981 /* output resampled raw samples */
982 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
983 fprintf(stderr, "av_fifo_realloc2() failed\n");
986 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
988 frame_bytes = enc->frame_size * osize * enc->channels;
990 while (av_fifo_size(ost->fifo) >= frame_bytes) {
992 av_init_packet(&pkt);
994 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
996 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
998 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1001 fprintf(stderr, "Audio encoding failed\n");
1005 pkt.stream_index= ost->index;
1006 pkt.data= audio_out;
1008 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1009 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1010 pkt.flags |= AV_PKT_FLAG_KEY;
1011 write_frame(s, &pkt, enc, ost->bitstream_filters);
1013 ost->sync_opts += enc->frame_size;
1017 av_init_packet(&pkt);
1019 ost->sync_opts += size_out / (osize * enc->channels);
1021 /* output a pcm frame */
1022 /* determine the size of the coded buffer */
1025 size_out = size_out*coded_bps/8;
1027 if(size_out > audio_out_size){
1028 fprintf(stderr, "Internal error, buffer size too small\n");
1032 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1033 ret = avcodec_encode_audio(enc, audio_out, size_out,
1036 fprintf(stderr, "Audio encoding failed\n");
1040 pkt.stream_index= ost->index;
1041 pkt.data= audio_out;
1043 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1044 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1045 pkt.flags |= AV_PKT_FLAG_KEY;
1046 write_frame(s, &pkt, enc, ost->bitstream_filters);
1050 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1052 AVCodecContext *dec;
1053 AVPicture *picture2;
1054 AVPicture picture_tmp;
1057 dec = ist->st->codec;
1059 /* deinterlace : must be done before any resize */
1060 if (do_deinterlace) {
1063 /* create temporary picture */
1064 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1065 buf = av_malloc(size);
1069 picture2 = &picture_tmp;
1070 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1072 if(avpicture_deinterlace(picture2, picture,
1073 dec->pix_fmt, dec->width, dec->height) < 0) {
1074 /* if error, do not deinterlace */
1075 fprintf(stderr, "Deinterlacing failed\n");
1084 if (picture != picture2)
1085 *picture = *picture2;
1089 static void do_subtitle_out(AVFormatContext *s,
1095 static uint8_t *subtitle_out = NULL;
1096 int subtitle_out_max_size = 1024 * 1024;
1097 int subtitle_out_size, nb, i;
1098 AVCodecContext *enc;
1101 if (pts == AV_NOPTS_VALUE) {
1102 fprintf(stderr, "Subtitle packets must have a pts\n");
1108 enc = ost->st->codec;
1110 if (!subtitle_out) {
1111 subtitle_out = av_malloc(subtitle_out_max_size);
1114 /* Note: DVB subtitle need one packet to draw them and one other
1115 packet to clear them */
1116 /* XXX: signal it in the codec context ? */
1117 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1122 for(i = 0; i < nb; i++) {
1123 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1124 // start_display_time is required to be 0
1125 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1126 sub->end_display_time -= sub->start_display_time;
1127 sub->start_display_time = 0;
1128 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1129 subtitle_out_max_size, sub);
1130 if (subtitle_out_size < 0) {
1131 fprintf(stderr, "Subtitle encoding failed\n");
1135 av_init_packet(&pkt);
1136 pkt.stream_index = ost->index;
1137 pkt.data = subtitle_out;
1138 pkt.size = subtitle_out_size;
1139 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1140 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1141 /* XXX: the pts correction is handled here. Maybe handling
1142 it in the codec would be better */
1144 pkt.pts += 90 * sub->start_display_time;
1146 pkt.pts += 90 * sub->end_display_time;
1148 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1152 static int bit_buffer_size= 1024*256;
1153 static uint8_t *bit_buffer= NULL;
1155 static void do_video_resample(OutputStream *ost,
1157 AVFrame *in_picture,
1158 AVFrame **out_picture)
1161 *out_picture = in_picture;
1163 AVCodecContext *dec = ist->st->codec;
1164 AVCodecContext *enc = ost->st->codec;
1165 int resample_changed = ost->resample_width != dec->width ||
1166 ost->resample_height != dec->height ||
1167 ost->resample_pix_fmt != dec->pix_fmt;
1169 *out_picture = in_picture;
1170 if (resample_changed) {
1171 av_log(NULL, AV_LOG_INFO,
1172 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1173 ist->file_index, ist->st->index,
1174 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1175 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1176 ost->resample_width = dec->width;
1177 ost->resample_height = dec->height;
1178 ost->resample_pix_fmt = dec->pix_fmt;
1181 ost->video_resample = dec->width != enc->width ||
1182 dec->height != enc->height ||
1183 dec->pix_fmt != enc->pix_fmt;
1185 if (ost->video_resample) {
1186 *out_picture = &ost->resample_frame;
1187 if (!ost->img_resample_ctx || resample_changed) {
1188 /* initialize the destination picture */
1189 if (!ost->resample_frame.data[0]) {
1190 avcodec_get_frame_defaults(&ost->resample_frame);
1191 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1192 enc->width, enc->height)) {
1193 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1197 /* initialize a new scaler context */
1198 sws_freeContext(ost->img_resample_ctx);
1199 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1200 enc->width, enc->height, enc->pix_fmt,
1201 ost->sws_flags, NULL, NULL, NULL);
1202 if (ost->img_resample_ctx == NULL) {
1203 fprintf(stderr, "Cannot get resampling context\n");
1207 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1208 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1214 static void do_video_out(AVFormatContext *s,
1217 AVFrame *in_picture,
1218 int *frame_size, float quality)
1220 int nb_frames, i, ret, format_video_sync;
1221 AVFrame *final_picture;
1222 AVCodecContext *enc;
1225 enc = ost->st->codec;
1227 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1229 /* by default, we output a single frame */
1234 format_video_sync = video_sync_method;
1235 if (format_video_sync < 0)
1236 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1238 if (format_video_sync) {
1239 double vdelta = sync_ipts - ost->sync_opts;
1240 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1243 else if (format_video_sync == 2) {
1246 }else if(vdelta>0.6)
1247 ost->sync_opts= lrintf(sync_ipts);
1248 }else if (vdelta > 1.1)
1249 nb_frames = lrintf(vdelta);
1250 //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);
1251 if (nb_frames == 0){
1254 fprintf(stderr, "*** drop!\n");
1255 }else if (nb_frames > 1) {
1256 nb_frames_dup += nb_frames - 1;
1258 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1261 ost->sync_opts= lrintf(sync_ipts);
1263 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1267 do_video_resample(ost, ist, in_picture, &final_picture);
1269 /* duplicates frame if needed */
1270 for(i=0;i<nb_frames;i++) {
1272 av_init_packet(&pkt);
1273 pkt.stream_index= ost->index;
1275 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1276 /* raw pictures are written as AVPicture structure to
1277 avoid any copies. We support temporarily the older
1279 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1280 enc->coded_frame->top_field_first = in_picture->top_field_first;
1281 pkt.data= (uint8_t *)final_picture;
1282 pkt.size= sizeof(AVPicture);
1283 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1284 pkt.flags |= AV_PKT_FLAG_KEY;
1286 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1288 AVFrame big_picture;
1290 big_picture= *final_picture;
1291 /* better than nothing: use input picture interlaced
1293 big_picture.interlaced_frame = in_picture->interlaced_frame;
1294 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1295 if(top_field_first == -1)
1296 big_picture.top_field_first = in_picture->top_field_first;
1298 big_picture.top_field_first = top_field_first;
1301 /* handles same_quant here. This is not correct because it may
1302 not be a global option */
1303 big_picture.quality = quality;
1305 big_picture.pict_type = 0;
1306 // big_picture.pts = AV_NOPTS_VALUE;
1307 big_picture.pts= ost->sync_opts;
1308 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1309 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1310 if (ost->forced_kf_index < ost->forced_kf_count &&
1311 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1312 big_picture.pict_type = AV_PICTURE_TYPE_I;
1313 ost->forced_kf_index++;
1315 ret = avcodec_encode_video(enc,
1316 bit_buffer, bit_buffer_size,
1319 fprintf(stderr, "Video encoding failed\n");
1324 pkt.data= bit_buffer;
1326 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1327 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1328 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1329 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1330 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1332 if(enc->coded_frame->key_frame)
1333 pkt.flags |= AV_PKT_FLAG_KEY;
1334 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1337 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1338 // enc->frame_number-1, ret, enc->pict_type);
1339 /* if two pass, output log */
1340 if (ost->logfile && enc->stats_out) {
1341 fprintf(ost->logfile, "%s", enc->stats_out);
1346 ost->frame_number++;
1350 static double psnr(double d){
1351 return -10.0*log(d)/log(10.0);
1354 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1357 AVCodecContext *enc;
1359 double ti1, bitrate, avg_bitrate;
1361 /* this is executed just the first time do_video_stats is called */
1363 vstats_file = fopen(vstats_filename, "w");
1370 enc = ost->st->codec;
1371 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1372 frame_number = ost->frame_number;
1373 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1374 if (enc->flags&CODEC_FLAG_PSNR)
1375 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1377 fprintf(vstats_file,"f_size= %6d ", frame_size);
1378 /* compute pts value */
1379 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1383 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1384 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1385 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1386 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1387 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1391 static void print_report(OutputFile *output_files,
1392 OutputStream *ost_table, int nb_ostreams,
1393 int is_last_report, int64_t timer_start)
1397 AVFormatContext *oc;
1399 AVCodecContext *enc;
1400 int frame_number, vid, i;
1402 int64_t pts = INT64_MAX;
1403 static int64_t last_time = -1;
1404 static int qp_histogram[52];
1406 if (!is_last_report) {
1408 /* display the report every 0.5 seconds */
1409 cur_time = av_gettime();
1410 if (last_time == -1) {
1411 last_time = cur_time;
1414 if ((cur_time - last_time) < 500000)
1416 last_time = cur_time;
1420 oc = output_files[0].ctx;
1422 total_size = avio_size(oc->pb);
1423 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1424 total_size= avio_tell(oc->pb);
1428 for(i=0;i<nb_ostreams;i++) {
1430 ost = &ost_table[i];
1431 enc = ost->st->codec;
1432 if (!ost->st->stream_copy && enc->coded_frame)
1433 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1434 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1435 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1437 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1438 float t = (av_gettime()-timer_start) / 1000000.0;
1440 frame_number = ost->frame_number;
1441 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1442 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1444 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1448 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1451 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1453 if (enc->flags&CODEC_FLAG_PSNR){
1455 double error, error_sum=0;
1456 double scale, scale_sum=0;
1457 char type[3]= {'Y','U','V'};
1458 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1461 error= enc->error[j];
1462 scale= enc->width*enc->height*255.0*255.0*frame_number;
1464 error= enc->coded_frame->error[j];
1465 scale= enc->width*enc->height*255.0*255.0;
1470 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1472 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1476 /* compute min output value */
1477 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1478 ost->st->time_base, AV_TIME_BASE_Q));
1481 if (verbose > 0 || is_last_report) {
1482 int hours, mins, secs, us;
1483 secs = pts / AV_TIME_BASE;
1484 us = pts % AV_TIME_BASE;
1490 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1492 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1493 "size=%8.0fkB time=", total_size / 1024.0);
1494 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1495 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1496 (100 * us) / AV_TIME_BASE);
1497 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1498 "bitrate=%6.1fkbits/s", bitrate);
1500 if (nb_frames_dup || nb_frames_drop)
1501 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1502 nb_frames_dup, nb_frames_drop);
1505 fprintf(stderr, "%s \r", buf);
1510 if (is_last_report && verbose >= 0){
1511 int64_t raw= audio_size + video_size + extra_size;
1512 fprintf(stderr, "\n");
1513 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1517 100.0*(total_size - raw)/raw
1522 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1524 int fill_char = 0x00;
1525 if (sample_fmt == AV_SAMPLE_FMT_U8)
1527 memset(buf, fill_char, size);
1530 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1534 for (i = 0; i < nb_ostreams; i++) {
1535 OutputStream *ost = &ost_table[i];
1536 AVCodecContext *enc = ost->st->codec;
1537 AVFormatContext *os = output_files[ost->file_index].ctx;
1539 if (!ost->encoding_needed)
1542 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1544 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1550 av_init_packet(&pkt);
1551 pkt.stream_index= ost->index;
1553 switch (ost->st->codec->codec_type) {
1554 case AVMEDIA_TYPE_AUDIO:
1555 fifo_bytes = av_fifo_size(ost->fifo);
1557 /* encode any samples remaining in fifo */
1558 if (fifo_bytes > 0) {
1559 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1560 int fs_tmp = enc->frame_size;
1562 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1563 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1564 enc->frame_size = fifo_bytes / (osize * enc->channels);
1566 int frame_bytes = enc->frame_size*osize*enc->channels;
1567 if (allocated_audio_buf_size < frame_bytes)
1569 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1572 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1573 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1574 ost->st->time_base.num, enc->sample_rate);
1575 enc->frame_size = fs_tmp;
1578 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1581 fprintf(stderr, "Audio encoding failed\n");
1585 pkt.flags |= AV_PKT_FLAG_KEY;
1587 case AVMEDIA_TYPE_VIDEO:
1588 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1590 fprintf(stderr, "Video encoding failed\n");
1594 if(enc->coded_frame && enc->coded_frame->key_frame)
1595 pkt.flags |= AV_PKT_FLAG_KEY;
1596 if (ost->logfile && enc->stats_out) {
1597 fprintf(ost->logfile, "%s", enc->stats_out);
1606 pkt.data = bit_buffer;
1608 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1609 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1610 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1615 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1616 static int output_packet(InputStream *ist, int ist_index,
1617 OutputStream *ost_table, int nb_ostreams,
1618 const AVPacket *pkt)
1620 AVFormatContext *os;
1625 void *buffer_to_free = NULL;
1626 static unsigned int samples_size= 0;
1627 AVSubtitle subtitle, *subtitle_to_free;
1628 int64_t pkt_pts = AV_NOPTS_VALUE;
1630 int frame_available;
1635 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1637 if(ist->next_pts == AV_NOPTS_VALUE)
1638 ist->next_pts= ist->pts;
1642 av_init_packet(&avpkt);
1650 if(pkt->dts != AV_NOPTS_VALUE)
1651 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1652 if(pkt->pts != AV_NOPTS_VALUE)
1653 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1655 //while we have more to decode or while the decoder did output something on EOF
1656 while (avpkt.size > 0 || (!pkt && got_output)) {
1657 uint8_t *data_buf, *decoded_data_buf;
1658 int data_size, decoded_data_size;
1660 ist->pts= ist->next_pts;
1662 if(avpkt.size && avpkt.size != pkt->size &&
1663 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1664 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1665 ist->showed_multi_packet_warning=1;
1668 /* decode the packet if needed */
1669 decoded_data_buf = NULL; /* fail safe */
1670 decoded_data_size= 0;
1671 data_buf = avpkt.data;
1672 data_size = avpkt.size;
1673 subtitle_to_free = NULL;
1674 if (ist->decoding_needed) {
1675 switch(ist->st->codec->codec_type) {
1676 case AVMEDIA_TYPE_AUDIO:{
1677 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1678 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1680 samples= av_malloc(samples_size);
1682 decoded_data_size= samples_size;
1683 /* XXX: could avoid copy if PCM 16 bits with same
1684 endianness as CPU */
1685 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1692 got_output = decoded_data_size > 0;
1693 /* Some bug in mpeg audio decoder gives */
1694 /* decoded_data_size < 0, it seems they are overflows */
1696 /* no audio frame */
1699 decoded_data_buf = (uint8_t *)samples;
1700 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1701 (ist->st->codec->sample_rate * ist->st->codec->channels);
1703 case AVMEDIA_TYPE_VIDEO:
1704 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1705 /* XXX: allocate picture correctly */
1706 avcodec_get_frame_defaults(&picture);
1707 avpkt.pts = pkt_pts;
1708 avpkt.dts = ist->pts;
1709 pkt_pts = AV_NOPTS_VALUE;
1711 ret = avcodec_decode_video2(ist->st->codec,
1712 &picture, &got_output, &avpkt);
1713 quality = same_quant ? picture.quality : 0;
1717 /* no picture yet */
1718 goto discard_packet;
1720 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1721 if (ist->st->codec->time_base.num != 0) {
1722 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1723 ist->next_pts += ((int64_t)AV_TIME_BASE *
1724 ist->st->codec->time_base.num * ticks) /
1725 ist->st->codec->time_base.den;
1728 buffer_to_free = NULL;
1729 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1731 case AVMEDIA_TYPE_SUBTITLE:
1732 ret = avcodec_decode_subtitle2(ist->st->codec,
1733 &subtitle, &got_output, &avpkt);
1737 goto discard_packet;
1739 subtitle_to_free = &subtitle;
1746 switch(ist->st->codec->codec_type) {
1747 case AVMEDIA_TYPE_AUDIO:
1748 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1749 ist->st->codec->sample_rate;
1751 case AVMEDIA_TYPE_VIDEO:
1752 if (ist->st->codec->time_base.num != 0) {
1753 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1754 ist->next_pts += ((int64_t)AV_TIME_BASE *
1755 ist->st->codec->time_base.num * ticks) /
1756 ist->st->codec->time_base.den;
1764 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1765 for(i=0;i<nb_ostreams;i++) {
1766 OutputFile *of = &output_files[ost_table[i].file_index];
1767 if (of->start_time == 0 || ist->pts >= of->start_time) {
1768 ost = &ost_table[i];
1769 if (ost->input_video_filter && ost->source_index == ist_index) {
1770 if (!picture.sample_aspect_ratio.num)
1771 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1772 picture.pts = ist->pts;
1774 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1780 // preprocess audio (volume)
1781 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1782 if (audio_volume != 256) {
1785 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1786 int v = ((*volp) * audio_volume + 128) >> 8;
1787 *volp++ = av_clip_int16(v);
1792 /* frame rate emulation */
1793 if (input_files[ist->file_index].rate_emu) {
1794 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1795 int64_t now = av_gettime() - ist->start;
1799 /* if output time reached then transcode raw format,
1800 encode packets and output them */
1801 for (i = 0; i < nb_ostreams; i++) {
1802 OutputFile *of = &output_files[ost_table[i].file_index];
1805 ost = &ost_table[i];
1806 if (ost->source_index != ist_index)
1809 if (of->start_time && ist->pts < of->start_time)
1812 if (of->recording_time != INT64_MAX &&
1813 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1814 (AVRational){1, 1000000}) >= 0) {
1815 ost->is_past_recording_time = 1;
1820 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1821 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1822 while (frame_available) {
1823 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1824 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1825 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1828 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1829 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1833 os = output_files[ost->file_index].ctx;
1835 /* set the input output pts pairs */
1836 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1838 if (ost->encoding_needed) {
1839 av_assert0(ist->decoding_needed);
1840 switch(ost->st->codec->codec_type) {
1841 case AVMEDIA_TYPE_AUDIO:
1842 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1844 case AVMEDIA_TYPE_VIDEO:
1846 if (ost->picref->video && !ost->frame_aspect_ratio)
1847 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1849 do_video_out(os, ost, ist, &picture, &frame_size,
1850 same_quant ? quality : ost->st->codec->global_quality);
1851 if (vstats_filename && frame_size)
1852 do_video_stats(os, ost, frame_size);
1854 case AVMEDIA_TYPE_SUBTITLE:
1855 do_subtitle_out(os, ost, ist, &subtitle,
1862 AVFrame avframe; //FIXME/XXX remove this
1865 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1866 av_init_packet(&opkt);
1868 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1869 #if !CONFIG_AVFILTER
1875 /* no reencoding needed : output the packet directly */
1876 /* force the input stream PTS */
1878 avcodec_get_frame_defaults(&avframe);
1879 ost->st->codec->coded_frame= &avframe;
1880 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1882 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1883 audio_size += data_size;
1884 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1885 video_size += data_size;
1889 opkt.stream_index= ost->index;
1890 if(pkt->pts != AV_NOPTS_VALUE)
1891 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1893 opkt.pts= AV_NOPTS_VALUE;
1895 if (pkt->dts == AV_NOPTS_VALUE)
1896 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1898 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1899 opkt.dts -= ost_tb_start_time;
1901 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1902 opkt.flags= pkt->flags;
1904 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1905 if( ost->st->codec->codec_id != CODEC_ID_H264
1906 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1907 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1909 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1910 opkt.destruct= av_destruct_packet;
1912 opkt.data = data_buf;
1913 opkt.size = data_size;
1916 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1917 /* store AVPicture in AVPacket, as expected by the output format */
1918 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1919 opkt.data = (uint8_t *)&pict;
1920 opkt.size = sizeof(AVPicture);
1921 opkt.flags |= AV_PKT_FLAG_KEY;
1923 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1924 ost->st->codec->frame_number++;
1925 ost->frame_number++;
1926 av_free_packet(&opkt);
1930 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1931 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1932 avfilter_unref_buffer(ost->picref);
1937 av_free(buffer_to_free);
1938 /* XXX: allocate the subtitles in the codec ? */
1939 if (subtitle_to_free) {
1940 avsubtitle_free(subtitle_to_free);
1941 subtitle_to_free = NULL;
1949 static void print_sdp(OutputFile *output_files, int n)
1953 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1957 for (i = 0; i < n; i++)
1958 avc[i] = output_files[i].ctx;
1960 av_sdp_create(avc, n, sdp, sizeof(sdp));
1961 printf("SDP:\n%s\n", sdp);
1966 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1967 char *error, int error_len)
1969 InputStream *ist = &input_streams[ist_index];
1970 if (ist->decoding_needed) {
1971 AVCodec *codec = ist->dec;
1973 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
1974 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1975 return AVERROR(EINVAL);
1977 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1978 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1979 ist->file_index, ist->st->index);
1980 return AVERROR(EINVAL);
1982 assert_codec_experimental(ist->st->codec, 0);
1983 assert_avoptions(ist->opts);
1986 ist->pts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames*AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1987 ist->next_pts = AV_NOPTS_VALUE;
1993 static int transcode_init(OutputFile *output_files,
1994 int nb_output_files,
1995 InputFile *input_files,
1999 AVFormatContext *os;
2000 AVCodecContext *codec, *icodec;
2006 /* init framerate emulation */
2007 for (i = 0; i < nb_input_files; i++) {
2008 InputFile *ifile = &input_files[i];
2009 if (ifile->rate_emu)
2010 for (j = 0; j < ifile->nb_streams; j++)
2011 input_streams[j + ifile->ist_index].start = av_gettime();
2014 /* output stream init */
2015 for(i=0;i<nb_output_files;i++) {
2016 os = output_files[i].ctx;
2017 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2018 av_dump_format(os, i, os->filename, 1);
2019 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
2020 return AVERROR(EINVAL);
2024 /* for each output stream, we compute the right encoding parameters */
2025 for (i = 0; i < nb_output_streams; i++) {
2026 ost = &output_streams[i];
2027 os = output_files[ost->file_index].ctx;
2028 ist = &input_streams[ost->source_index];
2030 codec = ost->st->codec;
2031 icodec = ist->st->codec;
2033 ost->st->disposition = ist->st->disposition;
2034 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2035 codec->chroma_sample_location = icodec->chroma_sample_location;
2037 if (ost->st->stream_copy) {
2038 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2040 if (extra_size > INT_MAX) {
2041 return AVERROR(EINVAL);
2044 /* if stream_copy is selected, no need to decode or encode */
2045 codec->codec_id = icodec->codec_id;
2046 codec->codec_type = icodec->codec_type;
2048 if(!codec->codec_tag){
2049 if( !os->oformat->codec_tag
2050 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2051 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2052 codec->codec_tag = icodec->codec_tag;
2055 codec->bit_rate = icodec->bit_rate;
2056 codec->rc_max_rate = icodec->rc_max_rate;
2057 codec->rc_buffer_size = icodec->rc_buffer_size;
2058 codec->extradata= av_mallocz(extra_size);
2059 if (!codec->extradata) {
2060 return AVERROR(ENOMEM);
2062 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2063 codec->extradata_size= icodec->extradata_size;
2065 codec->time_base = ist->st->time_base;
2066 if(!strcmp(os->oformat->name, "avi")) {
2067 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){
2068 codec->time_base = icodec->time_base;
2069 codec->time_base.num *= icodec->ticks_per_frame;
2070 codec->time_base.den *= 2;
2072 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2073 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){
2074 codec->time_base = icodec->time_base;
2075 codec->time_base.num *= icodec->ticks_per_frame;
2078 av_reduce(&codec->time_base.num, &codec->time_base.den,
2079 codec->time_base.num, codec->time_base.den, INT_MAX);
2081 switch(codec->codec_type) {
2082 case AVMEDIA_TYPE_AUDIO:
2083 if(audio_volume != 256) {
2084 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2087 codec->channel_layout = icodec->channel_layout;
2088 codec->sample_rate = icodec->sample_rate;
2089 codec->channels = icodec->channels;
2090 codec->frame_size = icodec->frame_size;
2091 codec->audio_service_type = icodec->audio_service_type;
2092 codec->block_align= icodec->block_align;
2093 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2094 codec->block_align= 0;
2095 if(codec->codec_id == CODEC_ID_AC3)
2096 codec->block_align= 0;
2098 case AVMEDIA_TYPE_VIDEO:
2099 codec->pix_fmt = icodec->pix_fmt;
2100 codec->width = icodec->width;
2101 codec->height = icodec->height;
2102 codec->has_b_frames = icodec->has_b_frames;
2103 if (!codec->sample_aspect_ratio.num) {
2104 codec->sample_aspect_ratio =
2105 ost->st->sample_aspect_ratio =
2106 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2107 ist->st->codec->sample_aspect_ratio.num ?
2108 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2111 case AVMEDIA_TYPE_SUBTITLE:
2112 codec->width = icodec->width;
2113 codec->height = icodec->height;
2115 case AVMEDIA_TYPE_DATA:
2122 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2123 switch(codec->codec_type) {
2124 case AVMEDIA_TYPE_AUDIO:
2125 ost->fifo= av_fifo_alloc(1024);
2127 return AVERROR(ENOMEM);
2129 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2130 if (!codec->sample_rate) {
2131 codec->sample_rate = icodec->sample_rate;
2133 choose_sample_rate(ost->st, ost->enc);
2134 codec->time_base = (AVRational){1, codec->sample_rate};
2135 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2136 codec->sample_fmt = icodec->sample_fmt;
2137 choose_sample_fmt(ost->st, ost->enc);
2138 if (!codec->channels) {
2139 codec->channels = icodec->channels;
2140 codec->channel_layout = icodec->channel_layout;
2142 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2143 codec->channel_layout = 0;
2144 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2145 icodec->request_channels = codec->channels;
2146 ist->decoding_needed = 1;
2147 ost->encoding_needed = 1;
2148 ost->resample_sample_fmt = icodec->sample_fmt;
2149 ost->resample_sample_rate = icodec->sample_rate;
2150 ost->resample_channels = icodec->channels;
2152 case AVMEDIA_TYPE_VIDEO:
2153 if (codec->pix_fmt == PIX_FMT_NONE)
2154 codec->pix_fmt = icodec->pix_fmt;
2155 choose_pixel_fmt(ost->st, ost->enc);
2157 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2158 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2162 if (!codec->width || !codec->height) {
2163 codec->width = icodec->width;
2164 codec->height = icodec->height;
2167 ost->video_resample = codec->width != icodec->width ||
2168 codec->height != icodec->height ||
2169 codec->pix_fmt != icodec->pix_fmt;
2170 if (ost->video_resample) {
2171 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2174 ost->resample_height = icodec->height;
2175 ost->resample_width = icodec->width;
2176 ost->resample_pix_fmt= icodec->pix_fmt;
2177 ost->encoding_needed = 1;
2178 ist->decoding_needed = 1;
2180 if (!ost->frame_rate.num)
2181 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2182 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2183 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2184 ost->frame_rate = ost->enc->supported_framerates[idx];
2186 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2187 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2188 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2189 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2190 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2194 if (configure_video_filters(ist, ost)) {
2195 fprintf(stderr, "Error opening filters!\n");
2200 case AVMEDIA_TYPE_SUBTITLE:
2201 ost->encoding_needed = 1;
2202 ist->decoding_needed = 1;
2209 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2210 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2211 char logfilename[1024];
2214 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2215 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2217 if (codec->flags & CODEC_FLAG_PASS1) {
2218 f = fopen(logfilename, "wb");
2220 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2226 size_t logbuffer_size;
2227 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2228 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2231 codec->stats_in = logbuffer;
2235 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2236 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2237 int size= codec->width * codec->height;
2238 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2243 bit_buffer = av_malloc(bit_buffer_size);
2245 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2247 return AVERROR(ENOMEM);
2250 /* open each encoder */
2251 for (i = 0; i < nb_output_streams; i++) {
2252 ost = &output_streams[i];
2253 if (ost->encoding_needed) {
2254 AVCodec *codec = ost->enc;
2255 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2257 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2258 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2259 ret = AVERROR(EINVAL);
2262 if (dec->subtitle_header) {
2263 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2264 if (!ost->st->codec->subtitle_header) {
2265 ret = AVERROR(ENOMEM);
2268 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2269 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2271 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2272 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2273 ost->file_index, ost->index);
2274 ret = AVERROR(EINVAL);
2277 assert_codec_experimental(ost->st->codec, 1);
2278 assert_avoptions(ost->opts);
2279 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2280 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2281 "It takes bits/s as argument, not kbits/s\n");
2282 extra_size += ost->st->codec->extradata_size;
2286 /* init input streams */
2287 for (i = 0; i < nb_input_streams; i++)
2288 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2291 /* open files and write file headers */
2292 for (i = 0; i < nb_output_files; i++) {
2293 os = output_files[i].ctx;
2294 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2295 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2296 ret = AVERROR(EINVAL);
2299 // assert_avoptions(output_files[i].opts);
2300 if (strcmp(os->oformat->name, "rtp")) {
2306 /* dump the file output parameters - cannot be done before in case
2308 for(i=0;i<nb_output_files;i++) {
2309 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2312 /* dump the stream mapping */
2314 fprintf(stderr, "Stream mapping:\n");
2315 for (i = 0; i < nb_output_streams;i ++) {
2316 ost = &output_streams[i];
2317 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2318 input_streams[ost->source_index].file_index,
2319 input_streams[ost->source_index].st->index,
2322 if (ost->sync_ist != &input_streams[ost->source_index])
2323 fprintf(stderr, " [sync #%d.%d]",
2324 ost->sync_ist->file_index,
2325 ost->sync_ist->st->index);
2326 if (ost->st->stream_copy)
2327 fprintf(stderr, " (copy)");
2329 fprintf(stderr, " (%s -> %s)", input_streams[ost->source_index].dec ?
2330 input_streams[ost->source_index].dec->name : "?",
2331 ost->enc ? ost->enc->name : "?");
2332 fprintf(stderr, "\n");
2337 fprintf(stderr, "%s\n", error);
2342 print_sdp(output_files, nb_output_files);
2349 * The following code is the main loop of the file converter
2351 static int transcode(OutputFile *output_files,
2352 int nb_output_files,
2353 InputFile *input_files,
2357 AVFormatContext *is, *os;
2361 int no_packet_count=0;
2362 int64_t timer_start;
2365 if (!(no_packet = av_mallocz(nb_input_files)))
2368 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2374 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2375 avio_set_interrupt_cb(decode_interrupt_cb);
2379 timer_start = av_gettime();
2381 for(; received_sigterm == 0;) {
2382 int file_index, ist_index;
2387 ipts_min= INT64_MAX;
2389 /* if 'q' pressed, exits */
2393 /* read_key() returns 0 on EOF */
2397 if (key == '+') verbose++;
2398 if (key == '-') verbose--;
2399 if (key == 's') qp_hist ^= 1;
2402 do_hex_dump = do_pkt_dump = 0;
2403 } else if(do_pkt_dump){
2407 av_log_set_level(AV_LOG_DEBUG);
2410 if (key == 'c' || key == 'C'){
2411 char ret[4096], target[64], cmd[256], arg[256]={0};
2414 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2416 while((k=read_key()) !='\n' && k!='\r' && i<sizeof(ret)-1)
2417 if(k>0) ret[i++]= k;
2419 if(k>0 && sscanf(ret, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &ts, cmd, arg) >= 3){
2420 for(i=0;i<nb_output_streams;i++) {
2422 ost = &output_streams[i];
2425 r= avfilter_graph_send_command(ost->graph, target, cmd, arg, ret, sizeof(ret), key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2426 fprintf(stderr, "Command reply for %d: %d, %s\n", i, r, ret);
2428 r= avfilter_graph_queue_command(ost->graph, target, cmd, arg, 0, ts);
2433 fprintf(stderr, "Parse error\n");
2437 if (key == 'd' || key == 'D'){
2440 debug = input_streams[0].st->codec->debug<<1;
2441 if(!debug) debug = 1;
2442 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2445 scanf("%d", &debug);
2446 for(i=0;i<nb_input_streams;i++) {
2447 input_streams[i].st->codec->debug = debug;
2449 for(i=0;i<nb_output_streams;i++) {
2450 ost = &output_streams[i];
2451 ost->st->codec->debug = debug;
2453 if(debug) av_log_set_level(AV_LOG_DEBUG);
2454 fprintf(stderr,"debug=%d\n", debug);
2457 fprintf(stderr, "key function\n"
2458 "? show this help\n"
2459 "+ increase verbosity\n"
2460 "- decrease verbosity\n"
2461 "c Send command to filtergraph\n"
2462 "D cycle through available debug modes\n"
2463 "h dump packets/hex press to cycle through the 3 states\n"
2465 "s Show QP histogram\n"
2470 /* select the stream that we must read now by looking at the
2471 smallest output pts */
2473 for (i = 0; i < nb_output_streams; i++) {
2477 ost = &output_streams[i];
2478 of = &output_files[ost->file_index];
2479 os = output_files[ost->file_index].ctx;
2480 ist = &input_streams[ost->source_index];
2481 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2482 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2484 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2486 if (!input_files[ist->file_index].eof_reached){
2487 if(ipts < ipts_min) {
2489 if(input_sync ) file_index = ist->file_index;
2491 if(opts < opts_min) {
2493 if(!input_sync) file_index = ist->file_index;
2496 if (ost->frame_number >= ost->max_frames) {
2498 for (j = of->ost_index; j < of->ctx->nb_streams; j++)
2499 output_streams[j].is_past_recording_time = 1;
2503 /* if none, if is finished */
2504 if (file_index < 0) {
2505 if(no_packet_count){
2507 memset(no_packet, 0, nb_input_files);
2514 /* read a frame from it and output it in the fifo */
2515 is = input_files[file_index].ctx;
2516 ret= av_read_frame(is, &pkt);
2517 if(ret == AVERROR(EAGAIN)){
2518 no_packet[file_index]=1;
2523 input_files[file_index].eof_reached = 1;
2531 memset(no_packet, 0, nb_input_files);
2534 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2535 is->streams[pkt.stream_index]);
2537 /* the following test is needed in case new streams appear
2538 dynamically in stream : we ignore them */
2539 if (pkt.stream_index >= input_files[file_index].nb_streams)
2540 goto discard_packet;
2541 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2542 ist = &input_streams[ist_index];
2544 goto discard_packet;
2546 if (pkt.dts != AV_NOPTS_VALUE)
2547 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2548 if (pkt.pts != AV_NOPTS_VALUE)
2549 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2551 if(pkt.pts != AV_NOPTS_VALUE)
2552 pkt.pts *= ist->ts_scale;
2553 if(pkt.dts != AV_NOPTS_VALUE)
2554 pkt.dts *= ist->ts_scale;
2556 // 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);
2557 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2558 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2559 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2560 int64_t delta= pkt_dts - ist->next_pts;
2561 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2562 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2563 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2564 pkt_dts+1<ist->pts)&& !copy_ts){
2565 input_files[ist->file_index].ts_offset -= delta;
2567 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2568 delta, input_files[ist->file_index].ts_offset);
2569 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2570 if(pkt.pts != AV_NOPTS_VALUE)
2571 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2575 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2576 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2579 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2580 ist->file_index, ist->st->index);
2583 av_free_packet(&pkt);
2588 av_free_packet(&pkt);
2590 /* dump report by using the output first video and audio streams */
2591 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2594 /* at the end of stream, we must flush the decoder buffers */
2595 for (i = 0; i < nb_input_streams; i++) {
2596 ist = &input_streams[i];
2597 if (ist->decoding_needed) {
2598 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2601 flush_encoders(output_streams, nb_output_streams);
2605 /* write the trailer if needed and close file */
2606 for(i=0;i<nb_output_files;i++) {
2607 os = output_files[i].ctx;
2608 av_write_trailer(os);
2611 /* dump report by using the first video and audio streams */
2612 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2614 /* close each encoder */
2615 for (i = 0; i < nb_output_streams; i++) {
2616 ost = &output_streams[i];
2617 if (ost->encoding_needed) {
2618 av_freep(&ost->st->codec->stats_in);
2619 avcodec_close(ost->st->codec);
2622 avfilter_graph_free(&ost->graph);
2626 /* close each decoder */
2627 for (i = 0; i < nb_input_streams; i++) {
2628 ist = &input_streams[i];
2629 if (ist->decoding_needed) {
2630 avcodec_close(ist->st->codec);
2638 av_freep(&bit_buffer);
2639 av_freep(&no_packet);
2641 if (output_streams) {
2642 for (i = 0; i < nb_output_streams; i++) {
2643 ost = &output_streams[i];
2645 if (ost->st->stream_copy)
2646 av_freep(&ost->st->codec->extradata);
2648 fclose(ost->logfile);
2649 ost->logfile = NULL;
2651 av_fifo_free(ost->fifo); /* works even if fifo is not
2652 initialized but set to zero */
2653 av_freep(&ost->st->codec->subtitle_header);
2654 av_free(ost->resample_frame.data[0]);
2655 av_free(ost->forced_kf_pts);
2656 if (ost->video_resample)
2657 sws_freeContext(ost->img_resample_ctx);
2659 audio_resample_close(ost->resample);
2660 if (ost->reformat_ctx)
2661 av_audio_convert_free(ost->reformat_ctx);
2662 av_dict_free(&ost->opts);
2669 static int opt_video_rc_override_string(const char *opt, const char *arg)
2671 video_rc_override_string = arg;
2675 static int opt_me_threshold(const char *opt, const char *arg)
2677 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2681 static int opt_verbose(const char *opt, const char *arg)
2683 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2687 static int opt_frame_rate(const char *opt, const char *arg)
2689 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2690 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2696 static int opt_frame_crop(const char *opt, const char *arg)
2698 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2699 return AVERROR(EINVAL);
2702 static int opt_frame_size(const char *opt, const char *arg)
2704 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2705 fprintf(stderr, "Incorrect frame size\n");
2706 return AVERROR(EINVAL);
2711 static int opt_pad(const char *opt, const char *arg) {
2712 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2716 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2718 if (strcmp(arg, "list")) {
2719 frame_pix_fmt = av_get_pix_fmt(arg);
2720 if (frame_pix_fmt == PIX_FMT_NONE) {
2721 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2722 return AVERROR(EINVAL);
2725 opt_pix_fmts(NULL, NULL);
2731 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2738 p = strchr(arg, ':');
2740 x = strtol(arg, &end, 10);
2742 y = strtol(end+1, &end, 10);
2744 ar = (double)x / (double)y;
2746 ar = strtod(arg, NULL);
2749 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2750 return AVERROR(EINVAL);
2752 frame_aspect_ratio = ar;
2756 static int opt_qscale(const char *opt, const char *arg)
2758 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2759 if (video_qscale <= 0 || video_qscale > 255) {
2760 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2761 return AVERROR(EINVAL);
2766 static int opt_top_field_first(const char *opt, const char *arg)
2768 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2769 return opt_default(opt, arg);
2772 static int opt_thread_count(const char *opt, const char *arg)
2774 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2777 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2782 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2784 if (strcmp(arg, "list")) {
2785 audio_sample_fmt = av_get_sample_fmt(arg);
2786 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2787 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2788 return AVERROR(EINVAL);
2793 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2794 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2800 static int opt_audio_rate(const char *opt, const char *arg)
2802 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2806 static int opt_audio_channels(const char *opt, const char *arg)
2808 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2812 static int opt_video_channel(const char *opt, const char *arg)
2814 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2815 return opt_default("channel", arg);
2818 static int opt_video_standard(const char *opt, const char *arg)
2820 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2821 return opt_default("standard", arg);
2824 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2826 audio_codec_name = arg;
2827 return parse_option(o, "codec:a", arg, options);
2830 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2832 video_codec_name = arg;
2833 return parse_option(o, "codec:v", arg, options);
2836 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2838 subtitle_codec_name = arg;
2839 return parse_option(o, "codec:s", arg, options);
2842 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2844 return parse_option(o, "codec:d", arg, options);
2847 static int opt_codec_tag(const char *opt, const char *arg)
2850 uint32_t *codec_tag;
2852 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2853 !strcmp(opt, "vtag") ? &video_codec_tag :
2854 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2858 *codec_tag = strtol(arg, &tail, 0);
2860 *codec_tag = AV_RL32(arg);
2865 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2867 StreamMap *m = NULL;
2868 int i, negative = 0, file_idx;
2869 int sync_file_idx = -1, sync_stream_idx;
2877 map = av_strdup(arg);
2879 /* parse sync stream first, just pick first matching stream */
2880 if (sync = strchr(map, ',')) {
2882 sync_file_idx = strtol(sync + 1, &sync, 0);
2883 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2884 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2889 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2890 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2891 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2892 sync_stream_idx = i;
2895 if (i == input_files[sync_file_idx].nb_streams) {
2896 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2897 "match any streams.\n", arg);
2903 file_idx = strtol(map, &p, 0);
2904 if (file_idx >= nb_input_files || file_idx < 0) {
2905 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2909 /* disable some already defined maps */
2910 for (i = 0; i < o->nb_stream_maps; i++) {
2911 m = &o->stream_maps[i];
2912 if (check_stream_specifier(input_files[m->file_index].ctx,
2913 input_files[m->file_index].ctx->streams[m->stream_index],
2914 *p == ':' ? p + 1 : p) > 0)
2918 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2919 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2920 *p == ':' ? p + 1 : p) <= 0)
2922 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2923 &o->nb_stream_maps, o->nb_stream_maps + 1);
2924 m = &o->stream_maps[o->nb_stream_maps - 1];
2926 m->file_index = file_idx;
2927 m->stream_index = i;
2929 if (sync_file_idx >= 0) {
2930 m->sync_file_index = sync_file_idx;
2931 m->sync_stream_index = sync_stream_idx;
2933 m->sync_file_index = file_idx;
2934 m->sync_stream_index = i;
2939 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2947 static void parse_meta_type(char *arg, char *type, int *index)
2957 if (*(++arg) == ':')
2958 *index = strtol(++arg, NULL, 0);
2961 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2968 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2970 MetadataMap *m, *m1;
2973 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2974 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2976 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2977 m->file = strtol(arg, &p, 0);
2978 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2980 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2981 if (p = strchr(opt, ':'))
2982 parse_meta_type(p + 1, &m1->type, &m1->index);
2986 if (m->type == 'g' || m1->type == 'g')
2987 o->metadata_global_manual = 1;
2988 if (m->type == 's' || m1->type == 's')
2989 o->metadata_streams_manual = 1;
2990 if (m->type == 'c' || m1->type == 'c')
2991 o->metadata_chapters_manual = 1;
2996 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2998 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2999 "Use -map_metadata instead.\n");
3000 return opt_map_metadata(o, opt, arg);
3003 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3006 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3007 struct tm time = *gmtime((time_t*)&recording_timestamp);
3008 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3009 parse_option(o, "metadata", buf, options);
3011 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3012 "tag instead.\n", opt);
3016 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3018 const char *codec_string = encoder ? "encoder" : "decoder";
3022 return CODEC_ID_NONE;
3024 avcodec_find_encoder_by_name(name) :
3025 avcodec_find_decoder_by_name(name);
3027 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
3030 if(codec->type != type) {
3031 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
3037 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
3039 char *codec_name = NULL;
3041 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3045 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
3046 return avcodec_find_encoder(st->codec->codec_id);
3048 } else if (!strcmp(codec_name, "copy"))
3049 st->stream_copy = 1;
3051 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
3052 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
3053 avcodec_find_decoder_by_name(codec_name);
3060 * Add all the streams from the given input file to the global
3061 * list of input streams.
3063 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3065 int i, rfps, rfps_base;
3067 for (i = 0; i < ic->nb_streams; i++) {
3068 AVStream *st = ic->streams[i];
3069 AVCodecContext *dec = st->codec;
3073 dec->thread_count = thread_count;
3075 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3076 ist = &input_streams[nb_input_streams - 1];
3078 ist->file_index = nb_input_files;
3080 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3082 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
3083 ist->ts_scale = scale;
3085 ist->dec = choose_codec(o, ic, st, dec->codec_type);
3087 ist->dec = avcodec_find_decoder(dec->codec_id);
3089 switch (dec->codec_type) {
3090 case AVMEDIA_TYPE_AUDIO:
3092 ist->dec = avcodec_find_decoder(dec->codec_id);
3094 st->discard= AVDISCARD_ALL;
3096 case AVMEDIA_TYPE_VIDEO:
3098 ist->dec = avcodec_find_decoder(dec->codec_id);
3099 rfps = ic->streams[i]->r_frame_rate.num;
3100 rfps_base = ic->streams[i]->r_frame_rate.den;
3102 dec->flags |= CODEC_FLAG_EMU_EDGE;
3105 dec->debug |= FF_DEBUG_MV;
3107 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3110 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3111 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3113 (float)rfps / rfps_base, rfps, rfps_base);
3117 st->discard= AVDISCARD_ALL;
3118 else if(video_discard)
3119 st->discard= video_discard;
3121 case AVMEDIA_TYPE_DATA:
3123 case AVMEDIA_TYPE_SUBTITLE:
3125 ist->dec = avcodec_find_decoder(dec->codec_id);
3126 if(subtitle_disable)
3127 st->discard = AVDISCARD_ALL;
3129 case AVMEDIA_TYPE_ATTACHMENT:
3130 case AVMEDIA_TYPE_UNKNOWN:
3138 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3140 AVFormatContext *ic;
3141 AVInputFormat *file_iformat = NULL;
3145 AVDictionary **opts;
3146 int orig_nb_streams; // number of streams before avformat_find_stream_info
3149 if (!(file_iformat = av_find_input_format(o->format))) {
3150 fprintf(stderr, "Unknown input format: '%s'\n", o->format);
3155 if (!strcmp(filename, "-"))
3158 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3159 !strcmp(filename, "/dev/stdin");
3161 /* get default parameters from command line */
3162 ic = avformat_alloc_context();
3164 print_error(filename, AVERROR(ENOMEM));
3167 if (audio_sample_rate) {
3168 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3169 av_dict_set(&format_opts, "sample_rate", buf, 0);
3171 if (audio_channels) {
3172 snprintf(buf, sizeof(buf), "%d", audio_channels);
3173 av_dict_set(&format_opts, "channels", buf, 0);
3175 if (frame_rate.num) {
3176 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3177 av_dict_set(&format_opts, "framerate", buf, 0);
3179 if (frame_width && frame_height) {
3180 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3181 av_dict_set(&format_opts, "video_size", buf, 0);
3183 if (frame_pix_fmt != PIX_FMT_NONE)
3184 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3186 ic->flags |= AVFMT_FLAG_NONBLOCK;
3189 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3190 ic->loop_input = loop_input;
3193 /* open the input file with generic libav function */
3194 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3196 print_error(filename, err);
3199 assert_avoptions(format_opts);
3204 for(i=0; i<ic->nb_streams; i++){
3205 ic->streams[i]->discard= AVDISCARD_ALL;
3207 for(i=0; i<ic->nb_programs; i++){
3208 AVProgram *p= ic->programs[i];
3209 if(p->id != opt_programid){
3210 p->discard = AVDISCARD_ALL;
3213 for(j=0; j<p->nb_stream_indexes; j++){
3214 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3219 fprintf(stderr, "Specified program id not found\n");
3225 /* apply forced codec ids */
3226 for (i = 0; i < ic->nb_streams; i++)
3227 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3229 /* Set AVCodecContext options for avformat_find_stream_info */
3230 opts = setup_find_stream_info_opts(ic, codec_opts);
3231 orig_nb_streams = ic->nb_streams;
3233 /* If not enough info to get the stream parameters, we decode the
3234 first frames to get it. (used in mpeg case for example) */
3235 ret = avformat_find_stream_info(ic, opts);
3236 if (ret < 0 && verbose >= 0) {
3237 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3238 av_close_input_file(ic);
3242 timestamp = o->start_time;
3243 /* add the stream start time */
3244 if (ic->start_time != AV_NOPTS_VALUE)
3245 timestamp += ic->start_time;
3247 /* if seeking requested, we execute it */
3248 if (o->start_time != 0) {
3249 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3251 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3252 filename, (double)timestamp / AV_TIME_BASE);
3256 /* update the current parameters so that they match the one of the input stream */
3257 add_input_streams(o, ic);
3259 /* dump the file content */
3261 av_dump_format(ic, nb_input_files, filename, 0);
3263 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3264 input_files[nb_input_files - 1].ctx = ic;
3265 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3266 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3267 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3269 top_field_first = -1;
3270 frame_rate = (AVRational){0, 0};
3271 frame_pix_fmt = PIX_FMT_NONE;
3274 audio_sample_rate = 0;
3276 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3278 for (i = 0; i < orig_nb_streams; i++)
3279 av_dict_free(&opts[i]);
3282 reset_options(o, 1);
3286 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3287 AVCodecContext *avctx)
3293 for (p = kf; *p; p++)
3296 ost->forced_kf_count = n;
3297 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3298 if (!ost->forced_kf_pts) {
3299 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3302 for (i = 0; i < n; i++) {
3303 p = i ? strchr(p, ',') + 1 : kf;
3304 t = parse_time_or_die("force_key_frames", p, 1);
3305 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3309 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3312 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3313 int idx = oc->nb_streams - 1;
3314 int64_t max_frames = INT64_MAX;
3315 char *bsf = NULL, *next;
3316 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3319 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3323 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3324 nb_output_streams + 1);
3325 ost = &output_streams[nb_output_streams - 1];
3326 ost->file_index = nb_output_files;
3329 st->codec->codec_type = type;
3330 ost->enc = choose_codec(o, oc, st, type);
3332 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3335 avcodec_get_context_defaults3(st->codec, ost->enc);
3336 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3338 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3339 ost->max_frames = max_frames;
3341 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3343 if (next = strchr(bsf, ','))
3345 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3346 av_log(NULL, AV_LOG_ERROR, "Unknown bitstream filter %s\n", bsf);
3350 bsfc_prev->next = bsfc;
3352 ost->bitstream_filters = bsfc;
3358 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3362 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3366 AVCodecContext *video_enc;
3368 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3370 if (!st->stream_copy) {
3371 ost->frame_aspect_ratio = frame_aspect_ratio;
3372 frame_aspect_ratio = 0;
3374 ost->avfilter = vfilters;
3379 st->codec->thread_count= thread_count;
3381 video_enc = st->codec;
3384 video_enc->codec_tag= video_codec_tag;
3386 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3387 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3390 if (st->stream_copy) {
3391 video_enc->sample_aspect_ratio =
3392 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3398 ost->frame_rate = frame_rate;
3400 video_enc->width = frame_width;
3401 video_enc->height = frame_height;
3402 video_enc->pix_fmt = frame_pix_fmt;
3403 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3404 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3407 video_enc->gop_size = 0;
3408 if (video_qscale || same_quant) {
3409 video_enc->flags |= CODEC_FLAG_QSCALE;
3410 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3414 video_enc->intra_matrix = intra_matrix;
3416 video_enc->inter_matrix = inter_matrix;
3418 p= video_rc_override_string;
3421 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3423 fprintf(stderr, "error parsing rc_override\n");
3426 video_enc->rc_override=
3427 av_realloc(video_enc->rc_override,
3428 sizeof(RcOverride)*(i+1));
3429 video_enc->rc_override[i].start_frame= start;
3430 video_enc->rc_override[i].end_frame = end;
3432 video_enc->rc_override[i].qscale= q;
3433 video_enc->rc_override[i].quality_factor= 1.0;
3436 video_enc->rc_override[i].qscale= 0;
3437 video_enc->rc_override[i].quality_factor= -q/100.0;
3442 video_enc->rc_override_count=i;
3443 if (!video_enc->rc_initial_buffer_occupancy)
3444 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3445 video_enc->me_threshold= me_threshold;
3446 video_enc->intra_dc_precision= intra_dc_precision - 8;
3449 video_enc->flags|= CODEC_FLAG_PSNR;
3454 video_enc->flags |= CODEC_FLAG_PASS1;
3456 video_enc->flags |= CODEC_FLAG_PASS2;
3460 if (forced_key_frames)
3461 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3463 if (video_language) {
3464 av_dict_set(&st->metadata, "language", video_language, 0);
3465 av_freep(&video_language);
3468 /* reset some key parameters */
3470 av_freep(&forced_key_frames);
3471 frame_pix_fmt = PIX_FMT_NONE;
3475 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3479 AVCodecContext *audio_enc;
3481 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3484 st->codec->thread_count= thread_count;
3486 audio_enc = st->codec;
3487 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3490 audio_enc->codec_tag= audio_codec_tag;
3492 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3493 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3495 if (!st->stream_copy) {
3496 if (audio_qscale > QSCALE_NONE) {
3497 audio_enc->flags |= CODEC_FLAG_QSCALE;
3498 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3501 audio_enc->channels = audio_channels;
3502 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3503 audio_enc->sample_fmt = audio_sample_fmt;
3504 if (audio_sample_rate)
3505 audio_enc->sample_rate = audio_sample_rate;
3507 if (audio_language) {
3508 av_dict_set(&st->metadata, "language", audio_language, 0);
3509 av_freep(&audio_language);
3512 /* reset some key parameters */
3518 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3522 AVCodecContext *data_enc;
3524 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3526 data_enc = st->codec;
3527 if (!st->stream_copy) {
3528 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3533 data_enc->codec_tag= data_codec_tag;
3535 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3536 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3543 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3547 AVCodecContext *subtitle_enc;
3549 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3551 subtitle_enc = st->codec;
3553 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3555 if(subtitle_codec_tag)
3556 subtitle_enc->codec_tag= subtitle_codec_tag;
3558 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3559 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3562 if (subtitle_language) {
3563 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3564 av_freep(&subtitle_language);
3567 subtitle_disable = 0;
3571 /* arg format is "output-stream-index:streamid-value". */
3572 static int opt_streamid(const char *opt, const char *arg)
3578 av_strlcpy(idx_str, arg, sizeof(idx_str));
3579 p = strchr(idx_str, ':');
3582 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3587 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3588 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3589 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3593 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3595 AVFormatContext *is = ifile->ctx;
3596 AVFormatContext *os = ofile->ctx;
3599 for (i = 0; i < is->nb_chapters; i++) {
3600 AVChapter *in_ch = is->chapters[i], *out_ch;
3601 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3602 AV_TIME_BASE_Q, in_ch->time_base);
3603 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3604 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3607 if (in_ch->end < ts_off)
3609 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3612 out_ch = av_mallocz(sizeof(AVChapter));
3614 return AVERROR(ENOMEM);
3616 out_ch->id = in_ch->id;
3617 out_ch->time_base = in_ch->time_base;
3618 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3619 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3622 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3625 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3627 return AVERROR(ENOMEM);
3628 os->chapters[os->nb_chapters - 1] = out_ch;
3633 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3636 AVFormatContext *ic = NULL;
3638 err = avformat_open_input(&ic, filename, NULL, NULL);
3641 /* copy stream format */
3642 for(i=0;i<ic->nb_streams;i++) {
3647 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3648 ost = new_output_stream(o, s, codec->type);
3651 // FIXME: a more elegant solution is needed
3652 memcpy(st, ic->streams[i], sizeof(AVStream));
3653 st->info = av_malloc(sizeof(*st->info));
3654 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3655 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3657 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3658 choose_sample_fmt(st, codec);
3659 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3660 choose_pixel_fmt(st, codec);
3663 av_close_input_file(ic);
3667 static void opt_output_file(void *optctx, const char *filename)
3669 OptionsContext *o = optctx;
3670 AVFormatContext *oc;
3672 AVOutputFormat *file_oformat;
3676 if (!strcmp(filename, "-"))
3679 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3681 print_error(filename, err);
3684 file_oformat= oc->oformat;
3686 if (!strcmp(file_oformat->name, "ffm") &&
3687 av_strstart(filename, "http:", NULL)) {
3688 /* special case for files sent to ffserver: we get the stream
3689 parameters from ffserver */
3690 int err = read_ffserver_streams(o, oc, filename);
3692 print_error(filename, err);
3695 } else if (!o->nb_stream_maps) {
3696 /* pick the "best" stream of each type */
3697 #define NEW_STREAM(type, index)\
3699 ost = new_ ## type ## _stream(o, oc);\
3700 ost->source_index = index;\
3701 ost->sync_ist = &input_streams[index];\
3702 input_streams[index].discard = 0;\
3705 /* video: highest resolution */
3706 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3707 int area = 0, idx = -1;
3708 for (i = 0; i < nb_input_streams; i++) {
3709 ist = &input_streams[i];
3710 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3711 ist->st->codec->width * ist->st->codec->height > area) {
3712 area = ist->st->codec->width * ist->st->codec->height;
3716 NEW_STREAM(video, idx);
3719 /* audio: most channels */
3720 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3721 int channels = 0, idx = -1;
3722 for (i = 0; i < nb_input_streams; i++) {
3723 ist = &input_streams[i];
3724 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3725 ist->st->codec->channels > channels) {
3726 channels = ist->st->codec->channels;
3730 NEW_STREAM(audio, idx);
3733 /* subtitles: pick first */
3734 if (!subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3735 for (i = 0; i < nb_input_streams; i++)
3736 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3737 NEW_STREAM(subtitle, i);
3741 /* do something with data? */
3743 for (i = 0; i < o->nb_stream_maps; i++) {
3744 StreamMap *map = &o->stream_maps[i];
3749 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3750 switch (ist->st->codec->codec_type) {
3751 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3752 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3753 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3754 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3756 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3757 map->file_index, map->stream_index);
3761 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3762 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3763 map->sync_stream_index];
3768 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3769 output_files[nb_output_files - 1].ctx = oc;
3770 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3771 output_files[nb_output_files - 1].recording_time = o->recording_time;
3772 output_files[nb_output_files - 1].start_time = o->start_time;
3773 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3774 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3776 /* check filename in case of an image number is expected */
3777 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3778 if (!av_filename_number_test(oc->filename)) {
3779 print_error(oc->filename, AVERROR(EINVAL));
3784 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3785 /* test if it already exists to avoid loosing precious files */
3786 if (!file_overwrite &&
3787 (strchr(filename, ':') == NULL ||
3788 filename[1] == ':' ||
3789 av_strstart(filename, "file:", NULL))) {
3790 if (avio_check(filename, 0) == 0) {
3792 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3794 if (!read_yesno()) {
3795 fprintf(stderr, "Not overwriting - exiting\n");
3800 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3807 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3808 print_error(filename, err);
3813 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3814 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3816 if (loop_output >= 0) {
3817 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3818 oc->loop_output = loop_output;
3822 if (o->chapters_input_file >= nb_input_files) {
3823 if (o->chapters_input_file == INT_MAX) {
3824 /* copy chapters from the first input file that has them*/
3825 o->chapters_input_file = -1;
3826 for (i = 0; i < nb_input_files; i++)
3827 if (input_files[i].ctx->nb_chapters) {
3828 o->chapters_input_file = i;
3832 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3833 o->chapters_input_file);
3837 if (o->chapters_input_file >= 0)
3838 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3839 o->metadata_chapters_manual);
3842 for (i = 0; i < o->nb_meta_data_maps; i++) {
3843 AVFormatContext *files[2];
3844 AVDictionary **meta[2];
3847 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3848 if ((index) < 0 || (index) >= (nb_elems)) {\
3849 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3854 int in_file_index = o->meta_data_maps[i][1].file;
3855 if (in_file_index < 0)
3857 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3860 files[1] = input_files[in_file_index].ctx;
3862 for (j = 0; j < 2; j++) {
3863 MetadataMap *map = &o->meta_data_maps[i][j];
3865 switch (map->type) {
3867 meta[j] = &files[j]->metadata;
3870 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3871 meta[j] = &files[j]->streams[map->index]->metadata;
3874 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3875 meta[j] = &files[j]->chapters[map->index]->metadata;
3878 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3879 meta[j] = &files[j]->programs[map->index]->metadata;
3884 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3887 /* copy global metadata by default */
3888 if (!o->metadata_global_manual && nb_input_files)
3889 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3890 AV_DICT_DONT_OVERWRITE);
3891 if (!o->metadata_streams_manual)
3892 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3893 InputStream *ist = &input_streams[output_streams[i].source_index];
3894 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3897 /* process manually set metadata */
3898 for (i = 0; i < o->nb_metadata; i++) {
3903 val = strchr(o->metadata[i].u.str, '=');
3905 av_log(NULL, AV_LOG_ERROR, "No '=' character in metadata string %s.\n",
3906 o->metadata[i].u.str);
3911 parse_meta_type(o->metadata[i].specifier, &type, &index);
3917 if (index < 0 || index >= oc->nb_streams) {
3918 av_log(NULL, AV_LOG_ERROR, "Invalid stream index %d in metadata specifier.\n", index);
3921 m = &oc->streams[i]->metadata;
3924 if (index < 0 || index >= oc->nb_chapters) {
3925 av_log(NULL, AV_LOG_ERROR, "Invalid chapter index %d in metadata specifier.\n", index);
3928 m = &oc->chapters[i]->metadata;
3931 av_log(NULL, AV_LOG_ERROR, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3935 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3938 frame_rate = (AVRational){0, 0};
3941 audio_sample_rate = 0;
3943 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3945 av_freep(&streamid_map);
3946 nb_streamid_map = 0;
3948 av_freep(&forced_key_frames);
3949 reset_options(o, 0);
3952 /* same option as mencoder */
3953 static int opt_pass(const char *opt, const char *arg)
3955 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3959 static int64_t getutime(void)
3962 struct rusage rusage;
3964 getrusage(RUSAGE_SELF, &rusage);
3965 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3966 #elif HAVE_GETPROCESSTIMES
3968 FILETIME c, e, k, u;
3969 proc = GetCurrentProcess();
3970 GetProcessTimes(proc, &c, &e, &k, &u);
3971 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3973 return av_gettime();
3977 static int64_t getmaxrss(void)
3979 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3980 struct rusage rusage;
3981 getrusage(RUSAGE_SELF, &rusage);
3982 return (int64_t)rusage.ru_maxrss * 1024;
3983 #elif HAVE_GETPROCESSMEMORYINFO
3985 PROCESS_MEMORY_COUNTERS memcounters;
3986 proc = GetCurrentProcess();
3987 memcounters.cb = sizeof(memcounters);
3988 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3989 return memcounters.PeakPagefileUsage;
3995 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3998 const char *p = str;
4005 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4012 static int opt_inter_matrix(const char *opt, const char *arg)
4014 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
4015 parse_matrix_coeffs(inter_matrix, arg);
4019 static int opt_intra_matrix(const char *opt, const char *arg)
4021 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
4022 parse_matrix_coeffs(intra_matrix, arg);
4026 static void show_usage(void)
4028 printf("Hyper fast Audio and Video encoder\n");
4029 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4033 static int opt_help(const char *opt, const char *arg)
4036 AVOutputFormat *oformat = NULL;
4037 AVInputFormat *iformat = NULL;
4038 const AVClass *class;
4040 av_log_set_callback(log_callback_help);
4042 show_help_options(options, "Main options:\n",
4043 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4044 show_help_options(options, "\nAdvanced options:\n",
4045 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4047 show_help_options(options, "\nVideo options:\n",
4048 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4050 show_help_options(options, "\nAdvanced Video options:\n",
4051 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4052 OPT_VIDEO | OPT_EXPERT);
4053 show_help_options(options, "\nAudio options:\n",
4054 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4056 show_help_options(options, "\nAdvanced Audio options:\n",
4057 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4058 OPT_AUDIO | OPT_EXPERT);
4059 show_help_options(options, "\nSubtitle options:\n",
4060 OPT_SUBTITLE | OPT_GRAB,
4062 show_help_options(options, "\nAudio/Video grab options:\n",
4066 class = avcodec_get_class();
4067 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4070 /* individual codec options */
4072 while ((c = av_codec_next(c))) {
4073 if (c->priv_class) {
4074 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4079 class = avformat_get_class();
4080 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4083 /* individual muxer options */
4084 while ((oformat = av_oformat_next(oformat))) {
4085 if (oformat->priv_class) {
4086 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4091 /* individual demuxer options */
4092 while ((iformat = av_iformat_next(iformat))) {
4093 if (iformat->priv_class) {
4094 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4099 class = sws_get_class();
4100 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4104 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4106 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4107 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4109 if(!strncmp(arg, "pal-", 4)) {
4112 } else if(!strncmp(arg, "ntsc-", 5)) {
4115 } else if(!strncmp(arg, "film-", 5)) {
4120 /* Calculate FR via float to avoid int overflow */
4121 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4124 } else if((fr == 29970) || (fr == 23976)) {
4127 /* Try to determine PAL/NTSC by peeking in the input files */
4128 if(nb_input_files) {
4130 for (j = 0; j < nb_input_files; j++) {
4131 for (i = 0; i < input_files[j].nb_streams; i++) {
4132 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4133 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4135 fr = c->time_base.den * 1000 / c->time_base.num;
4139 } else if((fr == 29970) || (fr == 23976)) {
4149 if(verbose > 0 && norm != UNKNOWN)
4150 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4153 if(norm == UNKNOWN) {
4154 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4155 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4156 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4160 if(!strcmp(arg, "vcd")) {
4161 opt_video_codec(o, "c:v", "mpeg1video");
4162 opt_audio_codec(o, "c:a", "mp2");
4163 parse_option(o, "f", "vcd", options);
4165 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4166 opt_frame_rate("r", frame_rates[norm]);
4167 opt_default("g", norm == PAL ? "15" : "18");
4169 opt_default("b", "1150000");
4170 opt_default("maxrate", "1150000");
4171 opt_default("minrate", "1150000");
4172 opt_default("bufsize", "327680"); // 40*1024*8;
4174 opt_default("b:a", "224000");
4175 audio_sample_rate = 44100;
4178 opt_default("packetsize", "2324");
4179 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4181 /* We have to offset the PTS, so that it is consistent with the SCR.
4182 SCR starts at 36000, but the first two packs contain only padding
4183 and the first pack from the other stream, respectively, may also have
4184 been written before.
4185 So the real data starts at SCR 36000+3*1200. */
4186 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4187 } else if(!strcmp(arg, "svcd")) {
4189 opt_video_codec(o, "c:v", "mpeg2video");
4190 opt_audio_codec(o, "c:a", "mp2");
4191 parse_option(o, "f", "svcd", options);
4193 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4194 opt_frame_rate("r", frame_rates[norm]);
4195 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4196 opt_default("g", norm == PAL ? "15" : "18");
4198 opt_default("b", "2040000");
4199 opt_default("maxrate", "2516000");
4200 opt_default("minrate", "0"); //1145000;
4201 opt_default("bufsize", "1835008"); //224*1024*8;
4202 opt_default("flags", "+scan_offset");
4205 opt_default("b:a", "224000");
4206 audio_sample_rate = 44100;
4208 opt_default("packetsize", "2324");
4210 } else if(!strcmp(arg, "dvd")) {
4212 opt_video_codec(o, "c:v", "mpeg2video");
4213 opt_audio_codec(o, "c:a", "ac3");
4214 parse_option(o, "f", "dvd", options);
4216 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4217 opt_frame_rate("r", frame_rates[norm]);
4218 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4219 opt_default("g", norm == PAL ? "15" : "18");
4221 opt_default("b", "6000000");
4222 opt_default("maxrate", "9000000");
4223 opt_default("minrate", "0"); //1500000;
4224 opt_default("bufsize", "1835008"); //224*1024*8;
4226 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4227 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4229 opt_default("b:a", "448000");
4230 audio_sample_rate = 48000;
4232 } else if(!strncmp(arg, "dv", 2)) {
4234 parse_option(o, "f", "dv", options);
4236 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4237 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4238 norm == PAL ? "yuv420p" : "yuv411p");
4239 opt_frame_rate("r", frame_rates[norm]);
4241 audio_sample_rate = 48000;
4245 fprintf(stderr, "Unknown target: %s\n", arg);
4246 return AVERROR(EINVAL);
4251 static int opt_vstats_file(const char *opt, const char *arg)
4253 av_free (vstats_filename);
4254 vstats_filename=av_strdup (arg);
4258 static int opt_vstats(const char *opt, const char *arg)
4261 time_t today2 = time(NULL);
4262 struct tm *today = localtime(&today2);
4264 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4266 return opt_vstats_file(opt, filename);
4269 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4271 return parse_option(o, "frames:v", arg, options);
4274 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4276 return parse_option(o, "frames:a", arg, options);
4279 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4281 return parse_option(o, "frames:d", arg, options);
4284 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4287 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4288 char *codec_name = *opt == 'v' ? video_codec_name :
4289 *opt == 'a' ? audio_codec_name :
4290 subtitle_codec_name;
4292 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4293 fprintf(stderr, "File for preset '%s' not found\n", arg);
4298 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4299 if(line[0] == '#' && !e)
4301 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4303 fprintf(stderr, "%s: Invalid syntax: '%s'\n", filename, line);
4306 if(!strcmp(tmp, "acodec")){
4307 opt_audio_codec(o, tmp, tmp2);
4308 }else if(!strcmp(tmp, "vcodec")){
4309 opt_video_codec(o, tmp, tmp2);
4310 }else if(!strcmp(tmp, "scodec")){
4311 opt_subtitle_codec(o, tmp, tmp2);
4312 }else if(!strcmp(tmp, "dcodec")){
4313 opt_data_codec(o, tmp, tmp2);
4314 }else if(opt_default(tmp, tmp2) < 0){
4315 fprintf(stderr, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4325 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4329 static int opt_passlogfile(const char *opt, const char *arg)
4331 pass_logfilename_prefix = arg;
4332 #if CONFIG_LIBX264_ENCODER
4333 return opt_default("passlogfile", arg);
4339 #define OFFSET(x) offsetof(OptionsContext, x)
4340 static const OptionDef options[] = {
4342 #include "cmdutils_common_opts.h"
4343 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4344 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4345 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4346 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4347 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4348 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4349 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4350 "outfile[,metadata]:infile[,metadata]" },
4351 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4352 "outfile[,metadata]:infile[,metadata]" },
4353 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4354 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4355 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4356 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4357 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4358 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4359 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4360 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4361 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4362 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4363 "add timings for benchmarking" },
4364 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4365 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4366 "dump each input packet" },
4367 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4368 "when dumping packets, also dump the payload" },
4369 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4370 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4371 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4372 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4373 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4374 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4375 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4376 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4377 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4378 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4379 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4380 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4381 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4382 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4383 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4384 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4385 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4388 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4389 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4390 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4391 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4392 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
4393 { "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" },
4394 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4395 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4396 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4397 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4398 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4399 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4400 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4401 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4402 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4403 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4404 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4405 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4406 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4407 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4408 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4409 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold", "threshold" },
4410 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4411 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4412 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4413 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4414 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4415 "deinterlace pictures" },
4416 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4417 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4418 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4420 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4422 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4423 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4424 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4425 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4426 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4427 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4428 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4429 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4430 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4431 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4434 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4435 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4436 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4437 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4438 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4439 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4440 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4441 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4442 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4443 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
4445 /* subtitle options */
4446 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4447 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4448 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4449 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4452 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4453 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4454 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4457 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4458 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4460 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4462 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4463 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4464 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4465 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4466 /* data codec support */
4467 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4469 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4473 int main(int argc, char **argv)
4475 OptionsContext o = { 0 };
4478 reset_options(&o, 0);
4480 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4482 if(argc>1 && !strcmp(argv[1], "-d")){
4485 av_log_set_callback(log_callback_null);
4490 avcodec_register_all();
4492 avdevice_register_all();
4495 avfilter_register_all();
4500 if(isatty(STDIN_FILENO))
4501 avio_set_interrupt_cb(decode_interrupt_cb);
4508 parse_options(&o, argc, argv, options, opt_output_file);
4510 if(nb_output_files <= 0 && nb_input_files == 0) {
4512 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4516 /* file converter / grab */
4517 if (nb_output_files <= 0) {
4518 fprintf(stderr, "At least one output file must be specified\n");
4522 if (nb_input_files == 0) {
4523 fprintf(stderr, "At least one input file must be specified\n");
4528 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4530 ti = getutime() - ti;
4532 int maxrss = getmaxrss() / 1024;
4533 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);