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[] = "avconv";
90 const int program_birth_year = 2000;
92 /* select an input stream for an output stream */
93 typedef struct StreamMap {
94 int disabled; /** 1 is this mapping is disabled by a negative map */
98 int sync_stream_index;
102 * select an input file for an output file
104 typedef struct MetadataMap {
105 int file; ///< file index
106 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
107 int index; ///< stream/chapter/program number
110 static const OptionDef options[];
112 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
114 static int frame_bits_per_raw_sample = 0;
115 static int video_discard = 0;
116 static int same_quant = 0;
117 static int do_deinterlace = 0;
118 static int intra_dc_precision = 8;
119 static int qp_hist = 0;
121 static int file_overwrite = 0;
122 static int do_benchmark = 0;
123 static int do_hex_dump = 0;
124 static int do_pkt_dump = 0;
125 static int do_pass = 0;
126 static const char *pass_logfilename_prefix;
127 static int video_sync_method= -1;
128 static int audio_sync_method= 0;
129 static float audio_drift_threshold= 0.1;
130 static int copy_ts= 0;
131 static int copy_tb= 0;
132 static int opt_shortest = 0;
133 static char *vstats_filename;
134 static FILE *vstats_file;
135 static int copy_initial_nonkeyframes = 0;
137 static int audio_volume = 256;
139 static int exit_on_error = 0;
140 static int using_stdin = 0;
141 static int run_as_daemon = 0;
142 static int q_pressed = 0;
143 static int64_t video_size = 0;
144 static int64_t audio_size = 0;
145 static int64_t extra_size = 0;
146 static int nb_frames_dup = 0;
147 static int nb_frames_drop = 0;
148 static int input_sync;
150 static float dts_delta_threshold = 10;
152 static int print_stats = 1;
154 static uint8_t *audio_buf;
155 static uint8_t *audio_out;
156 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
158 static void *samples;
160 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
162 typedef struct InputStream {
165 int discard; /* true if stream data should be discarded */
166 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
169 int64_t start; /* time when read started */
170 int64_t next_pts; /* synthetic pts for cases where pkt.pts
172 int64_t pts; /* current pts */
174 int is_start; /* is 1 at the start and after a discontinuity */
175 int showed_multi_packet_warning;
179 typedef struct InputFile {
180 AVFormatContext *ctx;
181 int eof_reached; /* true if eof reached */
182 int ist_index; /* index of first stream in ist_table */
183 int buffer_size; /* current total buffer size */
185 int nb_streams; /* number of stream that avconv is aware of; may be different
186 from ctx.nb_streams if new streams appear during av_read_frame() */
190 typedef struct OutputStream {
191 int file_index; /* file index */
192 int index; /* stream index in the output file */
193 int source_index; /* InputStream index */
194 AVStream *st; /* stream in the output file */
195 int encoding_needed; /* true if encoding needed for this stream */
197 /* input pts and corresponding output pts
199 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
200 struct InputStream *sync_ist; /* input stream to sync against */
201 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
202 AVBitStreamFilterContext *bitstream_filters;
208 AVFrame resample_frame; /* temporary frame for image resampling */
209 struct SwsContext *img_resample_ctx; /* for image resampling */
212 int resample_pix_fmt;
213 AVRational frame_rate;
217 float frame_aspect_ratio;
219 /* forced key frames */
220 int64_t *forced_kf_pts;
226 ReSampleContext *resample; /* for audio resampling */
227 int resample_sample_fmt;
228 int resample_channels;
229 int resample_sample_rate;
231 AVAudioConvert *reformat_ctx;
232 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
236 AVFilterContext *output_video_filter;
237 AVFilterContext *input_video_filter;
238 AVFilterBufferRef *picref;
240 AVFilterGraph *graph;
245 int is_past_recording_time;
251 /* init terminal so that we can grab keys */
252 static struct termios oldtty;
255 typedef struct OutputFile {
256 AVFormatContext *ctx;
258 int ost_index; /* index of the first stream in output_streams */
259 int64_t recording_time; /* desired length of the resulting file in microseconds */
260 int64_t start_time; /* start time in microseconds */
261 uint64_t limit_filesize;
264 static InputStream *input_streams = NULL;
265 static int nb_input_streams = 0;
266 static InputFile *input_files = NULL;
267 static int nb_input_files = 0;
269 static OutputStream *output_streams = NULL;
270 static int nb_output_streams = 0;
271 static OutputFile *output_files = NULL;
272 static int nb_output_files = 0;
274 typedef struct OptionsContext {
275 /* input/output options */
279 SpecifierOpt *codec_names;
281 SpecifierOpt *audio_channels;
282 int nb_audio_channels;
283 SpecifierOpt *audio_sample_rate;
284 int nb_audio_sample_rate;
285 SpecifierOpt *frame_rates;
287 SpecifierOpt *frame_sizes;
289 SpecifierOpt *frame_pix_fmts;
290 int nb_frame_pix_fmts;
293 int64_t input_ts_offset;
296 SpecifierOpt *ts_scale;
300 StreamMap *stream_maps;
302 /* first item specifies output metadata, second is input */
303 MetadataMap (*meta_data_maps)[2];
304 int nb_meta_data_maps;
305 int metadata_global_manual;
306 int metadata_streams_manual;
307 int metadata_chapters_manual;
309 int chapters_input_file;
311 int64_t recording_time;
312 uint64_t limit_filesize;
318 int subtitle_disable;
321 /* indexed by output file stream index */
325 SpecifierOpt *metadata;
327 SpecifierOpt *max_frames;
329 SpecifierOpt *bitstream_filters;
330 int nb_bitstream_filters;
331 SpecifierOpt *codec_tags;
333 SpecifierOpt *sample_fmts;
335 SpecifierOpt *qscale;
337 SpecifierOpt *forced_key_frames;
338 int nb_forced_key_frames;
339 SpecifierOpt *force_fps;
341 SpecifierOpt *frame_aspect_ratios;
342 int nb_frame_aspect_ratios;
343 SpecifierOpt *rc_overrides;
345 SpecifierOpt *intra_matrices;
346 int nb_intra_matrices;
347 SpecifierOpt *inter_matrices;
348 int nb_inter_matrices;
349 SpecifierOpt *top_field_first;
350 int nb_top_field_first;
351 SpecifierOpt *presets;
354 SpecifierOpt *filters;
359 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
362 for (i = 0; i < o->nb_ ## name; i++) {\
363 char *spec = o->name[i].specifier;\
364 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
365 outvar = o->name[i].u.type;\
371 static void reset_options(OptionsContext *o)
373 const OptionDef *po = options;
375 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
377 void *dst = (uint8_t*)o + po->u.off;
379 if (po->flags & OPT_SPEC) {
380 SpecifierOpt **so = dst;
381 int i, *count = (int*)(so + 1);
382 for (i = 0; i < *count; i++) {
383 av_freep(&(*so)[i].specifier);
384 if (po->flags & OPT_STRING)
385 av_freep(&(*so)[i].u.str);
389 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
394 av_freep(&o->stream_maps);
395 av_freep(&o->meta_data_maps);
396 av_freep(&o->streamid_map);
398 memset(o, 0, sizeof(*o));
400 o->mux_max_delay = 0.7;
401 o->recording_time = INT64_MAX;
402 o->limit_filesize = UINT64_MAX;
403 o->chapters_input_file = INT_MAX;
411 static int configure_video_filters(InputStream *ist, OutputStream *ost)
413 AVFilterContext *last_filter, *filter;
414 /** filter graph containing all filters including input & output */
415 AVCodecContext *codec = ost->st->codec;
416 AVCodecContext *icodec = ist->st->codec;
417 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
418 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
419 AVRational sample_aspect_ratio;
423 ost->graph = avfilter_graph_alloc();
425 if (ist->st->sample_aspect_ratio.num){
426 sample_aspect_ratio = ist->st->sample_aspect_ratio;
428 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
430 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
431 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
432 sample_aspect_ratio.num, sample_aspect_ratio.den);
434 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
435 "src", args, NULL, ost->graph);
438 #if FF_API_OLD_VSINK_API
439 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
440 "out", NULL, pix_fmts, ost->graph);
442 buffersink_params->pixel_fmts = pix_fmts;
443 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
444 "out", NULL, buffersink_params, ost->graph);
446 av_freep(&buffersink_params);
449 last_filter = ost->input_video_filter;
451 if (codec->width != icodec->width || codec->height != icodec->height) {
452 snprintf(args, 255, "%d:%d:flags=0x%X",
455 (unsigned)ost->sws_flags);
456 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
457 NULL, args, NULL, ost->graph)) < 0)
459 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
461 last_filter = filter;
464 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
465 ost->graph->scale_sws_opts = av_strdup(args);
468 AVFilterInOut *outputs = avfilter_inout_alloc();
469 AVFilterInOut *inputs = avfilter_inout_alloc();
471 outputs->name = av_strdup("in");
472 outputs->filter_ctx = last_filter;
473 outputs->pad_idx = 0;
474 outputs->next = NULL;
476 inputs->name = av_strdup("out");
477 inputs->filter_ctx = ost->output_video_filter;
481 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
483 av_freep(&ost->avfilter);
485 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
489 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
492 codec->width = ost->output_video_filter->inputs[0]->w;
493 codec->height = ost->output_video_filter->inputs[0]->h;
494 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
495 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
496 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
497 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
501 #endif /* CONFIG_AVFILTER */
503 static void term_exit(void)
505 av_log(NULL, AV_LOG_QUIET, "%s", "");
508 tcsetattr (0, TCSANOW, &oldtty);
512 static volatile int received_sigterm = 0;
515 sigterm_handler(int sig)
517 received_sigterm = sig;
522 static void term_init(void)
532 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
533 |INLCR|IGNCR|ICRNL|IXON);
534 tty.c_oflag |= OPOST;
535 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
536 tty.c_cflag &= ~(CSIZE|PARENB);
541 tcsetattr (0, TCSANOW, &tty);
542 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
546 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
547 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
549 signal(SIGXCPU, sigterm_handler);
553 /* read a key without blocking */
554 static int read_key(void)
569 n = select(1, &rfds, NULL, NULL, &tv);
584 static int decode_interrupt_cb(void)
586 q_pressed += read_key() == 'q';
587 return q_pressed > 1;
590 void exit_program(int ret)
595 for(i=0;i<nb_output_files;i++) {
596 AVFormatContext *s = output_files[i].ctx;
597 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
599 avformat_free_context(s);
600 av_dict_free(&output_files[i].opts);
602 for(i=0;i<nb_input_files;i++) {
603 av_close_input_file(input_files[i].ctx);
605 for (i = 0; i < nb_input_streams; i++)
606 av_dict_free(&input_streams[i].opts);
610 av_free(vstats_filename);
612 av_freep(&input_streams);
613 av_freep(&input_files);
614 av_freep(&output_streams);
615 av_freep(&output_files);
620 allocated_audio_buf_size= allocated_audio_out_size= 0;
627 if (received_sigterm) {
628 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
629 (int) received_sigterm);
633 exit(ret); /* not all OS-es handle main() return value */
636 static void assert_avoptions(AVDictionary *m)
638 AVDictionaryEntry *t;
639 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
640 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
645 static void assert_codec_experimental(AVCodecContext *c, int encoder)
647 const char *codec_string = encoder ? "encoder" : "decoder";
649 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
650 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
651 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
652 "results.\nAdd '-strict experimental' if you want to use it.\n",
653 codec_string, c->codec->name);
654 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
655 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
656 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
657 codec_string, codec->name);
662 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
664 if(codec && codec->sample_fmts){
665 const enum AVSampleFormat *p= codec->sample_fmts;
667 if(*p == st->codec->sample_fmt)
671 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
672 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
673 if(av_get_sample_fmt_name(st->codec->sample_fmt))
674 av_log(NULL, AV_LOG_WARNING,
675 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
676 av_get_sample_fmt_name(st->codec->sample_fmt),
678 av_get_sample_fmt_name(codec->sample_fmts[0]));
679 st->codec->sample_fmt = codec->sample_fmts[0];
684 static void choose_sample_rate(AVStream *st, AVCodec *codec)
686 if(codec && codec->supported_samplerates){
687 const int *p= codec->supported_samplerates;
689 int best_dist=INT_MAX;
691 int dist= abs(st->codec->sample_rate - *p);
692 if(dist < best_dist){
698 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
700 st->codec->sample_rate= best;
704 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
706 if(codec && codec->pix_fmts){
707 const enum PixelFormat *p= codec->pix_fmts;
708 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
709 if(st->codec->codec_id==CODEC_ID_MJPEG){
710 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
711 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
712 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};
716 if(*p == st->codec->pix_fmt)
720 if(st->codec->pix_fmt != PIX_FMT_NONE)
721 av_log(NULL, AV_LOG_WARNING,
722 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
723 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
725 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
726 st->codec->pix_fmt = codec->pix_fmts[0];
732 get_sync_ipts(const OutputStream *ost)
734 const InputStream *ist = ost->sync_ist;
735 OutputFile *of = &output_files[ost->file_index];
736 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
739 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
743 AVPacket new_pkt= *pkt;
744 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
745 &new_pkt.data, &new_pkt.size,
746 pkt->data, pkt->size,
747 pkt->flags & AV_PKT_FLAG_KEY);
750 new_pkt.destruct= av_destruct_packet;
752 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
753 bsfc->filter->name, pkt->stream_index,
754 avctx->codec ? avctx->codec->name : "copy");
764 ret= av_interleaved_write_frame(s, pkt);
766 print_error("av_interleaved_write_frame()", ret);
771 static void do_audio_out(AVFormatContext *s,
774 unsigned char *buf, int size)
777 int64_t audio_out_size, audio_buf_size;
778 int64_t allocated_for_size= size;
780 int size_out, frame_bytes, ret, resample_changed;
781 AVCodecContext *enc= ost->st->codec;
782 AVCodecContext *dec= ist->st->codec;
783 int osize = av_get_bytes_per_sample(enc->sample_fmt);
784 int isize = av_get_bytes_per_sample(dec->sample_fmt);
785 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
788 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
789 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
790 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
791 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
792 audio_buf_size*= osize*enc->channels;
794 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
795 if(coded_bps > 8*osize)
796 audio_out_size= audio_out_size * coded_bps / (8*osize);
797 audio_out_size += FF_MIN_BUFFER_SIZE;
799 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
800 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
804 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
805 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
806 if (!audio_buf || !audio_out){
807 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
811 if (enc->channels != dec->channels)
812 ost->audio_resample = 1;
814 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
815 ost->resample_channels != dec->channels ||
816 ost->resample_sample_rate != dec->sample_rate;
818 if ((ost->audio_resample && !ost->resample) || resample_changed) {
819 if (resample_changed) {
820 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",
821 ist->file_index, ist->st->index,
822 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
823 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
824 ost->resample_sample_fmt = dec->sample_fmt;
825 ost->resample_channels = dec->channels;
826 ost->resample_sample_rate = dec->sample_rate;
828 audio_resample_close(ost->resample);
830 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
831 if (audio_sync_method <= 1 &&
832 ost->resample_sample_fmt == enc->sample_fmt &&
833 ost->resample_channels == enc->channels &&
834 ost->resample_sample_rate == enc->sample_rate) {
835 ost->resample = NULL;
836 ost->audio_resample = 0;
838 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
839 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
840 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
841 enc->sample_rate, dec->sample_rate,
842 enc->sample_fmt, dec->sample_fmt,
844 if (!ost->resample) {
845 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
846 dec->channels, dec->sample_rate,
847 enc->channels, enc->sample_rate);
853 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
854 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
855 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
856 if (ost->reformat_ctx)
857 av_audio_convert_free(ost->reformat_ctx);
858 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
859 dec->sample_fmt, 1, NULL, 0);
860 if (!ost->reformat_ctx) {
861 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
862 av_get_sample_fmt_name(dec->sample_fmt),
863 av_get_sample_fmt_name(enc->sample_fmt));
866 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
869 if(audio_sync_method){
870 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
871 - av_fifo_size(ost->fifo)/(enc->channels * 2);
872 double idelta= delta*dec->sample_rate / enc->sample_rate;
873 int byte_delta= ((int)idelta)*2*dec->channels;
875 //FIXME resample delay
876 if(fabs(delta) > 50){
877 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
879 byte_delta= FFMAX(byte_delta, -size);
882 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
887 static uint8_t *input_tmp= NULL;
888 input_tmp= av_realloc(input_tmp, byte_delta + size);
890 if(byte_delta > allocated_for_size - size){
891 allocated_for_size= byte_delta + (int64_t)size;
896 memset(input_tmp, 0, byte_delta);
897 memcpy(input_tmp + byte_delta, buf, size);
900 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
902 }else if(audio_sync_method>1){
903 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
904 av_assert0(ost->audio_resample);
905 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
906 delta, comp, enc->sample_rate);
907 // 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));
908 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
912 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
913 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
915 if (ost->audio_resample) {
917 size_out = audio_resample(ost->resample,
918 (short *)buftmp, (short *)buf,
919 size / (dec->channels * isize));
920 size_out = size_out * enc->channels * osize;
926 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
927 const void *ibuf[6]= {buftmp};
928 void *obuf[6]= {audio_buf};
929 int istride[6]= {isize};
930 int ostride[6]= {osize};
931 int len= size_out/istride[0];
932 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
933 printf("av_audio_convert() failed\n");
939 size_out = len*osize;
942 /* now encode as many frames as possible */
943 if (enc->frame_size > 1) {
944 /* output resampled raw samples */
945 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
946 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
949 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
951 frame_bytes = enc->frame_size * osize * enc->channels;
953 while (av_fifo_size(ost->fifo) >= frame_bytes) {
955 av_init_packet(&pkt);
957 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
959 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
961 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
964 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
968 pkt.stream_index= ost->index;
971 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
972 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
973 pkt.flags |= AV_PKT_FLAG_KEY;
974 write_frame(s, &pkt, enc, ost->bitstream_filters);
976 ost->sync_opts += enc->frame_size;
980 av_init_packet(&pkt);
982 ost->sync_opts += size_out / (osize * enc->channels);
984 /* output a pcm frame */
985 /* determine the size of the coded buffer */
988 size_out = size_out*coded_bps/8;
990 if(size_out > audio_out_size){
991 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
995 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
996 ret = avcodec_encode_audio(enc, audio_out, size_out,
999 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1003 pkt.stream_index= ost->index;
1004 pkt.data= audio_out;
1006 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1007 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1008 pkt.flags |= AV_PKT_FLAG_KEY;
1009 write_frame(s, &pkt, enc, ost->bitstream_filters);
1013 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1015 AVCodecContext *dec;
1016 AVPicture *picture2;
1017 AVPicture picture_tmp;
1020 dec = ist->st->codec;
1022 /* deinterlace : must be done before any resize */
1023 if (do_deinterlace) {
1026 /* create temporary picture */
1027 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1028 buf = av_malloc(size);
1032 picture2 = &picture_tmp;
1033 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1035 if(avpicture_deinterlace(picture2, picture,
1036 dec->pix_fmt, dec->width, dec->height) < 0) {
1037 /* if error, do not deinterlace */
1038 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1047 if (picture != picture2)
1048 *picture = *picture2;
1052 static void do_subtitle_out(AVFormatContext *s,
1058 static uint8_t *subtitle_out = NULL;
1059 int subtitle_out_max_size = 1024 * 1024;
1060 int subtitle_out_size, nb, i;
1061 AVCodecContext *enc;
1064 if (pts == AV_NOPTS_VALUE) {
1065 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1071 enc = ost->st->codec;
1073 if (!subtitle_out) {
1074 subtitle_out = av_malloc(subtitle_out_max_size);
1077 /* Note: DVB subtitle need one packet to draw them and one other
1078 packet to clear them */
1079 /* XXX: signal it in the codec context ? */
1080 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1085 for(i = 0; i < nb; i++) {
1086 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1087 // start_display_time is required to be 0
1088 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1089 sub->end_display_time -= sub->start_display_time;
1090 sub->start_display_time = 0;
1091 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1092 subtitle_out_max_size, sub);
1093 if (subtitle_out_size < 0) {
1094 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1098 av_init_packet(&pkt);
1099 pkt.stream_index = ost->index;
1100 pkt.data = subtitle_out;
1101 pkt.size = subtitle_out_size;
1102 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1103 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1104 /* XXX: the pts correction is handled here. Maybe handling
1105 it in the codec would be better */
1107 pkt.pts += 90 * sub->start_display_time;
1109 pkt.pts += 90 * sub->end_display_time;
1111 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1115 static int bit_buffer_size= 1024*256;
1116 static uint8_t *bit_buffer= NULL;
1118 static void do_video_resample(OutputStream *ost,
1120 AVFrame *in_picture,
1121 AVFrame **out_picture)
1123 int resample_changed = 0;
1124 AVCodecContext *dec = ist->st->codec;
1125 AVCodecContext *enc = ost->st->codec;
1126 *out_picture = in_picture;
1128 resample_changed = ost->resample_width != dec->width ||
1129 ost->resample_height != dec->height ||
1130 ost->resample_pix_fmt != dec->pix_fmt;
1132 #if !CONFIG_AVFILTER
1133 if (resample_changed) {
1134 av_log(NULL, AV_LOG_INFO,
1135 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1136 ist->file_index, ist->st->index,
1137 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1138 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1139 ost->resample_width = dec->width;
1140 ost->resample_height = dec->height;
1141 ost->resample_pix_fmt = dec->pix_fmt;
1144 ost->video_resample = dec->width != enc->width ||
1145 dec->height != enc->height ||
1146 dec->pix_fmt != enc->pix_fmt;
1148 if (ost->video_resample) {
1149 *out_picture = &ost->resample_frame;
1150 if (!ost->img_resample_ctx || resample_changed) {
1151 /* initialize the destination picture */
1152 if (!ost->resample_frame.data[0]) {
1153 avcodec_get_frame_defaults(&ost->resample_frame);
1154 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1155 enc->width, enc->height)) {
1156 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1160 /* initialize a new scaler context */
1161 sws_freeContext(ost->img_resample_ctx);
1162 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1163 enc->width, enc->height, enc->pix_fmt,
1164 ost->sws_flags, NULL, NULL, NULL);
1165 if (ost->img_resample_ctx == NULL) {
1166 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1170 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1171 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1174 if (resample_changed) {
1175 avfilter_graph_free(&ost->graph);
1176 if (configure_video_filters(ist, ost)) {
1177 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1182 if (resample_changed) {
1183 ost->resample_width = dec->width;
1184 ost->resample_height = dec->height;
1185 ost->resample_pix_fmt = dec->pix_fmt;
1190 static void do_video_out(AVFormatContext *s,
1193 AVFrame *in_picture,
1194 int *frame_size, float quality)
1196 int nb_frames, i, ret, format_video_sync;
1197 AVFrame *final_picture;
1198 AVCodecContext *enc;
1201 enc = ost->st->codec;
1203 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1205 /* by default, we output a single frame */
1210 format_video_sync = video_sync_method;
1211 if (format_video_sync < 0)
1212 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1214 if (format_video_sync) {
1215 double vdelta = sync_ipts - ost->sync_opts;
1216 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1219 else if (format_video_sync == 2) {
1222 }else if(vdelta>0.6)
1223 ost->sync_opts= lrintf(sync_ipts);
1224 }else if (vdelta > 1.1)
1225 nb_frames = lrintf(vdelta);
1226 //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);
1227 if (nb_frames == 0){
1229 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1230 }else if (nb_frames > 1) {
1231 nb_frames_dup += nb_frames - 1;
1232 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1235 ost->sync_opts= lrintf(sync_ipts);
1237 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1241 do_video_resample(ost, ist, in_picture, &final_picture);
1243 /* duplicates frame if needed */
1244 for(i=0;i<nb_frames;i++) {
1246 av_init_packet(&pkt);
1247 pkt.stream_index= ost->index;
1249 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1250 /* raw pictures are written as AVPicture structure to
1251 avoid any copies. We support temporarily the older
1253 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1254 enc->coded_frame->top_field_first = in_picture->top_field_first;
1255 pkt.data= (uint8_t *)final_picture;
1256 pkt.size= sizeof(AVPicture);
1257 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1258 pkt.flags |= AV_PKT_FLAG_KEY;
1260 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1262 AVFrame big_picture;
1264 big_picture= *final_picture;
1265 /* better than nothing: use input picture interlaced
1267 big_picture.interlaced_frame = in_picture->interlaced_frame;
1268 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1269 if (ost->top_field_first == -1)
1270 big_picture.top_field_first = in_picture->top_field_first;
1272 big_picture.top_field_first = !!ost->top_field_first;
1275 /* handles same_quant here. This is not correct because it may
1276 not be a global option */
1277 big_picture.quality = quality;
1278 if (!enc->me_threshold)
1279 big_picture.pict_type = 0;
1280 // big_picture.pts = AV_NOPTS_VALUE;
1281 big_picture.pts= ost->sync_opts;
1282 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1283 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1284 if (ost->forced_kf_index < ost->forced_kf_count &&
1285 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1286 big_picture.pict_type = AV_PICTURE_TYPE_I;
1287 ost->forced_kf_index++;
1289 ret = avcodec_encode_video(enc,
1290 bit_buffer, bit_buffer_size,
1293 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1298 pkt.data= bit_buffer;
1300 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1301 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1302 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1303 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1304 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1306 if(enc->coded_frame->key_frame)
1307 pkt.flags |= AV_PKT_FLAG_KEY;
1308 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1311 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1312 // enc->frame_number-1, ret, enc->pict_type);
1313 /* if two pass, output log */
1314 if (ost->logfile && enc->stats_out) {
1315 fprintf(ost->logfile, "%s", enc->stats_out);
1320 ost->frame_number++;
1324 static double psnr(double d){
1325 return -10.0*log(d)/log(10.0);
1328 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1331 AVCodecContext *enc;
1333 double ti1, bitrate, avg_bitrate;
1335 /* this is executed just the first time do_video_stats is called */
1337 vstats_file = fopen(vstats_filename, "w");
1344 enc = ost->st->codec;
1345 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1346 frame_number = ost->frame_number;
1347 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1348 if (enc->flags&CODEC_FLAG_PSNR)
1349 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1351 fprintf(vstats_file,"f_size= %6d ", frame_size);
1352 /* compute pts value */
1353 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1357 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1358 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1359 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1360 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1361 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1365 static void print_report(OutputFile *output_files,
1366 OutputStream *ost_table, int nb_ostreams,
1367 int is_last_report, int64_t timer_start)
1371 AVFormatContext *oc;
1373 AVCodecContext *enc;
1374 int frame_number, vid, i;
1376 int64_t pts = INT64_MAX;
1377 static int64_t last_time = -1;
1378 static int qp_histogram[52];
1379 int hours, mins, secs, us;
1381 if (!print_stats && !is_last_report)
1384 if (!is_last_report) {
1386 /* display the report every 0.5 seconds */
1387 cur_time = av_gettime();
1388 if (last_time == -1) {
1389 last_time = cur_time;
1392 if ((cur_time - last_time) < 500000)
1394 last_time = cur_time;
1398 oc = output_files[0].ctx;
1400 total_size = avio_size(oc->pb);
1401 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1402 total_size= avio_tell(oc->pb);
1406 for(i=0;i<nb_ostreams;i++) {
1408 ost = &ost_table[i];
1409 enc = ost->st->codec;
1410 if (!ost->stream_copy && enc->coded_frame)
1411 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1412 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1413 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1415 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1416 float t = (av_gettime()-timer_start) / 1000000.0;
1418 frame_number = ost->frame_number;
1419 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1420 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1422 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1426 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1429 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1431 if (enc->flags&CODEC_FLAG_PSNR){
1433 double error, error_sum=0;
1434 double scale, scale_sum=0;
1435 char type[3]= {'Y','U','V'};
1436 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1439 error= enc->error[j];
1440 scale= enc->width*enc->height*255.0*255.0*frame_number;
1442 error= enc->coded_frame->error[j];
1443 scale= enc->width*enc->height*255.0*255.0;
1448 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1450 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1454 /* compute min output value */
1455 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1456 ost->st->time_base, AV_TIME_BASE_Q));
1459 secs = pts / AV_TIME_BASE;
1460 us = pts % AV_TIME_BASE;
1466 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1468 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1469 "size=%8.0fkB time=", total_size / 1024.0);
1470 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1471 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1472 (100 * us) / AV_TIME_BASE);
1473 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1474 "bitrate=%6.1fkbits/s", bitrate);
1476 if (nb_frames_dup || nb_frames_drop)
1477 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1478 nb_frames_dup, nb_frames_drop);
1480 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1484 if (is_last_report) {
1485 int64_t raw= audio_size + video_size + extra_size;
1486 av_log(NULL, AV_LOG_INFO, "\n");
1487 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1491 100.0*(total_size - raw)/raw
1496 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1498 int fill_char = 0x00;
1499 if (sample_fmt == AV_SAMPLE_FMT_U8)
1501 memset(buf, fill_char, size);
1504 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1508 for (i = 0; i < nb_ostreams; i++) {
1509 OutputStream *ost = &ost_table[i];
1510 AVCodecContext *enc = ost->st->codec;
1511 AVFormatContext *os = output_files[ost->file_index].ctx;
1513 if (!ost->encoding_needed)
1516 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1518 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1524 av_init_packet(&pkt);
1525 pkt.stream_index= ost->index;
1527 switch (ost->st->codec->codec_type) {
1528 case AVMEDIA_TYPE_AUDIO:
1529 fifo_bytes = av_fifo_size(ost->fifo);
1531 /* encode any samples remaining in fifo */
1532 if (fifo_bytes > 0) {
1533 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1534 int fs_tmp = enc->frame_size;
1536 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1537 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1538 enc->frame_size = fifo_bytes / (osize * enc->channels);
1540 int frame_bytes = enc->frame_size*osize*enc->channels;
1541 if (allocated_audio_buf_size < frame_bytes)
1543 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1546 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1547 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1548 ost->st->time_base.num, enc->sample_rate);
1549 enc->frame_size = fs_tmp;
1552 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1555 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1559 pkt.flags |= AV_PKT_FLAG_KEY;
1561 case AVMEDIA_TYPE_VIDEO:
1562 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1564 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1568 if(enc->coded_frame && enc->coded_frame->key_frame)
1569 pkt.flags |= AV_PKT_FLAG_KEY;
1570 if (ost->logfile && enc->stats_out) {
1571 fprintf(ost->logfile, "%s", enc->stats_out);
1580 pkt.data = bit_buffer;
1582 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1583 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1584 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1589 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1590 static int output_packet(InputStream *ist, int ist_index,
1591 OutputStream *ost_table, int nb_ostreams,
1592 const AVPacket *pkt)
1594 AVFormatContext *os;
1598 void *buffer_to_free = NULL;
1599 static unsigned int samples_size= 0;
1600 AVSubtitle subtitle, *subtitle_to_free;
1601 int64_t pkt_pts = AV_NOPTS_VALUE;
1603 int frame_available;
1608 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1610 if(ist->next_pts == AV_NOPTS_VALUE)
1611 ist->next_pts= ist->pts;
1615 av_init_packet(&avpkt);
1623 if(pkt->dts != AV_NOPTS_VALUE)
1624 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1625 if(pkt->pts != AV_NOPTS_VALUE)
1626 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1628 //while we have more to decode or while the decoder did output something on EOF
1629 while (avpkt.size > 0 || (!pkt && got_output)) {
1630 uint8_t *data_buf, *decoded_data_buf;
1631 int data_size, decoded_data_size;
1632 AVFrame *decoded_frame, *filtered_frame;
1634 ist->pts= ist->next_pts;
1636 if(avpkt.size && avpkt.size != pkt->size)
1637 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1638 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1639 ist->showed_multi_packet_warning=1;
1641 /* decode the packet if needed */
1642 decoded_frame = filtered_frame = NULL;
1643 decoded_data_buf = NULL; /* fail safe */
1644 decoded_data_size= 0;
1645 data_buf = avpkt.data;
1646 data_size = avpkt.size;
1647 subtitle_to_free = NULL;
1648 if (ist->decoding_needed) {
1649 switch(ist->st->codec->codec_type) {
1650 case AVMEDIA_TYPE_AUDIO:{
1651 if(pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1652 samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1654 samples= av_malloc(samples_size);
1656 decoded_data_size= samples_size;
1657 /* XXX: could avoid copy if PCM 16 bits with same
1658 endianness as CPU */
1659 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1666 got_output = decoded_data_size > 0;
1667 /* Some bug in mpeg audio decoder gives */
1668 /* decoded_data_size < 0, it seems they are overflows */
1670 /* no audio frame */
1673 decoded_data_buf = (uint8_t *)samples;
1674 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1675 (ist->st->codec->sample_rate * ist->st->codec->channels);
1677 case AVMEDIA_TYPE_VIDEO:
1678 if (!(decoded_frame = avcodec_alloc_frame()))
1679 return AVERROR(ENOMEM);
1680 avpkt.pts = pkt_pts;
1681 avpkt.dts = ist->pts;
1682 pkt_pts = AV_NOPTS_VALUE;
1684 ret = avcodec_decode_video2(ist->st->codec,
1685 decoded_frame, &got_output, &avpkt);
1686 quality = same_quant ? decoded_frame->quality : 0;
1690 /* no picture yet */
1691 av_freep(&decoded_frame);
1692 goto discard_packet;
1694 ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
1695 if (ist->st->codec->time_base.num != 0) {
1696 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1697 ist->next_pts += ((int64_t)AV_TIME_BASE *
1698 ist->st->codec->time_base.num * ticks) /
1699 ist->st->codec->time_base.den;
1702 buffer_to_free = NULL;
1703 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1705 case AVMEDIA_TYPE_SUBTITLE:
1706 ret = avcodec_decode_subtitle2(ist->st->codec,
1707 &subtitle, &got_output, &avpkt);
1711 goto discard_packet;
1713 subtitle_to_free = &subtitle;
1720 switch(ist->st->codec->codec_type) {
1721 case AVMEDIA_TYPE_AUDIO:
1722 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1723 ist->st->codec->sample_rate;
1725 case AVMEDIA_TYPE_VIDEO:
1726 if (ist->st->codec->time_base.num != 0) {
1727 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1728 ist->next_pts += ((int64_t)AV_TIME_BASE *
1729 ist->st->codec->time_base.num * ticks) /
1730 ist->st->codec->time_base.den;
1737 // preprocess audio (volume)
1738 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1739 if (audio_volume != 256) {
1740 switch (ist->st->codec->sample_fmt) {
1741 case AV_SAMPLE_FMT_U8:
1743 uint8_t *volp = samples;
1744 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1745 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1746 *volp++ = av_clip_uint8(v);
1750 case AV_SAMPLE_FMT_S16:
1752 int16_t *volp = samples;
1753 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1754 int v = ((*volp) * audio_volume + 128) >> 8;
1755 *volp++ = av_clip_int16(v);
1759 case AV_SAMPLE_FMT_S32:
1761 int32_t *volp = samples;
1762 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1763 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1764 *volp++ = av_clipl_int32(v);
1768 case AV_SAMPLE_FMT_FLT:
1770 float *volp = samples;
1771 float scale = audio_volume / 256.f;
1772 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1777 case AV_SAMPLE_FMT_DBL:
1779 double *volp = samples;
1780 double scale = audio_volume / 256.;
1781 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1787 av_log(NULL, AV_LOG_FATAL,
1788 "Audio volume adjustment on sample format %s is not supported.\n",
1789 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1795 /* frame rate emulation */
1796 if (input_files[ist->file_index].rate_emu) {
1797 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1798 int64_t now = av_gettime() - ist->start;
1802 /* if output time reached then transcode raw format,
1803 encode packets and output them */
1804 for (i = 0; i < nb_ostreams; i++) {
1805 OutputFile *of = &output_files[ost_table[i].file_index];
1808 ost = &ost_table[i];
1809 if (ost->source_index != ist_index)
1812 if (of->start_time && ist->pts < of->start_time)
1815 if (of->recording_time != INT64_MAX &&
1816 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1817 (AVRational){1, 1000000}) >= 0) {
1818 ost->is_past_recording_time = 1;
1823 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1824 ost->input_video_filter) {
1825 if (!decoded_frame->sample_aspect_ratio.num)
1826 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1827 decoded_frame->pts = ist->pts;
1829 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
1830 if (!(filtered_frame = avcodec_alloc_frame())) {
1831 ret = AVERROR(ENOMEM);
1835 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1836 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1837 while (frame_available) {
1838 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1839 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1840 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1843 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
1844 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1848 filtered_frame = decoded_frame;
1850 os = output_files[ost->file_index].ctx;
1852 /* set the input output pts pairs */
1853 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1855 if (ost->encoding_needed) {
1856 av_assert0(ist->decoding_needed);
1857 switch(ost->st->codec->codec_type) {
1858 case AVMEDIA_TYPE_AUDIO:
1859 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1861 case AVMEDIA_TYPE_VIDEO:
1863 if (ost->picref->video && !ost->frame_aspect_ratio)
1864 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1866 do_video_out(os, ost, ist, filtered_frame, &frame_size,
1867 same_quant ? quality : ost->st->codec->global_quality);
1868 if (vstats_filename && frame_size)
1869 do_video_stats(os, ost, frame_size);
1871 case AVMEDIA_TYPE_SUBTITLE:
1872 do_subtitle_out(os, ost, ist, &subtitle,
1881 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1882 av_init_packet(&opkt);
1884 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1885 #if !CONFIG_AVFILTER
1891 /* no reencoding needed : output the packet directly */
1892 /* force the input stream PTS */
1894 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1895 audio_size += data_size;
1896 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1897 video_size += data_size;
1901 opkt.stream_index= ost->index;
1902 if(pkt->pts != AV_NOPTS_VALUE)
1903 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1905 opkt.pts= AV_NOPTS_VALUE;
1907 if (pkt->dts == AV_NOPTS_VALUE)
1908 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1910 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1911 opkt.dts -= ost_tb_start_time;
1913 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1914 opkt.flags= pkt->flags;
1916 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1917 if( ost->st->codec->codec_id != CODEC_ID_H264
1918 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1919 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1921 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1922 opkt.destruct= av_destruct_packet;
1924 opkt.data = data_buf;
1925 opkt.size = data_size;
1928 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1929 /* store AVPicture in AVPacket, as expected by the output format */
1930 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1931 opkt.data = (uint8_t *)&pict;
1932 opkt.size = sizeof(AVPicture);
1933 opkt.flags |= AV_PKT_FLAG_KEY;
1935 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1936 ost->st->codec->frame_number++;
1937 ost->frame_number++;
1938 av_free_packet(&opkt);
1942 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1943 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1945 avfilter_unref_buffer(ost->picref);
1947 av_freep(&filtered_frame);
1952 av_free(buffer_to_free);
1953 /* XXX: allocate the subtitles in the codec ? */
1954 if (subtitle_to_free) {
1955 avsubtitle_free(subtitle_to_free);
1956 subtitle_to_free = NULL;
1958 av_freep(&decoded_frame);
1967 static void print_sdp(OutputFile *output_files, int n)
1971 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1975 for (i = 0; i < n; i++)
1976 avc[i] = output_files[i].ctx;
1978 av_sdp_create(avc, n, sdp, sizeof(sdp));
1979 printf("SDP:\n%s\n", sdp);
1984 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1985 char *error, int error_len)
1988 InputStream *ist = &input_streams[ist_index];
1989 if (ist->decoding_needed) {
1990 AVCodec *codec = ist->dec;
1992 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1993 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1994 return AVERROR(EINVAL);
1997 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1998 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1999 ist->file_index, ist->st->index);
2000 return AVERROR(EINVAL);
2002 assert_codec_experimental(ist->st->codec, 0);
2003 assert_avoptions(ist->opts);
2006 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;
2007 ist->next_pts = AV_NOPTS_VALUE;
2013 static int transcode_init(OutputFile *output_files,
2014 int nb_output_files,
2015 InputFile *input_files,
2018 int ret = 0, i, j, k;
2019 AVFormatContext *os;
2020 AVCodecContext *codec, *icodec;
2026 /* init framerate emulation */
2027 for (i = 0; i < nb_input_files; i++) {
2028 InputFile *ifile = &input_files[i];
2029 if (ifile->rate_emu)
2030 for (j = 0; j < ifile->nb_streams; j++)
2031 input_streams[j + ifile->ist_index].start = av_gettime();
2034 /* output stream init */
2035 for(i=0;i<nb_output_files;i++) {
2036 os = output_files[i].ctx;
2037 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2038 av_dump_format(os, i, os->filename, 1);
2039 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2040 return AVERROR(EINVAL);
2044 /* for each output stream, we compute the right encoding parameters */
2045 for (i = 0; i < nb_output_streams; i++) {
2046 ost = &output_streams[i];
2047 os = output_files[ost->file_index].ctx;
2048 ist = &input_streams[ost->source_index];
2050 codec = ost->st->codec;
2051 icodec = ist->st->codec;
2053 ost->st->disposition = ist->st->disposition;
2054 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2055 codec->chroma_sample_location = icodec->chroma_sample_location;
2057 if (ost->stream_copy) {
2058 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2060 if (extra_size > INT_MAX) {
2061 return AVERROR(EINVAL);
2064 /* if stream_copy is selected, no need to decode or encode */
2065 codec->codec_id = icodec->codec_id;
2066 codec->codec_type = icodec->codec_type;
2068 if(!codec->codec_tag){
2069 if( !os->oformat->codec_tag
2070 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2071 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2072 codec->codec_tag = icodec->codec_tag;
2075 codec->bit_rate = icodec->bit_rate;
2076 codec->rc_max_rate = icodec->rc_max_rate;
2077 codec->rc_buffer_size = icodec->rc_buffer_size;
2078 codec->extradata= av_mallocz(extra_size);
2079 if (!codec->extradata) {
2080 return AVERROR(ENOMEM);
2082 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2083 codec->extradata_size= icodec->extradata_size;
2085 codec->time_base = ist->st->time_base;
2086 if(!strcmp(os->oformat->name, "avi")) {
2087 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){
2088 codec->time_base = icodec->time_base;
2089 codec->time_base.num *= icodec->ticks_per_frame;
2090 codec->time_base.den *= 2;
2092 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2093 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){
2094 codec->time_base = icodec->time_base;
2095 codec->time_base.num *= icodec->ticks_per_frame;
2098 av_reduce(&codec->time_base.num, &codec->time_base.den,
2099 codec->time_base.num, codec->time_base.den, INT_MAX);
2101 switch(codec->codec_type) {
2102 case AVMEDIA_TYPE_AUDIO:
2103 if(audio_volume != 256) {
2104 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2107 codec->channel_layout = icodec->channel_layout;
2108 codec->sample_rate = icodec->sample_rate;
2109 codec->channels = icodec->channels;
2110 codec->frame_size = icodec->frame_size;
2111 codec->audio_service_type = icodec->audio_service_type;
2112 codec->block_align= icodec->block_align;
2113 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2114 codec->block_align= 0;
2115 if(codec->codec_id == CODEC_ID_AC3)
2116 codec->block_align= 0;
2118 case AVMEDIA_TYPE_VIDEO:
2119 codec->pix_fmt = icodec->pix_fmt;
2120 codec->width = icodec->width;
2121 codec->height = icodec->height;
2122 codec->has_b_frames = icodec->has_b_frames;
2123 if (!codec->sample_aspect_ratio.num) {
2124 codec->sample_aspect_ratio =
2125 ost->st->sample_aspect_ratio =
2126 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2127 ist->st->codec->sample_aspect_ratio.num ?
2128 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2131 case AVMEDIA_TYPE_SUBTITLE:
2132 codec->width = icodec->width;
2133 codec->height = icodec->height;
2135 case AVMEDIA_TYPE_DATA:
2136 case AVMEDIA_TYPE_ATTACHMENT:
2143 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2144 ist->decoding_needed = 1;
2145 ost->encoding_needed = 1;
2146 switch(codec->codec_type) {
2147 case AVMEDIA_TYPE_AUDIO:
2148 ost->fifo= av_fifo_alloc(1024);
2150 return AVERROR(ENOMEM);
2152 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2153 if (!codec->sample_rate)
2154 codec->sample_rate = icodec->sample_rate;
2155 choose_sample_rate(ost->st, ost->enc);
2156 codec->time_base = (AVRational){1, codec->sample_rate};
2157 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2158 codec->sample_fmt = icodec->sample_fmt;
2159 choose_sample_fmt(ost->st, ost->enc);
2160 if (!codec->channels) {
2161 codec->channels = icodec->channels;
2162 codec->channel_layout = icodec->channel_layout;
2164 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2165 codec->channel_layout = 0;
2166 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2167 icodec->request_channels = codec->channels;
2168 ost->resample_sample_fmt = icodec->sample_fmt;
2169 ost->resample_sample_rate = icodec->sample_rate;
2170 ost->resample_channels = icodec->channels;
2172 case AVMEDIA_TYPE_VIDEO:
2173 if (codec->pix_fmt == PIX_FMT_NONE)
2174 codec->pix_fmt = icodec->pix_fmt;
2175 choose_pixel_fmt(ost->st, ost->enc);
2177 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2178 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2182 if (!codec->width || !codec->height) {
2183 codec->width = icodec->width;
2184 codec->height = icodec->height;
2187 ost->video_resample = codec->width != icodec->width ||
2188 codec->height != icodec->height ||
2189 codec->pix_fmt != icodec->pix_fmt;
2190 if (ost->video_resample) {
2191 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2194 ost->resample_height = icodec->height;
2195 ost->resample_width = icodec->width;
2196 ost->resample_pix_fmt= icodec->pix_fmt;
2198 if (!ost->frame_rate.num)
2199 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2200 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2201 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2202 ost->frame_rate = ost->enc->supported_framerates[idx];
2204 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2205 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2206 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2207 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2208 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2212 if (configure_video_filters(ist, ost)) {
2213 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2218 case AVMEDIA_TYPE_SUBTITLE:
2225 if (codec->codec_id != CODEC_ID_H264 &&
2226 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2227 char logfilename[1024];
2230 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2231 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2233 if (codec->flags & CODEC_FLAG_PASS1) {
2234 f = fopen(logfilename, "wb");
2236 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2237 logfilename, strerror(errno));
2243 size_t logbuffer_size;
2244 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2245 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2249 codec->stats_in = logbuffer;
2253 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2254 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2255 int size= codec->width * codec->height;
2256 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2261 bit_buffer = av_malloc(bit_buffer_size);
2263 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2265 return AVERROR(ENOMEM);
2268 /* open each encoder */
2269 for (i = 0; i < nb_output_streams; i++) {
2270 ost = &output_streams[i];
2271 if (ost->encoding_needed) {
2272 AVCodec *codec = ost->enc;
2273 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2275 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2276 ost->st->codec->codec_id, ost->file_index, ost->index);
2277 ret = AVERROR(EINVAL);
2280 if (dec->subtitle_header) {
2281 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2282 if (!ost->st->codec->subtitle_header) {
2283 ret = AVERROR(ENOMEM);
2286 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2287 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2289 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2290 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2291 ost->file_index, ost->index);
2292 ret = AVERROR(EINVAL);
2295 assert_codec_experimental(ost->st->codec, 1);
2296 assert_avoptions(ost->opts);
2297 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2298 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2299 "It takes bits/s as argument, not kbits/s\n");
2300 extra_size += ost->st->codec->extradata_size;
2302 if (ost->st->codec->me_threshold)
2303 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2307 /* init input streams */
2308 for (i = 0; i < nb_input_streams; i++)
2309 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2312 /* discard unused programs */
2313 for (i = 0; i < nb_input_files; i++) {
2314 InputFile *ifile = &input_files[i];
2315 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2316 AVProgram *p = ifile->ctx->programs[j];
2317 int discard = AVDISCARD_ALL;
2319 for (k = 0; k < p->nb_stream_indexes; k++)
2320 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2321 discard = AVDISCARD_DEFAULT;
2324 p->discard = discard;
2328 /* open files and write file headers */
2329 for (i = 0; i < nb_output_files; i++) {
2330 os = output_files[i].ctx;
2331 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2332 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2333 ret = AVERROR(EINVAL);
2336 // assert_avoptions(output_files[i].opts);
2337 if (strcmp(os->oformat->name, "rtp")) {
2343 /* dump the file output parameters - cannot be done before in case
2345 for(i=0;i<nb_output_files;i++) {
2346 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2349 /* dump the stream mapping */
2350 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2351 for (i = 0; i < nb_output_streams; i++) {
2352 ost = &output_streams[i];
2353 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d -> #%d.%d",
2354 input_streams[ost->source_index].file_index,
2355 input_streams[ost->source_index].st->index,
2358 if (ost->sync_ist != &input_streams[ost->source_index])
2359 av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
2360 ost->sync_ist->file_index,
2361 ost->sync_ist->st->index);
2362 if (ost->stream_copy)
2363 av_log(NULL, AV_LOG_INFO, " (copy)");
2365 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2366 input_streams[ost->source_index].dec->name : "?",
2367 ost->enc ? ost->enc->name : "?");
2368 av_log(NULL, AV_LOG_INFO, "\n");
2372 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2377 print_sdp(output_files, nb_output_files);
2384 * The following code is the main loop of the file converter
2386 static int transcode(OutputFile *output_files,
2387 int nb_output_files,
2388 InputFile *input_files,
2392 AVFormatContext *is, *os;
2396 int no_packet_count=0;
2397 int64_t timer_start;
2400 if (!(no_packet = av_mallocz(nb_input_files)))
2403 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2408 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2409 avio_set_interrupt_cb(decode_interrupt_cb);
2413 timer_start = av_gettime();
2415 for(; received_sigterm == 0;) {
2416 int file_index, ist_index;
2421 ipts_min = INT64_MAX;
2423 /* if 'q' pressed, exits */
2427 /* read_key() returns 0 on EOF */
2431 if (key == '+') av_log_set_level(av_log_get_level()+10);
2432 if (key == '-') av_log_set_level(av_log_get_level()-10);
2433 if (key == 's') qp_hist ^= 1;
2436 do_hex_dump = do_pkt_dump = 0;
2437 } else if(do_pkt_dump){
2441 av_log_set_level(AV_LOG_DEBUG);
2443 if (key == 'd' || key == 'D'){
2446 debug = input_streams[0].st->codec->debug<<1;
2447 if(!debug) debug = 1;
2448 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2451 scanf("%d", &debug);
2452 for(i=0;i<nb_input_streams;i++) {
2453 input_streams[i].st->codec->debug = debug;
2455 for(i=0;i<nb_output_streams;i++) {
2456 ost = &output_streams[i];
2457 ost->st->codec->debug = debug;
2459 if(debug) av_log_set_level(AV_LOG_DEBUG);
2460 fprintf(stderr,"debug=%d\n", debug);
2463 fprintf(stderr, "key function\n"
2464 "? show this help\n"
2465 "+ increase verbosity\n"
2466 "- decrease verbosity\n"
2467 "D cycle through available debug modes\n"
2468 "h dump packets/hex press to cycle through the 3 states\n"
2470 "s Show QP histogram\n"
2475 /* select the stream that we must read now by looking at the
2476 smallest output pts */
2478 for (i = 0; i < nb_output_streams; i++) {
2482 ost = &output_streams[i];
2483 of = &output_files[ost->file_index];
2484 os = output_files[ost->file_index].ctx;
2485 ist = &input_streams[ost->source_index];
2486 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2487 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2489 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2491 if (!input_files[ist->file_index].eof_reached){
2492 if(ipts < ipts_min) {
2494 if(input_sync ) file_index = ist->file_index;
2496 if(opts < opts_min) {
2498 if(!input_sync) file_index = ist->file_index;
2501 if (ost->frame_number >= ost->max_frames) {
2503 for (j = 0; j < of->ctx->nb_streams; j++)
2504 output_streams[of->ost_index + j].is_past_recording_time = 1;
2508 /* if none, if is finished */
2509 if (file_index < 0) {
2510 if(no_packet_count){
2512 memset(no_packet, 0, nb_input_files);
2519 /* read a frame from it and output it in the fifo */
2520 is = input_files[file_index].ctx;
2521 ret= av_read_frame(is, &pkt);
2522 if(ret == AVERROR(EAGAIN)){
2523 no_packet[file_index]=1;
2528 input_files[file_index].eof_reached = 1;
2536 memset(no_packet, 0, nb_input_files);
2539 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2540 is->streams[pkt.stream_index]);
2542 /* the following test is needed in case new streams appear
2543 dynamically in stream : we ignore them */
2544 if (pkt.stream_index >= input_files[file_index].nb_streams)
2545 goto discard_packet;
2546 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2547 ist = &input_streams[ist_index];
2549 goto discard_packet;
2551 if (pkt.dts != AV_NOPTS_VALUE)
2552 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2553 if (pkt.pts != AV_NOPTS_VALUE)
2554 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2556 if(pkt.pts != AV_NOPTS_VALUE)
2557 pkt.pts *= ist->ts_scale;
2558 if(pkt.dts != AV_NOPTS_VALUE)
2559 pkt.dts *= ist->ts_scale;
2561 // 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);
2562 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2563 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2564 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2565 int64_t delta= pkt_dts - ist->next_pts;
2566 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2567 input_files[ist->file_index].ts_offset -= delta;
2568 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2569 delta, input_files[ist->file_index].ts_offset);
2570 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2571 if(pkt.pts != AV_NOPTS_VALUE)
2572 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2576 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2577 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2579 av_log(NULL, AV_LOG_ERROR, "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->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 double parse_frame_aspect_ratio(const char *arg)
2676 p = strchr(arg, ':');
2678 x = strtol(arg, &end, 10);
2680 y = strtol(end+1, &end, 10);
2682 ar = (double)x / (double)y;
2684 ar = strtod(arg, NULL);
2687 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2693 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2695 return parse_option(o, "codec:a", arg, options);
2698 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2700 return parse_option(o, "codec:v", arg, options);
2703 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2705 return parse_option(o, "codec:s", arg, options);
2708 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2710 return parse_option(o, "codec:d", arg, options);
2713 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2715 StreamMap *m = NULL;
2716 int i, negative = 0, file_idx;
2717 int sync_file_idx = -1, sync_stream_idx;
2725 map = av_strdup(arg);
2727 /* parse sync stream first, just pick first matching stream */
2728 if (sync = strchr(map, ',')) {
2730 sync_file_idx = strtol(sync + 1, &sync, 0);
2731 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2732 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2737 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2738 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2739 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2740 sync_stream_idx = i;
2743 if (i == input_files[sync_file_idx].nb_streams) {
2744 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2745 "match any streams.\n", arg);
2751 file_idx = strtol(map, &p, 0);
2752 if (file_idx >= nb_input_files || file_idx < 0) {
2753 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2757 /* disable some already defined maps */
2758 for (i = 0; i < o->nb_stream_maps; i++) {
2759 m = &o->stream_maps[i];
2760 if (check_stream_specifier(input_files[m->file_index].ctx,
2761 input_files[m->file_index].ctx->streams[m->stream_index],
2762 *p == ':' ? p + 1 : p) > 0)
2766 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2767 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2768 *p == ':' ? p + 1 : p) <= 0)
2770 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2771 &o->nb_stream_maps, o->nb_stream_maps + 1);
2772 m = &o->stream_maps[o->nb_stream_maps - 1];
2774 m->file_index = file_idx;
2775 m->stream_index = i;
2777 if (sync_file_idx >= 0) {
2778 m->sync_file_index = sync_file_idx;
2779 m->sync_stream_index = sync_stream_idx;
2781 m->sync_file_index = file_idx;
2782 m->sync_stream_index = i;
2787 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2795 static void parse_meta_type(char *arg, char *type, int *index)
2805 if (*(++arg) == ':')
2806 *index = strtol(++arg, NULL, 0);
2809 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2816 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2818 MetadataMap *m, *m1;
2821 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2822 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2824 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2825 m->file = strtol(arg, &p, 0);
2826 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2828 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2829 if (p = strchr(opt, ':'))
2830 parse_meta_type(p + 1, &m1->type, &m1->index);
2834 if (m->type == 'g' || m1->type == 'g')
2835 o->metadata_global_manual = 1;
2836 if (m->type == 's' || m1->type == 's')
2837 o->metadata_streams_manual = 1;
2838 if (m->type == 'c' || m1->type == 'c')
2839 o->metadata_chapters_manual = 1;
2844 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2846 const char *codec_string = encoder ? "encoder" : "decoder";
2850 avcodec_find_encoder_by_name(name) :
2851 avcodec_find_decoder_by_name(name);
2853 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2856 if(codec->type != type) {
2857 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2863 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
2865 char *codec_name = NULL;
2867 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2869 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
2870 st->codec->codec_id = codec->id;
2873 return avcodec_find_decoder(st->codec->codec_id);
2877 * Add all the streams from the given input file to the global
2878 * list of input streams.
2880 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2882 int i, rfps, rfps_base;
2884 for (i = 0; i < ic->nb_streams; i++) {
2885 AVStream *st = ic->streams[i];
2886 AVCodecContext *dec = st->codec;
2890 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2891 ist = &input_streams[nb_input_streams - 1];
2893 ist->file_index = nb_input_files;
2895 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2897 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2898 ist->ts_scale = scale;
2900 ist->dec = choose_decoder(o, ic, st);
2902 switch (dec->codec_type) {
2903 case AVMEDIA_TYPE_AUDIO:
2905 ist->dec = avcodec_find_decoder(dec->codec_id);
2906 if(o->audio_disable)
2907 st->discard= AVDISCARD_ALL;
2909 case AVMEDIA_TYPE_VIDEO:
2911 ist->dec = avcodec_find_decoder(dec->codec_id);
2912 rfps = ic->streams[i]->r_frame_rate.num;
2913 rfps_base = ic->streams[i]->r_frame_rate.den;
2915 dec->flags |= CODEC_FLAG_EMU_EDGE;
2918 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2920 av_log(NULL, AV_LOG_INFO,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2921 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2922 (float)rfps / rfps_base, rfps, rfps_base);
2925 if (o->video_disable)
2926 st->discard= AVDISCARD_ALL;
2927 else if(video_discard)
2928 st->discard= video_discard;
2930 case AVMEDIA_TYPE_DATA:
2932 case AVMEDIA_TYPE_SUBTITLE:
2934 ist->dec = avcodec_find_decoder(dec->codec_id);
2935 if(o->subtitle_disable)
2936 st->discard = AVDISCARD_ALL;
2938 case AVMEDIA_TYPE_ATTACHMENT:
2939 case AVMEDIA_TYPE_UNKNOWN:
2947 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2949 AVFormatContext *ic;
2950 AVInputFormat *file_iformat = NULL;
2954 AVDictionary **opts;
2955 int orig_nb_streams; // number of streams before avformat_find_stream_info
2958 if (!(file_iformat = av_find_input_format(o->format))) {
2959 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
2964 if (!strcmp(filename, "-"))
2967 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2968 !strcmp(filename, "/dev/stdin");
2970 /* get default parameters from command line */
2971 ic = avformat_alloc_context();
2973 print_error(filename, AVERROR(ENOMEM));
2976 if (o->nb_audio_sample_rate) {
2977 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2978 av_dict_set(&format_opts, "sample_rate", buf, 0);
2980 if (o->nb_audio_channels) {
2981 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2982 av_dict_set(&format_opts, "channels", buf, 0);
2984 if (o->nb_frame_rates) {
2985 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2987 if (o->nb_frame_sizes) {
2988 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2990 if (o->nb_frame_pix_fmts)
2991 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
2993 ic->flags |= AVFMT_FLAG_NONBLOCK;
2995 /* open the input file with generic libav function */
2996 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2998 print_error(filename, err);
3001 assert_avoptions(format_opts);
3003 /* apply forced codec ids */
3004 for (i = 0; i < ic->nb_streams; i++)
3005 choose_decoder(o, ic, ic->streams[i]);
3007 /* Set AVCodecContext options for avformat_find_stream_info */
3008 opts = setup_find_stream_info_opts(ic, codec_opts);
3009 orig_nb_streams = ic->nb_streams;
3011 /* If not enough info to get the stream parameters, we decode the
3012 first frames to get it. (used in mpeg case for example) */
3013 ret = avformat_find_stream_info(ic, opts);
3015 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3016 av_close_input_file(ic);
3020 timestamp = o->start_time;
3021 /* add the stream start time */
3022 if (ic->start_time != AV_NOPTS_VALUE)
3023 timestamp += ic->start_time;
3025 /* if seeking requested, we execute it */
3026 if (o->start_time != 0) {
3027 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3029 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3030 filename, (double)timestamp / AV_TIME_BASE);
3034 /* update the current parameters so that they match the one of the input stream */
3035 add_input_streams(o, ic);
3037 /* dump the file content */
3038 av_dump_format(ic, nb_input_files, filename, 0);
3040 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3041 input_files[nb_input_files - 1].ctx = ic;
3042 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3043 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3044 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3045 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3047 for (i = 0; i < orig_nb_streams; i++)
3048 av_dict_free(&opts[i]);
3055 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3056 AVCodecContext *avctx)
3062 for (p = kf; *p; p++)
3065 ost->forced_kf_count = n;
3066 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3067 if (!ost->forced_kf_pts) {
3068 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3071 for (i = 0; i < n; i++) {
3072 p = i ? strchr(p, ',') + 1 : kf;
3073 t = parse_time_or_die("force_key_frames", p, 1);
3074 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3078 static uint8_t *get_line(AVIOContext *s)
3084 if (avio_open_dyn_buf(&line) < 0) {
3085 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3089 while ((c = avio_r8(s)) && c != '\n')
3092 avio_close_dyn_buf(line, &buf);
3097 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3100 char filename[1000];
3101 const char *base[3] = { getenv("AVCONV_DATADIR"),
3106 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3110 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3111 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3112 ret = avio_open(s, filename, AVIO_FLAG_READ);
3115 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3116 i != 1 ? "" : "/.avconv", preset_name);
3117 ret = avio_open(s, filename, AVIO_FLAG_READ);
3123 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3125 char *codec_name = NULL;
3127 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3129 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3130 NULL, ost->st->codec->codec_type);
3131 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3132 } else if (!strcmp(codec_name, "copy"))
3133 ost->stream_copy = 1;
3135 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3136 ost->st->codec->codec_id = ost->enc->id;
3140 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3143 AVStream *st = avformat_new_stream(oc, NULL);
3144 int idx = oc->nb_streams - 1, ret = 0;
3145 int64_t max_frames = INT64_MAX;
3146 char *bsf = NULL, *next, *codec_tag = NULL;
3147 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3149 char *buf = NULL, *arg = NULL, *preset = NULL;
3150 AVIOContext *s = NULL;
3153 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3157 if (oc->nb_streams - 1 < o->nb_streamid_map)
3158 st->id = o->streamid_map[oc->nb_streams - 1];
3160 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3161 nb_output_streams + 1);
3162 ost = &output_streams[nb_output_streams - 1];
3163 ost->file_index = nb_output_files;
3166 st->codec->codec_type = type;
3167 choose_encoder(o, oc, ost);
3169 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3172 avcodec_get_context_defaults3(st->codec, ost->enc);
3173 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3175 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3176 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3179 if (!buf[0] || buf[0] == '#') {
3183 if (!(arg = strchr(buf, '='))) {
3184 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3188 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3190 } while (!s->eof_reached);
3194 av_log(NULL, AV_LOG_FATAL,
3195 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3196 preset, ost->file_index, ost->index);
3200 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3201 ost->max_frames = max_frames;
3203 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3205 if (next = strchr(bsf, ','))
3207 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3208 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3212 bsfc_prev->next = bsfc;
3214 ost->bitstream_filters = bsfc;
3220 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3222 uint32_t tag = strtol(codec_tag, &next, 0);
3224 tag = AV_RL32(codec_tag);
3225 st->codec->codec_tag = tag;
3228 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3229 if (qscale >= 0 || same_quant) {
3230 st->codec->flags |= CODEC_FLAG_QSCALE;
3231 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3234 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3235 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3237 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3241 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3244 const char *p = str;
3251 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3258 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3262 AVCodecContext *video_enc;
3264 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3266 video_enc = st->codec;
3268 if (!ost->stream_copy) {
3269 const char *p = NULL;
3270 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3271 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3272 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3273 int i, force_fps = 0, top_field_first = -1;
3275 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3276 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3277 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3281 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3282 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3283 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3287 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3288 if (frame_aspect_ratio)
3289 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3291 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3292 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3293 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3296 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3298 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3300 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3301 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3304 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3306 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3308 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3309 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3312 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3315 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3318 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3320 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3323 video_enc->rc_override=
3324 av_realloc(video_enc->rc_override,
3325 sizeof(RcOverride)*(i+1));
3326 video_enc->rc_override[i].start_frame= start;
3327 video_enc->rc_override[i].end_frame = end;
3329 video_enc->rc_override[i].qscale= q;
3330 video_enc->rc_override[i].quality_factor= 1.0;
3333 video_enc->rc_override[i].qscale= 0;
3334 video_enc->rc_override[i].quality_factor= -q/100.0;
3339 video_enc->rc_override_count=i;
3340 if (!video_enc->rc_initial_buffer_occupancy)
3341 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3342 video_enc->intra_dc_precision= intra_dc_precision - 8;
3347 video_enc->flags |= CODEC_FLAG_PASS1;
3349 video_enc->flags |= CODEC_FLAG_PASS2;
3353 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3354 if (forced_key_frames)
3355 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3357 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3358 ost->force_fps = force_fps;
3360 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3361 ost->top_field_first = top_field_first;
3364 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3366 ost->avfilter = av_strdup(filters);
3373 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3377 AVCodecContext *audio_enc;
3379 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3382 audio_enc = st->codec;
3383 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3385 if (!ost->stream_copy) {
3386 char *sample_fmt = NULL;
3388 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3390 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3392 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3393 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3397 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3403 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3407 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3408 if (!ost->stream_copy) {
3409 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3416 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3418 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3419 ost->stream_copy = 1;
3423 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3427 AVCodecContext *subtitle_enc;
3429 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3431 subtitle_enc = st->codec;
3433 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3438 /* arg format is "output-stream-index:streamid-value". */
3439 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3445 av_strlcpy(idx_str, arg, sizeof(idx_str));
3446 p = strchr(idx_str, ':');
3448 av_log(NULL, AV_LOG_FATAL,
3449 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3454 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3455 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3456 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3460 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3462 AVFormatContext *is = ifile->ctx;
3463 AVFormatContext *os = ofile->ctx;
3466 for (i = 0; i < is->nb_chapters; i++) {
3467 AVChapter *in_ch = is->chapters[i], *out_ch;
3468 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3469 AV_TIME_BASE_Q, in_ch->time_base);
3470 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3471 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3474 if (in_ch->end < ts_off)
3476 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3479 out_ch = av_mallocz(sizeof(AVChapter));
3481 return AVERROR(ENOMEM);
3483 out_ch->id = in_ch->id;
3484 out_ch->time_base = in_ch->time_base;
3485 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3486 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3489 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3492 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3494 return AVERROR(ENOMEM);
3495 os->chapters[os->nb_chapters - 1] = out_ch;
3500 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3503 AVFormatContext *ic = NULL;
3505 err = avformat_open_input(&ic, filename, NULL, NULL);
3508 /* copy stream format */
3509 for(i=0;i<ic->nb_streams;i++) {
3514 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3515 ost = new_output_stream(o, s, codec->type);
3518 // FIXME: a more elegant solution is needed
3519 memcpy(st, ic->streams[i], sizeof(AVStream));
3520 st->info = av_malloc(sizeof(*st->info));
3521 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3522 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3524 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3525 choose_sample_fmt(st, codec);
3526 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3527 choose_pixel_fmt(st, codec);
3530 av_close_input_file(ic);
3534 static void opt_output_file(void *optctx, const char *filename)
3536 OptionsContext *o = optctx;
3537 AVFormatContext *oc;
3539 AVOutputFormat *file_oformat;
3543 if (!strcmp(filename, "-"))
3546 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3548 print_error(filename, err);
3552 file_oformat= oc->oformat;
3554 if (!strcmp(file_oformat->name, "ffm") &&
3555 av_strstart(filename, "http:", NULL)) {
3556 /* special case for files sent to ffserver: we get the stream
3557 parameters from ffserver */
3558 int err = read_ffserver_streams(o, oc, filename);
3560 print_error(filename, err);
3563 } else if (!o->nb_stream_maps) {
3564 /* pick the "best" stream of each type */
3565 #define NEW_STREAM(type, index)\
3567 ost = new_ ## type ## _stream(o, oc);\
3568 ost->source_index = index;\
3569 ost->sync_ist = &input_streams[index];\
3570 input_streams[index].discard = 0;\
3573 /* video: highest resolution */
3574 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3575 int area = 0, idx = -1;
3576 for (i = 0; i < nb_input_streams; i++) {
3577 ist = &input_streams[i];
3578 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3579 ist->st->codec->width * ist->st->codec->height > area) {
3580 area = ist->st->codec->width * ist->st->codec->height;
3584 NEW_STREAM(video, idx);
3587 /* audio: most channels */
3588 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3589 int channels = 0, idx = -1;
3590 for (i = 0; i < nb_input_streams; i++) {
3591 ist = &input_streams[i];
3592 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3593 ist->st->codec->channels > channels) {
3594 channels = ist->st->codec->channels;
3598 NEW_STREAM(audio, idx);
3601 /* subtitles: pick first */
3602 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3603 for (i = 0; i < nb_input_streams; i++)
3604 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3605 NEW_STREAM(subtitle, i);
3609 /* do something with data? */
3611 for (i = 0; i < o->nb_stream_maps; i++) {
3612 StreamMap *map = &o->stream_maps[i];
3617 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3618 switch (ist->st->codec->codec_type) {
3619 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3620 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3621 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3622 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3623 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3625 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3626 map->file_index, map->stream_index);
3630 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3631 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3632 map->sync_stream_index];
3637 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3638 output_files[nb_output_files - 1].ctx = oc;
3639 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3640 output_files[nb_output_files - 1].recording_time = o->recording_time;
3641 output_files[nb_output_files - 1].start_time = o->start_time;
3642 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3643 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3645 /* check filename in case of an image number is expected */
3646 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3647 if (!av_filename_number_test(oc->filename)) {
3648 print_error(oc->filename, AVERROR(EINVAL));
3653 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3654 /* test if it already exists to avoid loosing precious files */
3655 if (!file_overwrite &&
3656 (strchr(filename, ':') == NULL ||
3657 filename[1] == ':' ||
3658 av_strstart(filename, "file:", NULL))) {
3659 if (avio_check(filename, 0) == 0) {
3661 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3663 if (!read_yesno()) {
3664 fprintf(stderr, "Not overwriting - exiting\n");
3669 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3676 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3677 print_error(filename, err);
3682 if (o->mux_preload) {
3684 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3685 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3687 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3690 if (o->chapters_input_file >= nb_input_files) {
3691 if (o->chapters_input_file == INT_MAX) {
3692 /* copy chapters from the first input file that has them*/
3693 o->chapters_input_file = -1;
3694 for (i = 0; i < nb_input_files; i++)
3695 if (input_files[i].ctx->nb_chapters) {
3696 o->chapters_input_file = i;
3700 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3701 o->chapters_input_file);
3705 if (o->chapters_input_file >= 0)
3706 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3707 !o->metadata_chapters_manual);
3710 for (i = 0; i < o->nb_meta_data_maps; i++) {
3711 AVFormatContext *files[2];
3712 AVDictionary **meta[2];
3715 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3716 if ((index) < 0 || (index) >= (nb_elems)) {\
3717 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3722 int in_file_index = o->meta_data_maps[i][1].file;
3723 if (in_file_index < 0)
3725 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3728 files[1] = input_files[in_file_index].ctx;
3730 for (j = 0; j < 2; j++) {
3731 MetadataMap *map = &o->meta_data_maps[i][j];
3733 switch (map->type) {
3735 meta[j] = &files[j]->metadata;
3738 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3739 meta[j] = &files[j]->streams[map->index]->metadata;
3742 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3743 meta[j] = &files[j]->chapters[map->index]->metadata;
3746 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3747 meta[j] = &files[j]->programs[map->index]->metadata;
3752 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3755 /* copy global metadata by default */
3756 if (!o->metadata_global_manual && nb_input_files)
3757 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3758 AV_DICT_DONT_OVERWRITE);
3759 if (!o->metadata_streams_manual)
3760 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3761 InputStream *ist = &input_streams[output_streams[i].source_index];
3762 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3765 /* process manually set metadata */
3766 for (i = 0; i < o->nb_metadata; i++) {
3771 val = strchr(o->metadata[i].u.str, '=');
3773 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3774 o->metadata[i].u.str);
3779 parse_meta_type(o->metadata[i].specifier, &type, &index);
3785 if (index < 0 || index >= oc->nb_streams) {
3786 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3789 m = &oc->streams[index]->metadata;
3792 if (index < 0 || index >= oc->nb_chapters) {
3793 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3796 m = &oc->chapters[index]->metadata;
3799 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3803 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3809 /* same option as mencoder */
3810 static int opt_pass(const char *opt, const char *arg)
3812 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3816 static int64_t getutime(void)
3819 struct rusage rusage;
3821 getrusage(RUSAGE_SELF, &rusage);
3822 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3823 #elif HAVE_GETPROCESSTIMES
3825 FILETIME c, e, k, u;
3826 proc = GetCurrentProcess();
3827 GetProcessTimes(proc, &c, &e, &k, &u);
3828 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3830 return av_gettime();
3834 static int64_t getmaxrss(void)
3836 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3837 struct rusage rusage;
3838 getrusage(RUSAGE_SELF, &rusage);
3839 return (int64_t)rusage.ru_maxrss * 1024;
3840 #elif HAVE_GETPROCESSMEMORYINFO
3842 PROCESS_MEMORY_COUNTERS memcounters;
3843 proc = GetCurrentProcess();
3844 memcounters.cb = sizeof(memcounters);
3845 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3846 return memcounters.PeakPagefileUsage;
3852 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3854 return parse_option(o, "q:a", arg, options);
3857 static void show_usage(void)
3859 printf("Hyper fast Audio and Video encoder\n");
3860 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3864 static int opt_help(const char *opt, const char *arg)
3866 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3867 av_log_set_callback(log_callback_help);
3869 show_help_options(options, "Main options:\n",
3870 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3871 show_help_options(options, "\nAdvanced options:\n",
3872 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3874 show_help_options(options, "\nVideo options:\n",
3875 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3877 show_help_options(options, "\nAdvanced Video options:\n",
3878 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3879 OPT_VIDEO | OPT_EXPERT);
3880 show_help_options(options, "\nAudio options:\n",
3881 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3883 show_help_options(options, "\nAdvanced Audio options:\n",
3884 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3885 OPT_AUDIO | OPT_EXPERT);
3886 show_help_options(options, "\nSubtitle options:\n",
3887 OPT_SUBTITLE | OPT_GRAB,
3889 show_help_options(options, "\nAudio/Video grab options:\n",
3893 show_help_children(avcodec_get_class(), flags);
3894 show_help_children(avformat_get_class(), flags);
3895 show_help_children(sws_get_class(), flags);
3900 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3902 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3903 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3905 if(!strncmp(arg, "pal-", 4)) {
3908 } else if(!strncmp(arg, "ntsc-", 5)) {
3911 } else if(!strncmp(arg, "film-", 5)) {
3915 /* Try to determine PAL/NTSC by peeking in the input files */
3916 if(nb_input_files) {
3918 for (j = 0; j < nb_input_files; j++) {
3919 for (i = 0; i < input_files[j].nb_streams; i++) {
3920 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3921 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3923 fr = c->time_base.den * 1000 / c->time_base.num;
3927 } else if((fr == 29970) || (fr == 23976)) {
3936 if (norm != UNKNOWN)
3937 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3940 if(norm == UNKNOWN) {
3941 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3942 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3943 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3947 if(!strcmp(arg, "vcd")) {
3948 opt_video_codec(o, "c:v", "mpeg1video");
3949 opt_audio_codec(o, "c:a", "mp2");
3950 parse_option(o, "f", "vcd", options);
3952 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3953 parse_option(o, "r", frame_rates[norm], options);
3954 opt_default("g", norm == PAL ? "15" : "18");
3956 opt_default("b", "1150000");
3957 opt_default("maxrate", "1150000");
3958 opt_default("minrate", "1150000");
3959 opt_default("bufsize", "327680"); // 40*1024*8;
3961 opt_default("b:a", "224000");
3962 parse_option(o, "ar", "44100", options);
3963 parse_option(o, "ac", "2", options);
3965 opt_default("packetsize", "2324");
3966 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3968 /* We have to offset the PTS, so that it is consistent with the SCR.
3969 SCR starts at 36000, but the first two packs contain only padding
3970 and the first pack from the other stream, respectively, may also have
3971 been written before.
3972 So the real data starts at SCR 36000+3*1200. */
3973 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3974 } else if(!strcmp(arg, "svcd")) {
3976 opt_video_codec(o, "c:v", "mpeg2video");
3977 opt_audio_codec(o, "c:a", "mp2");
3978 parse_option(o, "f", "svcd", options);
3980 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3981 parse_option(o, "r", frame_rates[norm], options);
3982 opt_default("g", norm == PAL ? "15" : "18");
3984 opt_default("b", "2040000");
3985 opt_default("maxrate", "2516000");
3986 opt_default("minrate", "0"); //1145000;
3987 opt_default("bufsize", "1835008"); //224*1024*8;
3988 opt_default("flags", "+scan_offset");
3991 opt_default("b:a", "224000");
3992 parse_option(o, "ar", "44100", options);
3994 opt_default("packetsize", "2324");
3996 } else if(!strcmp(arg, "dvd")) {
3998 opt_video_codec(o, "c:v", "mpeg2video");
3999 opt_audio_codec(o, "c:a", "ac3");
4000 parse_option(o, "f", "dvd", options);
4002 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4003 parse_option(o, "r", frame_rates[norm], options);
4004 opt_default("g", norm == PAL ? "15" : "18");
4006 opt_default("b", "6000000");
4007 opt_default("maxrate", "9000000");
4008 opt_default("minrate", "0"); //1500000;
4009 opt_default("bufsize", "1835008"); //224*1024*8;
4011 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4012 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4014 opt_default("b:a", "448000");
4015 parse_option(o, "ar", "48000", options);
4017 } else if(!strncmp(arg, "dv", 2)) {
4019 parse_option(o, "f", "dv", options);
4021 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4022 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4023 norm == PAL ? "yuv420p" : "yuv411p", options);
4024 parse_option(o, "r", frame_rates[norm], options);
4026 parse_option(o, "ar", "48000", options);
4027 parse_option(o, "ac", "2", options);
4030 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4031 return AVERROR(EINVAL);
4036 static int opt_vstats_file(const char *opt, const char *arg)
4038 av_free (vstats_filename);
4039 vstats_filename=av_strdup (arg);
4043 static int opt_vstats(const char *opt, const char *arg)
4046 time_t today2 = time(NULL);
4047 struct tm *today = localtime(&today2);
4049 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4051 return opt_vstats_file(opt, filename);
4054 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4056 return parse_option(o, "frames:v", arg, options);
4059 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4061 return parse_option(o, "frames:a", arg, options);
4064 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4066 return parse_option(o, "frames:d", arg, options);
4069 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4073 static int opt_passlogfile(const char *opt, const char *arg)
4075 pass_logfilename_prefix = arg;
4076 #if CONFIG_LIBX264_ENCODER
4077 return opt_default("passlogfile", arg);
4083 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4085 return parse_option(o, "tag:v", arg, options);
4088 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4090 return parse_option(o, "tag:a", arg, options);
4093 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4095 return parse_option(o, "tag:s", arg, options);
4098 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4100 return parse_option(o, "filter:v", arg, options);
4103 #define OFFSET(x) offsetof(OptionsContext, x)
4104 static const OptionDef options[] = {
4106 #include "cmdutils_common_opts.h"
4107 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4108 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4109 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4110 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4111 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4112 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4113 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4114 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4115 "outfile[,metadata]:infile[,metadata]" },
4116 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4117 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4118 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4119 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4120 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4121 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4122 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4123 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4124 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4125 "add timings for benchmarking" },
4126 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4127 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4128 "dump each input packet" },
4129 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4130 "when dumping packets, also dump the payload" },
4131 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4132 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4133 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4134 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4135 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4136 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4137 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4138 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4139 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4140 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4141 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4142 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4143 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4144 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4145 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4147 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4149 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4152 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4153 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4154 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4155 { "aspect", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_aspect_ratios)}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4156 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4157 { "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" },
4158 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4159 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4160 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4161 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4162 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4163 "use same quantizer as source (implies VBR)" },
4164 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4165 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4166 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4167 "deinterlace pictures" },
4168 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4169 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4171 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4173 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4174 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4175 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4176 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4177 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4178 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4179 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4180 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4181 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(forced_key_frames)}, "force key frames at specified timestamps", "timestamps" },
4184 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4185 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4186 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4187 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4188 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4189 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4190 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4191 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4192 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4194 /* subtitle options */
4195 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4196 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4197 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4200 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4203 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4204 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4206 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4208 /* data codec support */
4209 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4211 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4215 int main(int argc, char **argv)
4217 OptionsContext o = { 0 };
4222 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4223 parse_loglevel(argc, argv, options);
4225 if(argc>1 && !strcmp(argv[1], "-d")){
4227 av_log_set_callback(log_callback_null);
4232 avcodec_register_all();
4234 avdevice_register_all();
4237 avfilter_register_all();
4242 if(isatty(STDIN_FILENO))
4243 avio_set_interrupt_cb(decode_interrupt_cb);
4249 parse_options(&o, argc, argv, options, opt_output_file);
4251 if(nb_output_files <= 0 && nb_input_files == 0) {
4253 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4257 /* file converter / grab */
4258 if (nb_output_files <= 0) {
4259 fprintf(stderr, "At least one output file must be specified\n");
4263 if (nb_input_files == 0) {
4264 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4269 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4271 ti = getutime() - ti;
4273 int maxrss = getmaxrss() / 1024;
4274 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);