3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
48 #include "libswresample/swresample.h"
50 #include "libavformat/ffm.h" // not public API
53 # include "libavfilter/avcodec.h"
54 # include "libavfilter/avfilter.h"
55 # include "libavfilter/avfiltergraph.h"
56 # include "libavfilter/buffersink.h"
57 # include "libavfilter/vsrc_buffer.h"
60 #if HAVE_SYS_RESOURCE_H
61 #include <sys/types.h>
63 #include <sys/resource.h>
64 #elif HAVE_GETPROCESSTIMES
67 #if HAVE_GETPROCESSMEMORYINFO
73 #include <sys/select.h>
78 #include <sys/ioctl.h>
88 #include "libavutil/avassert.h"
90 const char program_name[] = "ffmpeg";
91 const int program_birth_year = 2000;
93 /* select an input stream for an output stream */
94 typedef struct StreamMap {
95 int disabled; /** 1 is this mapping is disabled by a negative map */
99 int sync_stream_index;
103 int file_idx, stream_idx, channel_idx; // input
104 int ofile_idx, ostream_idx; // output
108 * select an input file for an output file
110 typedef struct MetadataMap {
111 int file; ///< file index
112 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
113 int index; ///< stream/chapter/program number
116 static const OptionDef options[];
118 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
120 static int frame_bits_per_raw_sample = 0;
121 static int video_discard = 0;
122 static int same_quant = 0;
123 static int do_deinterlace = 0;
124 static int intra_dc_precision = 8;
125 static int loop_input = 0;
126 static int loop_output = AVFMT_NOOUTPUTLOOP;
127 static int qp_hist = 0;
128 static int intra_only = 0;
129 static const char *video_codec_name = NULL;
130 static const char *audio_codec_name = NULL;
131 static const char *subtitle_codec_name = NULL;
133 static int file_overwrite = 0;
134 static int no_file_overwrite = 0;
135 static int do_benchmark = 0;
136 static int do_hex_dump = 0;
137 static int do_pkt_dump = 0;
138 static int do_psnr = 0;
139 static int do_pass = 0;
140 static const char *pass_logfilename_prefix;
141 static int video_sync_method= -1;
142 static int audio_sync_method= 0;
143 static float audio_drift_threshold= 0.1;
144 static int copy_ts= 0;
145 static int copy_tb= 0;
146 static int opt_shortest = 0;
147 static char *vstats_filename;
148 static FILE *vstats_file;
150 static int audio_volume = 256;
152 static int exit_on_error = 0;
153 static int using_stdin = 0;
154 static int run_as_daemon = 0;
155 static volatile int received_nb_signals = 0;
156 static int64_t video_size = 0;
157 static int64_t audio_size = 0;
158 static int64_t extra_size = 0;
159 static int nb_frames_dup = 0;
160 static int nb_frames_drop = 0;
161 static int input_sync;
163 static float dts_delta_threshold = 10;
165 static int print_stats = 1;
167 static uint8_t *audio_buf;
168 static uint8_t *audio_out;
169 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
171 static void *samples;
172 static uint8_t *input_tmp= NULL;
174 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
176 typedef struct InputStream {
179 int discard; /* true if stream data should be discarded */
180 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
183 int64_t start; /* time when read started */
184 int64_t next_pts; /* synthetic pts for cases where pkt.pts
186 int64_t pts; /* current pts */
188 int is_start; /* is 1 at the start and after a discontinuity */
189 int showed_multi_packet_warning;
193 typedef struct InputFile {
194 AVFormatContext *ctx;
195 int eof_reached; /* true if eof reached */
196 int ist_index; /* index of first stream in input_streams */
197 int buffer_size; /* current total buffer size */
199 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
200 from ctx.nb_streams if new streams appear during av_read_frame() */
204 typedef struct OutputStream {
205 int file_index; /* file index */
206 int index; /* stream index in the output file */
207 int source_index; /* InputStream index */
208 AVStream *st; /* stream in the output file */
209 int encoding_needed; /* true if encoding needed for this stream */
211 /* input pts and corresponding output pts
213 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
214 struct InputStream *sync_ist; /* input stream to sync against */
215 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
216 AVBitStreamFilterContext *bitstream_filters;
222 AVFrame resample_frame; /* temporary frame for image resampling */
223 struct SwsContext *img_resample_ctx; /* for image resampling */
226 int resample_pix_fmt;
227 AVRational frame_rate;
231 float frame_aspect_ratio;
233 /* forced key frames */
234 int64_t *forced_kf_pts;
240 int audio_channels_map[SWR_CH_MAX]; ///< list of the channels id to pick from the source stream
241 int audio_channels_mapped; ///< number of channels in audio_channels_map
242 int resample_sample_fmt;
243 int resample_channels;
244 int resample_sample_rate;
245 float rematrix_volume;
246 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
249 struct SwrContext *swr;
252 AVFilterContext *output_video_filter;
253 AVFilterContext *input_video_filter;
254 AVFilterBufferRef *picref;
256 AVFilterGraph *graph;
261 int is_past_recording_time;
263 const char *attachment_filename;
264 int copy_initial_nonkeyframes;
270 /* init terminal so that we can grab keys */
271 static struct termios oldtty;
274 typedef struct OutputFile {
275 AVFormatContext *ctx;
277 int ost_index; /* index of the first stream in output_streams */
278 int64_t recording_time; /* desired length of the resulting file in microseconds */
279 int64_t start_time; /* start time in microseconds */
280 uint64_t limit_filesize;
283 static InputStream *input_streams = NULL;
284 static int nb_input_streams = 0;
285 static InputFile *input_files = NULL;
286 static int nb_input_files = 0;
288 static OutputStream *output_streams = NULL;
289 static int nb_output_streams = 0;
290 static OutputFile *output_files = NULL;
291 static int nb_output_files = 0;
293 typedef struct OptionsContext {
294 /* input/output options */
298 SpecifierOpt *codec_names;
300 SpecifierOpt *audio_channels;
301 int nb_audio_channels;
302 SpecifierOpt *audio_sample_rate;
303 int nb_audio_sample_rate;
304 SpecifierOpt *rematrix_volume;
305 int nb_rematrix_volume;
306 SpecifierOpt *frame_rates;
308 SpecifierOpt *frame_sizes;
310 SpecifierOpt *frame_pix_fmts;
311 int nb_frame_pix_fmts;
314 int64_t input_ts_offset;
317 SpecifierOpt *ts_scale;
319 SpecifierOpt *dump_attachment;
320 int nb_dump_attachment;
323 StreamMap *stream_maps;
325 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
326 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
327 /* first item specifies output metadata, second is input */
328 MetadataMap (*meta_data_maps)[2];
329 int nb_meta_data_maps;
330 int metadata_global_manual;
331 int metadata_streams_manual;
332 int metadata_chapters_manual;
333 const char **attachments;
336 int chapters_input_file;
338 int64_t recording_time;
339 uint64_t limit_filesize;
345 int subtitle_disable;
348 /* indexed by output file stream index */
352 SpecifierOpt *metadata;
354 SpecifierOpt *max_frames;
356 SpecifierOpt *bitstream_filters;
357 int nb_bitstream_filters;
358 SpecifierOpt *codec_tags;
360 SpecifierOpt *sample_fmts;
362 SpecifierOpt *qscale;
364 SpecifierOpt *forced_key_frames;
365 int nb_forced_key_frames;
366 SpecifierOpt *force_fps;
368 SpecifierOpt *frame_aspect_ratios;
369 int nb_frame_aspect_ratios;
370 SpecifierOpt *rc_overrides;
372 SpecifierOpt *intra_matrices;
373 int nb_intra_matrices;
374 SpecifierOpt *inter_matrices;
375 int nb_inter_matrices;
376 SpecifierOpt *top_field_first;
377 int nb_top_field_first;
378 SpecifierOpt *presets;
380 SpecifierOpt *copy_initial_nonkeyframes;
381 int nb_copy_initial_nonkeyframes;
383 SpecifierOpt *filters;
388 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
391 for (i = 0; i < o->nb_ ## name; i++) {\
392 char *spec = o->name[i].specifier;\
393 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
394 outvar = o->name[i].u.type;\
400 static void reset_options(OptionsContext *o, int is_input)
402 const OptionDef *po = options;
403 OptionsContext bak= *o;
405 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
407 void *dst = (uint8_t*)o + po->u.off;
409 if (po->flags & OPT_SPEC) {
410 SpecifierOpt **so = dst;
411 int i, *count = (int*)(so + 1);
412 for (i = 0; i < *count; i++) {
413 av_freep(&(*so)[i].specifier);
414 if (po->flags & OPT_STRING)
415 av_freep(&(*so)[i].u.str);
419 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
424 av_freep(&o->stream_maps);
425 av_freep(&o->audio_channel_maps);
426 av_freep(&o->meta_data_maps);
427 av_freep(&o->streamid_map);
429 memset(o, 0, sizeof(*o));
431 if(is_input) o->recording_time = bak.recording_time;
432 else o->recording_time = INT64_MAX;
433 o->mux_max_delay = 0.7;
434 o->limit_filesize = UINT64_MAX;
435 o->chapters_input_file = INT_MAX;
443 static int configure_video_filters(InputStream *ist, OutputStream *ost)
445 AVFilterContext *last_filter, *filter;
446 /** filter graph containing all filters including input & output */
447 AVCodecContext *codec = ost->st->codec;
448 AVCodecContext *icodec = ist->st->codec;
449 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
450 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
451 AVRational sample_aspect_ratio;
455 ost->graph = avfilter_graph_alloc();
457 if (ist->st->sample_aspect_ratio.num){
458 sample_aspect_ratio = ist->st->sample_aspect_ratio;
460 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
462 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
463 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
464 sample_aspect_ratio.num, sample_aspect_ratio.den);
466 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
467 "src", args, NULL, ost->graph);
470 #if FF_API_OLD_VSINK_API
471 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
472 "out", NULL, pix_fmts, ost->graph);
474 buffersink_params->pixel_fmts = pix_fmts;
475 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
476 "out", NULL, buffersink_params, ost->graph);
478 av_freep(&buffersink_params);
481 last_filter = ost->input_video_filter;
483 if (codec->width != icodec->width || codec->height != icodec->height) {
484 snprintf(args, 255, "%d:%d:flags=0x%X",
487 (unsigned)ost->sws_flags);
488 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
489 NULL, args, NULL, ost->graph)) < 0)
491 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
493 last_filter = filter;
496 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
497 ost->graph->scale_sws_opts = av_strdup(args);
500 AVFilterInOut *outputs = avfilter_inout_alloc();
501 AVFilterInOut *inputs = avfilter_inout_alloc();
503 outputs->name = av_strdup("in");
504 outputs->filter_ctx = last_filter;
505 outputs->pad_idx = 0;
506 outputs->next = NULL;
508 inputs->name = av_strdup("out");
509 inputs->filter_ctx = ost->output_video_filter;
513 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
515 av_freep(&ost->avfilter);
517 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
521 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
524 codec->width = ost->output_video_filter->inputs[0]->w;
525 codec->height = ost->output_video_filter->inputs[0]->h;
526 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
527 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
528 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
529 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
533 #endif /* CONFIG_AVFILTER */
535 static void term_exit(void)
537 av_log(NULL, AV_LOG_QUIET, "%s", "");
540 tcsetattr (0, TCSANOW, &oldtty);
544 static volatile int received_sigterm = 0;
546 static void sigterm_handler(int sig)
548 received_sigterm = sig;
549 received_nb_signals++;
553 static void term_init(void)
563 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
564 |INLCR|IGNCR|ICRNL|IXON);
565 tty.c_oflag |= OPOST;
566 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
567 tty.c_cflag &= ~(CSIZE|PARENB);
572 tcsetattr (0, TCSANOW, &tty);
573 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
576 avformat_network_deinit();
578 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
579 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
581 signal(SIGXCPU, sigterm_handler);
585 /* read a key without blocking */
586 static int read_key(void)
598 n = select(1, &rfds, NULL, NULL, &tv);
607 # if HAVE_PEEKNAMEDPIPE
609 static HANDLE input_handle;
612 input_handle = GetStdHandle(STD_INPUT_HANDLE);
613 is_pipe = !GetConsoleMode(input_handle, &dw);
616 if (stdin->_cnt > 0) {
621 /* When running under a GUI, you will end here. */
622 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
639 static int decode_interrupt_cb(void *ctx)
641 return received_nb_signals > 1;
644 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
646 void av_noreturn exit_program(int ret)
651 for(i=0;i<nb_output_files;i++) {
652 AVFormatContext *s = output_files[i].ctx;
653 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
655 avformat_free_context(s);
656 av_dict_free(&output_files[i].opts);
658 for(i=0;i<nb_input_files;i++) {
659 av_close_input_file(input_files[i].ctx);
661 for (i = 0; i < nb_input_streams; i++)
662 av_dict_free(&input_streams[i].opts);
666 av_free(vstats_filename);
668 av_freep(&input_streams);
669 av_freep(&input_files);
670 av_freep(&output_streams);
671 av_freep(&output_files);
676 allocated_audio_buf_size= allocated_audio_out_size= 0;
682 avformat_network_deinit();
684 av_freep(&input_tmp);
686 if (received_sigterm) {
687 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
688 (int) received_sigterm);
692 exit(ret); /* not all OS-es handle main() return value */
695 static void assert_avoptions(AVDictionary *m)
697 AVDictionaryEntry *t;
698 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
699 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
704 static void assert_codec_experimental(AVCodecContext *c, int encoder)
706 const char *codec_string = encoder ? "encoder" : "decoder";
708 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
709 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
710 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
711 "results.\nAdd '-strict experimental' if you want to use it.\n",
712 codec_string, c->codec->name);
713 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
714 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
715 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
716 codec_string, codec->name);
721 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
723 if(codec && codec->sample_fmts){
724 const enum AVSampleFormat *p= codec->sample_fmts;
726 if(*p == st->codec->sample_fmt)
730 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
731 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
732 if(av_get_sample_fmt_name(st->codec->sample_fmt))
733 av_log(NULL, AV_LOG_WARNING,
734 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
735 av_get_sample_fmt_name(st->codec->sample_fmt),
737 av_get_sample_fmt_name(codec->sample_fmts[0]));
738 st->codec->sample_fmt = codec->sample_fmts[0];
743 static void choose_sample_rate(AVStream *st, AVCodec *codec)
745 if(codec && codec->supported_samplerates){
746 const int *p= codec->supported_samplerates;
748 int best_dist=INT_MAX;
750 int dist= abs(st->codec->sample_rate - *p);
751 if(dist < best_dist){
757 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
759 st->codec->sample_rate= best;
763 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
765 if(codec && codec->pix_fmts){
766 const enum PixelFormat *p= codec->pix_fmts;
767 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
768 if(st->codec->codec_id==CODEC_ID_MJPEG){
769 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
770 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
771 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};
774 for (; *p != PIX_FMT_NONE; p++) {
775 if(*p == st->codec->pix_fmt)
778 if (*p == PIX_FMT_NONE) {
779 if(st->codec->pix_fmt != PIX_FMT_NONE)
780 av_log(NULL, AV_LOG_WARNING,
781 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
782 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
784 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
785 st->codec->pix_fmt = codec->pix_fmts[0];
790 static double get_sync_ipts(const OutputStream *ost)
792 const InputStream *ist = ost->sync_ist;
793 OutputFile *of = &output_files[ost->file_index];
794 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
797 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
802 AVPacket new_pkt= *pkt;
803 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
804 &new_pkt.data, &new_pkt.size,
805 pkt->data, pkt->size,
806 pkt->flags & AV_PKT_FLAG_KEY);
809 new_pkt.destruct= av_destruct_packet;
811 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
812 bsfc->filter->name, pkt->stream_index,
813 avctx->codec ? avctx->codec->name : "copy");
823 ret= av_interleaved_write_frame(s, pkt);
825 print_error("av_interleaved_write_frame()", ret);
830 static void do_audio_out(AVFormatContext *s,
833 unsigned char *buf, int size)
836 int64_t audio_out_size, audio_buf_size;
837 int64_t allocated_for_size= size;
839 int size_out, frame_bytes, ret, resample_changed;
840 AVCodecContext *enc= ost->st->codec;
841 AVCodecContext *dec= ist->st->codec;
842 int osize = av_get_bytes_per_sample(enc->sample_fmt);
843 int isize = av_get_bytes_per_sample(dec->sample_fmt);
844 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
847 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
848 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
849 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
850 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
851 audio_buf_size*= osize*enc->channels;
853 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
854 if(coded_bps > 8*osize)
855 audio_out_size= audio_out_size * coded_bps / (8*osize);
856 audio_out_size += FF_MIN_BUFFER_SIZE;
858 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
859 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
863 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
864 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
865 if (!audio_buf || !audio_out){
866 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
870 if (enc->channels != dec->channels
871 || enc->sample_fmt != dec->sample_fmt)
872 ost->audio_resample = 1;
874 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
875 ost->resample_channels != dec->channels ||
876 ost->resample_sample_rate != dec->sample_rate;
878 if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
879 if (resample_changed) {
880 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",
881 ist->file_index, ist->st->index,
882 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
883 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
884 ost->resample_sample_fmt = dec->sample_fmt;
885 ost->resample_channels = dec->channels;
886 ost->resample_sample_rate = dec->sample_rate;
889 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
890 if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
891 ost->resample_sample_fmt == enc->sample_fmt &&
892 ost->resample_channels == enc->channels &&
893 ost->resample_sample_rate == enc->sample_rate) {
895 ost->audio_resample = 0;
897 ost->swr = swr_alloc_set_opts(ost->swr,
898 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
899 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
901 if (ost->audio_channels_mapped)
902 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
903 av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
904 if (ost->audio_channels_mapped) {
905 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
906 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
908 av_opt_set_int(ost->swr, "ich", dec->channels, 0);
909 av_opt_set_int(ost->swr, "och", enc->channels, 0);
910 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
911 if(ost->swr && swr_init(ost->swr) < 0){
912 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
917 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
918 dec->channels, dec->sample_rate,
919 enc->channels, enc->sample_rate);
925 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
927 if(audio_sync_method){
928 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
929 - av_fifo_size(ost->fifo)/(enc->channels * 2);
930 double idelta= delta*dec->sample_rate / enc->sample_rate;
931 int byte_delta= ((int)idelta)*2*dec->channels;
933 //FIXME resample delay
934 if(fabs(delta) > 50){
935 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
937 byte_delta= FFMAX(byte_delta, -size);
940 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
945 input_tmp= av_realloc(input_tmp, byte_delta + size);
947 if(byte_delta > allocated_for_size - size){
948 allocated_for_size= byte_delta + (int64_t)size;
953 memset(input_tmp, 0, byte_delta);
954 memcpy(input_tmp + byte_delta, buf, size);
957 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
959 }else if(audio_sync_method>1){
960 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
961 av_assert0(ost->audio_resample);
962 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
963 delta, comp, enc->sample_rate);
964 // 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));
965 swr_compensate(ost->swr, comp, enc->sample_rate);
969 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
970 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
972 if (ost->audio_resample) {
974 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
975 (const uint8_t*[]){buf }, size / (dec->channels * isize));
976 size_out = size_out * enc->channels * osize;
982 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
984 /* now encode as many frames as possible */
985 if (enc->frame_size > 1) {
986 /* output resampled raw samples */
987 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
988 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
991 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
993 frame_bytes = enc->frame_size * osize * enc->channels;
995 while (av_fifo_size(ost->fifo) >= frame_bytes) {
997 av_init_packet(&pkt);
999 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1001 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1003 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1004 (short *)audio_buf);
1006 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1010 pkt.stream_index= ost->index;
1011 pkt.data= audio_out;
1013 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1014 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1015 pkt.flags |= AV_PKT_FLAG_KEY;
1016 write_frame(s, &pkt, enc, ost->bitstream_filters);
1018 ost->sync_opts += enc->frame_size;
1022 av_init_packet(&pkt);
1024 ost->sync_opts += size_out / (osize * enc->channels);
1026 /* output a pcm frame */
1027 /* determine the size of the coded buffer */
1030 size_out = size_out*coded_bps/8;
1032 if(size_out > audio_out_size){
1033 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1037 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1038 ret = avcodec_encode_audio(enc, audio_out, size_out,
1041 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1045 pkt.stream_index= ost->index;
1046 pkt.data= audio_out;
1048 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1049 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1050 pkt.flags |= AV_PKT_FLAG_KEY;
1051 write_frame(s, &pkt, enc, ost->bitstream_filters);
1055 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1057 AVCodecContext *dec;
1058 AVPicture *picture2;
1059 AVPicture picture_tmp;
1062 dec = ist->st->codec;
1064 /* deinterlace : must be done before any resize */
1065 if (do_deinterlace) {
1068 /* create temporary picture */
1069 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1070 buf = av_malloc(size);
1074 picture2 = &picture_tmp;
1075 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1077 if(avpicture_deinterlace(picture2, picture,
1078 dec->pix_fmt, dec->width, dec->height) < 0) {
1079 /* if error, do not deinterlace */
1080 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1089 if (picture != picture2)
1090 *picture = *picture2;
1094 static void do_subtitle_out(AVFormatContext *s,
1100 static uint8_t *subtitle_out = NULL;
1101 int subtitle_out_max_size = 1024 * 1024;
1102 int subtitle_out_size, nb, i;
1103 AVCodecContext *enc;
1106 if (pts == AV_NOPTS_VALUE) {
1107 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1113 enc = ost->st->codec;
1115 if (!subtitle_out) {
1116 subtitle_out = av_malloc(subtitle_out_max_size);
1119 /* Note: DVB subtitle need one packet to draw them and one other
1120 packet to clear them */
1121 /* XXX: signal it in the codec context ? */
1122 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1127 for(i = 0; i < nb; i++) {
1128 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1129 // start_display_time is required to be 0
1130 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1131 sub->end_display_time -= sub->start_display_time;
1132 sub->start_display_time = 0;
1133 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1134 subtitle_out_max_size, sub);
1135 if (subtitle_out_size < 0) {
1136 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1140 av_init_packet(&pkt);
1141 pkt.stream_index = ost->index;
1142 pkt.data = subtitle_out;
1143 pkt.size = subtitle_out_size;
1144 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1145 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1146 /* XXX: the pts correction is handled here. Maybe handling
1147 it in the codec would be better */
1149 pkt.pts += 90 * sub->start_display_time;
1151 pkt.pts += 90 * sub->end_display_time;
1153 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1157 static int bit_buffer_size= 1024*256;
1158 static uint8_t *bit_buffer= NULL;
1160 static void do_video_resample(OutputStream *ost,
1162 AVFrame *in_picture,
1163 AVFrame **out_picture)
1166 *out_picture = in_picture;
1168 AVCodecContext *dec = ist->st->codec;
1169 AVCodecContext *enc = ost->st->codec;
1170 int resample_changed = ost->resample_width != dec->width ||
1171 ost->resample_height != dec->height ||
1172 ost->resample_pix_fmt != dec->pix_fmt;
1174 *out_picture = in_picture;
1175 if (resample_changed) {
1176 av_log(NULL, AV_LOG_INFO,
1177 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1178 ist->file_index, ist->st->index,
1179 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1180 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1181 ost->resample_width = dec->width;
1182 ost->resample_height = dec->height;
1183 ost->resample_pix_fmt = dec->pix_fmt;
1186 ost->video_resample = dec->width != enc->width ||
1187 dec->height != enc->height ||
1188 dec->pix_fmt != enc->pix_fmt;
1190 if (ost->video_resample) {
1191 *out_picture = &ost->resample_frame;
1192 if (!ost->img_resample_ctx || resample_changed) {
1193 /* initialize the destination picture */
1194 if (!ost->resample_frame.data[0]) {
1195 avcodec_get_frame_defaults(&ost->resample_frame);
1196 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1197 enc->width, enc->height)) {
1198 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1202 /* initialize a new scaler context */
1203 sws_freeContext(ost->img_resample_ctx);
1204 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1205 enc->width, enc->height, enc->pix_fmt,
1206 ost->sws_flags, NULL, NULL, NULL);
1207 if (ost->img_resample_ctx == NULL) {
1208 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1212 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1213 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1219 static void do_video_out(AVFormatContext *s,
1222 AVFrame *in_picture,
1223 int *frame_size, float quality)
1225 int nb_frames, i, ret, format_video_sync;
1226 AVFrame *final_picture;
1227 AVCodecContext *enc;
1229 double duration = 0;
1231 enc = ost->st->codec;
1233 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1234 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1235 if(ist->st->avg_frame_rate.num)
1236 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1238 duration /= av_q2d(enc->time_base);
1241 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1243 /* by default, we output a single frame */
1248 format_video_sync = video_sync_method;
1249 if (format_video_sync < 0)
1250 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? 0 : 2) : 1;
1252 if (format_video_sync) {
1253 double vdelta = sync_ipts - ost->sync_opts + duration;
1254 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1257 else if (format_video_sync == 2) {
1260 }else if(vdelta>0.6)
1261 ost->sync_opts= lrintf(sync_ipts);
1262 }else if (vdelta > 1.1)
1263 nb_frames = lrintf(vdelta);
1264 //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);
1265 if (nb_frames == 0){
1267 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1268 }else if (nb_frames > 1) {
1269 nb_frames_dup += nb_frames - 1;
1270 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1273 ost->sync_opts= lrintf(sync_ipts);
1275 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1279 do_video_resample(ost, ist, in_picture, &final_picture);
1281 /* duplicates frame if needed */
1282 for(i=0;i<nb_frames;i++) {
1284 av_init_packet(&pkt);
1285 pkt.stream_index= ost->index;
1287 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1288 /* raw pictures are written as AVPicture structure to
1289 avoid any copies. We support temporarily the older
1291 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1292 enc->coded_frame->top_field_first = in_picture->top_field_first;
1293 pkt.data= (uint8_t *)final_picture;
1294 pkt.size= sizeof(AVPicture);
1295 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1296 pkt.flags |= AV_PKT_FLAG_KEY;
1298 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1300 AVFrame big_picture;
1302 big_picture= *final_picture;
1303 /* better than nothing: use input picture interlaced
1305 big_picture.interlaced_frame = in_picture->interlaced_frame;
1306 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1307 if (ost->top_field_first == -1)
1308 big_picture.top_field_first = in_picture->top_field_first;
1310 big_picture.top_field_first = !!ost->top_field_first;
1313 /* handles same_quant here. This is not correct because it may
1314 not be a global option */
1315 big_picture.quality = quality;
1316 if (!enc->me_threshold)
1317 big_picture.pict_type = 0;
1318 // big_picture.pts = AV_NOPTS_VALUE;
1319 big_picture.pts= ost->sync_opts;
1320 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1321 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1322 if (ost->forced_kf_index < ost->forced_kf_count &&
1323 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1324 big_picture.pict_type = AV_PICTURE_TYPE_I;
1325 ost->forced_kf_index++;
1327 ret = avcodec_encode_video(enc,
1328 bit_buffer, bit_buffer_size,
1331 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1336 pkt.data= bit_buffer;
1338 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1339 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1340 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1341 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1342 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1344 if(enc->coded_frame->key_frame)
1345 pkt.flags |= AV_PKT_FLAG_KEY;
1346 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1349 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1350 // enc->frame_number-1, ret, enc->pict_type);
1351 /* if two pass, output log */
1352 if (ost->logfile && enc->stats_out) {
1353 fprintf(ost->logfile, "%s", enc->stats_out);
1358 ost->frame_number++;
1362 static double psnr(double d)
1364 return -10.0*log(d)/log(10.0);
1367 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1370 AVCodecContext *enc;
1372 double ti1, bitrate, avg_bitrate;
1374 /* this is executed just the first time do_video_stats is called */
1376 vstats_file = fopen(vstats_filename, "w");
1383 enc = ost->st->codec;
1384 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1385 frame_number = ost->frame_number;
1386 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1387 if (enc->flags&CODEC_FLAG_PSNR)
1388 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1390 fprintf(vstats_file,"f_size= %6d ", frame_size);
1391 /* compute pts value */
1392 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1396 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1397 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1398 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1399 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1400 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1404 static void print_report(OutputFile *output_files,
1405 OutputStream *ost_table, int nb_ostreams,
1406 int is_last_report, int64_t timer_start, int64_t cur_time)
1410 AVFormatContext *oc;
1412 AVCodecContext *enc;
1413 int frame_number, vid, i;
1415 int64_t pts = INT64_MAX;
1416 static int64_t last_time = -1;
1417 static int qp_histogram[52];
1418 int hours, mins, secs, us;
1420 if (!print_stats && !is_last_report)
1423 if (!is_last_report) {
1424 if (last_time == -1) {
1425 last_time = cur_time;
1428 if ((cur_time - last_time) < 500000)
1430 last_time = cur_time;
1434 oc = output_files[0].ctx;
1436 total_size = avio_size(oc->pb);
1437 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1438 total_size= avio_tell(oc->pb);
1442 for(i=0;i<nb_ostreams;i++) {
1444 ost = &ost_table[i];
1445 enc = ost->st->codec;
1446 if (!ost->stream_copy && enc->coded_frame)
1447 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1448 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1449 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1451 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1452 float t = (cur_time-timer_start) / 1000000.0;
1454 frame_number = ost->frame_number;
1455 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1456 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1458 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1462 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1465 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1467 if (enc->flags&CODEC_FLAG_PSNR){
1469 double error, error_sum=0;
1470 double scale, scale_sum=0;
1471 char type[3]= {'Y','U','V'};
1472 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1475 error= enc->error[j];
1476 scale= enc->width*enc->height*255.0*255.0*frame_number;
1478 error= enc->coded_frame->error[j];
1479 scale= enc->width*enc->height*255.0*255.0;
1484 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1486 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1490 /* compute min output value */
1491 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1492 ost->st->time_base, AV_TIME_BASE_Q));
1495 secs = pts / AV_TIME_BASE;
1496 us = pts % AV_TIME_BASE;
1502 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1504 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1505 "size=%8.0fkB time=", total_size / 1024.0);
1506 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1507 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1508 (100 * us) / AV_TIME_BASE);
1509 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1510 "bitrate=%6.1fkbits/s", bitrate);
1512 if (nb_frames_dup || nb_frames_drop)
1513 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1514 nb_frames_dup, nb_frames_drop);
1516 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1520 if (is_last_report) {
1521 int64_t raw= audio_size + video_size + extra_size;
1522 av_log(NULL, AV_LOG_INFO, "\n");
1523 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1527 100.0*(total_size - raw)/raw
1529 if(video_size + audio_size + extra_size == 0){
1530 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1535 static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
1537 int fill_char = 0x00;
1538 if (sample_fmt == AV_SAMPLE_FMT_U8)
1540 memset(buf, fill_char, size);
1543 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1547 for (i = 0; i < nb_ostreams; i++) {
1548 OutputStream *ost = &ost_table[i];
1549 AVCodecContext *enc = ost->st->codec;
1550 AVFormatContext *os = output_files[ost->file_index].ctx;
1552 if (!ost->encoding_needed)
1555 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1557 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1563 av_init_packet(&pkt);
1564 pkt.stream_index= ost->index;
1566 switch (ost->st->codec->codec_type) {
1567 case AVMEDIA_TYPE_AUDIO:
1568 fifo_bytes = av_fifo_size(ost->fifo);
1570 /* encode any samples remaining in fifo */
1571 if (fifo_bytes > 0) {
1572 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1573 int fs_tmp = enc->frame_size;
1575 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1576 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1577 enc->frame_size = fifo_bytes / (osize * enc->channels);
1579 int frame_bytes = enc->frame_size*osize*enc->channels;
1580 if (allocated_audio_buf_size < frame_bytes)
1582 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1585 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1586 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1587 ost->st->time_base.num, enc->sample_rate);
1588 enc->frame_size = fs_tmp;
1591 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1594 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1598 pkt.flags |= AV_PKT_FLAG_KEY;
1600 case AVMEDIA_TYPE_VIDEO:
1601 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1603 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1607 if(enc->coded_frame && enc->coded_frame->key_frame)
1608 pkt.flags |= AV_PKT_FLAG_KEY;
1609 if (ost->logfile && enc->stats_out) {
1610 fprintf(ost->logfile, "%s", enc->stats_out);
1619 pkt.data = bit_buffer;
1621 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1622 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1623 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1629 * Check whether a packet from ist should be written into ost at this time
1631 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1633 OutputFile *of = &output_files[ost->file_index];
1634 int ist_index = ist - input_streams;
1636 if (ost->source_index != ist_index)
1639 if (of->start_time && ist->pts < of->start_time)
1642 if (of->recording_time != INT64_MAX &&
1643 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1644 (AVRational){1, 1000000}) >= 0) {
1645 ost->is_past_recording_time = 1;
1652 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1654 OutputFile *of = &output_files[ost->file_index];
1655 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1659 av_init_packet(&opkt);
1661 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1662 !ost->copy_initial_nonkeyframes)
1665 /* force the input stream PTS */
1666 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1667 audio_size += pkt->size;
1668 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1669 video_size += pkt->size;
1673 opkt.stream_index = ost->index;
1674 if (pkt->pts != AV_NOPTS_VALUE)
1675 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1677 opkt.pts = AV_NOPTS_VALUE;
1679 if (pkt->dts == AV_NOPTS_VALUE)
1680 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1682 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1683 opkt.dts -= ost_tb_start_time;
1685 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1686 opkt.flags = pkt->flags;
1688 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1689 if( ost->st->codec->codec_id != CODEC_ID_H264
1690 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1691 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1693 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1694 opkt.destruct = av_destruct_packet;
1696 opkt.data = pkt->data;
1697 opkt.size = pkt->size;
1699 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1700 /* store AVPicture in AVPacket, as expected by the output format */
1701 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1702 opkt.data = (uint8_t *)&pict;
1703 opkt.size = sizeof(AVPicture);
1704 opkt.flags |= AV_PKT_FLAG_KEY;
1707 write_frame(of->ctx, &opkt, ost->st->codec, ost->bitstream_filters);
1708 ost->st->codec->frame_number++;
1709 ost->frame_number++;
1710 av_free_packet(&opkt);
1713 static void rate_emu_sleep(InputStream *ist)
1715 if (input_files[ist->file_index].rate_emu) {
1716 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1717 int64_t now = av_gettime() - ist->start;
1723 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1725 static unsigned int samples_size = 0;
1726 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1727 uint8_t *decoded_data_buf = NULL;
1728 int decoded_data_size = 0;
1731 if (pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1733 samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1734 samples = av_malloc(samples_size);
1736 decoded_data_size = samples_size;
1738 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1742 *got_output = decoded_data_size > 0;
1744 /* Some bug in mpeg audio decoder gives */
1745 /* decoded_data_size < 0, it seems they are overflows */
1747 /* no audio frame */
1751 decoded_data_buf = (uint8_t *)samples;
1752 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1753 (ist->st->codec->sample_rate * ist->st->codec->channels);
1755 // preprocess audio (volume)
1756 if (audio_volume != 256) {
1757 switch (ist->st->codec->sample_fmt) {
1758 case AV_SAMPLE_FMT_U8:
1760 uint8_t *volp = samples;
1761 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1762 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1763 *volp++ = av_clip_uint8(v);
1767 case AV_SAMPLE_FMT_S16:
1769 int16_t *volp = samples;
1770 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1771 int v = ((*volp) * audio_volume + 128) >> 8;
1772 *volp++ = av_clip_int16(v);
1776 case AV_SAMPLE_FMT_S32:
1778 int32_t *volp = samples;
1779 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1780 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1781 *volp++ = av_clipl_int32(v);
1785 case AV_SAMPLE_FMT_FLT:
1787 float *volp = samples;
1788 float scale = audio_volume / 256.f;
1789 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1794 case AV_SAMPLE_FMT_DBL:
1796 double *volp = samples;
1797 double scale = audio_volume / 256.;
1798 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1804 av_log(NULL, AV_LOG_FATAL,
1805 "Audio volume adjustment on sample format %s is not supported.\n",
1806 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1811 rate_emu_sleep(ist);
1813 for (i = 0; i < nb_output_streams; i++) {
1814 OutputStream *ost = &output_streams[i];
1816 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1818 do_audio_out(output_files[ost->file_index].ctx, ost, ist,
1819 decoded_data_buf, decoded_data_size);
1824 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
1826 AVFrame *decoded_frame, *filtered_frame = NULL;
1827 void *buffer_to_free = NULL;
1831 int frame_available = 1;
1834 if (!(decoded_frame = avcodec_alloc_frame()))
1835 return AVERROR(ENOMEM);
1836 pkt->pts = *pkt_pts;
1837 pkt->dts = *pkt_dts;
1838 *pkt_pts = AV_NOPTS_VALUE;
1840 if(*pkt_dts != AV_NOPTS_VALUE && ist->st->codec->time_base.num != 0) {
1841 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1842 *pkt_dts += ((int64_t)AV_TIME_BASE *
1843 ist->st->codec->time_base.num * ticks) /
1844 ist->st->codec->time_base.den;
1846 *pkt_dts = AV_NOPTS_VALUE;
1848 ret = avcodec_decode_video2(ist->st->codec,
1849 decoded_frame, got_output, pkt);
1853 quality = same_quant ? decoded_frame->quality : 0;
1855 /* no picture yet */
1856 av_freep(&decoded_frame);
1860 if(decoded_frame->best_effort_timestamp != AV_NOPTS_VALUE)
1861 ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
1863 if (ist->st->codec->time_base.num != 0) {
1864 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1865 ist->st->codec->ticks_per_frame;
1866 ist->next_pts += ((int64_t)AV_TIME_BASE *
1867 ist->st->codec->time_base.num * ticks) /
1868 ist->st->codec->time_base.den;
1872 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1875 for(i=0;i<nb_output_streams;i++) {
1876 OutputStream *ost = ost = &output_streams[i];
1877 if(check_output_constraints(ist, ost)){
1878 if (!decoded_frame->sample_aspect_ratio.num)
1879 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1880 decoded_frame->pts = ist->pts;
1882 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
1887 rate_emu_sleep(ist);
1889 for (i = 0; i < nb_output_streams; i++) {
1890 OutputStream *ost = &output_streams[i];
1893 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1897 if (ost->input_video_filter) {
1898 frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1900 while (frame_available) {
1901 if (ost->output_video_filter) {
1902 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1903 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1905 if (!filtered_frame && !(filtered_frame = avcodec_alloc_frame())) {
1906 ret = AVERROR(ENOMEM);
1909 *filtered_frame= *decoded_frame; //for me_threshold
1911 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
1912 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1915 if (ost->picref->video && !ost->frame_aspect_ratio)
1916 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1918 filtered_frame = decoded_frame;
1921 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
1922 same_quant ? quality : ost->st->codec->global_quality);
1923 if (vstats_filename && frame_size)
1924 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
1927 frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1928 avfilter_unref_buffer(ost->picref);
1930 av_freep(&filtered_frame);
1935 av_free(buffer_to_free);
1936 av_freep(&decoded_frame);
1940 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1942 AVSubtitle subtitle;
1943 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1944 &subtitle, got_output, pkt);
1950 rate_emu_sleep(ist);
1952 for (i = 0; i < nb_output_streams; i++) {
1953 OutputStream *ost = &output_streams[i];
1955 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1958 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
1961 avsubtitle_free(&subtitle);
1965 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1966 static int output_packet(InputStream *ist,
1967 OutputStream *ost_table, int nb_ostreams,
1968 const AVPacket *pkt)
1972 int64_t pkt_dts = AV_NOPTS_VALUE;
1973 int64_t pkt_pts = AV_NOPTS_VALUE;
1977 if (ist->next_pts == AV_NOPTS_VALUE)
1978 ist->next_pts = ist->pts;
1982 av_init_packet(&avpkt);
1990 if(pkt->dts != AV_NOPTS_VALUE){
1991 if(ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
1992 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1993 pkt_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1995 if(pkt->pts != AV_NOPTS_VALUE)
1996 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1998 //while we have more to decode or while the decoder did output something on EOF
1999 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2002 ist->pts = ist->next_pts;
2004 if (avpkt.size && avpkt.size != pkt->size) {
2005 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2006 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2007 ist->showed_multi_packet_warning = 1;
2010 switch(ist->st->codec->codec_type) {
2011 case AVMEDIA_TYPE_AUDIO:
2012 ret = transcode_audio (ist, &avpkt, &got_output);
2014 case AVMEDIA_TYPE_VIDEO:
2015 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
2017 case AVMEDIA_TYPE_SUBTITLE:
2018 ret = transcode_subtitles(ist, &avpkt, &got_output);
2026 // touch data and size only if not EOF
2028 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2038 /* handle stream copy */
2039 if (!ist->decoding_needed) {
2040 rate_emu_sleep(ist);
2041 switch (ist->st->codec->codec_type) {
2042 case AVMEDIA_TYPE_AUDIO:
2043 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2044 ist->st->codec->sample_rate;
2046 case AVMEDIA_TYPE_VIDEO:
2047 if (ist->st->codec->time_base.num != 0) {
2048 int ticks = ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2049 ist->next_pts += ((int64_t)AV_TIME_BASE *
2050 ist->st->codec->time_base.num * ticks) /
2051 ist->st->codec->time_base.den;
2056 for (i = 0; pkt && i < nb_ostreams; i++) {
2057 OutputStream *ost = &ost_table[i];
2059 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2062 do_streamcopy(ist, ost, pkt);
2068 static void print_sdp(OutputFile *output_files, int n)
2072 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
2076 for (i = 0; i < n; i++)
2077 avc[i] = output_files[i].ctx;
2079 av_sdp_create(avc, n, sdp, sizeof(sdp));
2080 printf("SDP:\n%s\n", sdp);
2085 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2086 char *error, int error_len)
2088 InputStream *ist = &input_streams[ist_index];
2089 if (ist->decoding_needed) {
2090 AVCodec *codec = ist->dec;
2092 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2093 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2094 return AVERROR(EINVAL);
2096 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2097 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2098 ist->file_index, ist->st->index);
2099 return AVERROR(EINVAL);
2101 assert_codec_experimental(ist->st->codec, 0);
2102 assert_avoptions(ist->opts);
2105 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;
2106 ist->next_pts = AV_NOPTS_VALUE;
2112 static int transcode_init(OutputFile *output_files, int nb_output_files,
2113 InputFile *input_files, int nb_input_files)
2115 int ret = 0, i, j, k;
2116 AVFormatContext *oc;
2117 AVCodecContext *codec, *icodec;
2123 /* init framerate emulation */
2124 for (i = 0; i < nb_input_files; i++) {
2125 InputFile *ifile = &input_files[i];
2126 if (ifile->rate_emu)
2127 for (j = 0; j < ifile->nb_streams; j++)
2128 input_streams[j + ifile->ist_index].start = av_gettime();
2131 /* output stream init */
2132 for (i = 0; i < nb_output_files; i++) {
2133 oc = output_files[i].ctx;
2134 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2135 av_dump_format(oc, i, oc->filename, 1);
2136 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2137 return AVERROR(EINVAL);
2141 /* for each output stream, we compute the right encoding parameters */
2142 for (i = 0; i < nb_output_streams; i++) {
2143 ost = &output_streams[i];
2144 oc = output_files[ost->file_index].ctx;
2145 ist = &input_streams[ost->source_index];
2147 if (ost->attachment_filename)
2150 codec = ost->st->codec;
2151 icodec = ist->st->codec;
2153 ost->st->disposition = ist->st->disposition;
2154 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2155 codec->chroma_sample_location = icodec->chroma_sample_location;
2157 if (ost->stream_copy) {
2158 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2160 if (extra_size > INT_MAX) {
2161 return AVERROR(EINVAL);
2164 /* if stream_copy is selected, no need to decode or encode */
2165 codec->codec_id = icodec->codec_id;
2166 codec->codec_type = icodec->codec_type;
2168 if (!codec->codec_tag) {
2169 if (!oc->oformat->codec_tag ||
2170 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2171 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2172 codec->codec_tag = icodec->codec_tag;
2175 codec->bit_rate = icodec->bit_rate;
2176 codec->rc_max_rate = icodec->rc_max_rate;
2177 codec->rc_buffer_size = icodec->rc_buffer_size;
2178 codec->extradata = av_mallocz(extra_size);
2179 if (!codec->extradata) {
2180 return AVERROR(ENOMEM);
2182 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2183 codec->extradata_size= icodec->extradata_size;
2185 codec->time_base = ist->st->time_base;
2186 if(!strcmp(oc->oformat->name, "avi")) {
2188 av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) &&
2189 av_q2d(ist->st->time_base) < 1.0/500){
2190 codec->time_base = icodec->time_base;
2191 codec->time_base.num *= icodec->ticks_per_frame;
2192 codec->time_base.den *= 2;
2194 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)) {
2195 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){
2196 codec->time_base = icodec->time_base;
2197 codec->time_base.num *= icodec->ticks_per_frame;
2200 av_reduce(&codec->time_base.num, &codec->time_base.den,
2201 codec->time_base.num, codec->time_base.den, INT_MAX);
2203 switch(codec->codec_type) {
2204 case AVMEDIA_TYPE_AUDIO:
2205 if(audio_volume != 256) {
2206 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2209 codec->channel_layout = icodec->channel_layout;
2210 codec->sample_rate = icodec->sample_rate;
2211 codec->channels = icodec->channels;
2212 codec->frame_size = icodec->frame_size;
2213 codec->audio_service_type = icodec->audio_service_type;
2214 codec->block_align = icodec->block_align;
2216 case AVMEDIA_TYPE_VIDEO:
2217 codec->pix_fmt = icodec->pix_fmt;
2218 codec->width = icodec->width;
2219 codec->height = icodec->height;
2220 codec->has_b_frames = icodec->has_b_frames;
2221 if (!codec->sample_aspect_ratio.num) {
2222 codec->sample_aspect_ratio =
2223 ost->st->sample_aspect_ratio =
2224 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2225 ist->st->codec->sample_aspect_ratio.num ?
2226 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2228 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2230 case AVMEDIA_TYPE_SUBTITLE:
2231 codec->width = icodec->width;
2232 codec->height = icodec->height;
2234 case AVMEDIA_TYPE_DATA:
2235 case AVMEDIA_TYPE_ATTACHMENT:
2242 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2244 ist->decoding_needed = 1;
2245 ost->encoding_needed = 1;
2247 switch(codec->codec_type) {
2248 case AVMEDIA_TYPE_AUDIO:
2249 ost->fifo = av_fifo_alloc(1024);
2251 return AVERROR(ENOMEM);
2253 if (!codec->sample_rate)
2254 codec->sample_rate = icodec->sample_rate;
2255 choose_sample_rate(ost->st, ost->enc);
2256 codec->time_base = (AVRational){1, codec->sample_rate};
2258 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2259 codec->sample_fmt = icodec->sample_fmt;
2260 choose_sample_fmt(ost->st, ost->enc);
2262 if (ost->audio_channels_mapped) {
2263 /* the requested output channel is set to the number of
2264 * -map_channel only if no -ac are specified */
2265 if (!codec->channels) {
2266 codec->channels = ost->audio_channels_mapped;
2267 codec->channel_layout = av_get_default_channel_layout(codec->channels);
2268 if (!codec->channel_layout) {
2269 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2273 /* fill unused channel mapping with -1 (which means a muted
2274 * channel in case the number of output channels is bigger
2275 * than the number of mapped channel) */
2276 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2277 ost->audio_channels_map[j] = -1;
2278 } else if (!codec->channels) {
2279 codec->channels = icodec->channels;
2280 codec->channel_layout = icodec->channel_layout;
2282 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2283 codec->channel_layout = 0;
2285 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2286 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2287 || codec->channel_layout != icodec->channel_layout;
2288 icodec->request_channels = codec->channels;
2289 ost->resample_sample_fmt = icodec->sample_fmt;
2290 ost->resample_sample_rate = icodec->sample_rate;
2291 ost->resample_channels = icodec->channels;
2293 case AVMEDIA_TYPE_VIDEO:
2294 if (codec->pix_fmt == PIX_FMT_NONE)
2295 codec->pix_fmt = icodec->pix_fmt;
2296 choose_pixel_fmt(ost->st, ost->enc);
2298 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2299 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2303 if (!codec->width || !codec->height) {
2304 codec->width = icodec->width;
2305 codec->height = icodec->height;
2308 ost->video_resample = codec->width != icodec->width ||
2309 codec->height != icodec->height ||
2310 codec->pix_fmt != icodec->pix_fmt;
2311 if (ost->video_resample) {
2312 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2315 ost->resample_height = icodec->height;
2316 ost->resample_width = icodec->width;
2317 ost->resample_pix_fmt = icodec->pix_fmt;
2319 if (!ost->frame_rate.num)
2320 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2321 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2322 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2323 ost->frame_rate = ost->enc->supported_framerates[idx];
2325 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2326 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2327 && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2328 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2329 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2331 for (j = 0; j < ost->forced_kf_count; j++)
2332 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2337 if (configure_video_filters(ist, ost)) {
2338 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2343 case AVMEDIA_TYPE_SUBTITLE:
2350 if (codec->codec_id != CODEC_ID_H264 &&
2351 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2352 char logfilename[1024];
2355 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2356 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2358 if (codec->flags & CODEC_FLAG_PASS2) {
2360 size_t logbuffer_size;
2361 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2362 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2366 codec->stats_in = logbuffer;
2368 if (codec->flags & CODEC_FLAG_PASS1) {
2369 f = fopen(logfilename, "wb");
2371 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2372 logfilename, strerror(errno));
2379 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2380 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2381 int size = codec->width * codec->height;
2382 bit_buffer_size = FFMAX(bit_buffer_size, 7*size + 10000);
2387 bit_buffer = av_malloc(bit_buffer_size);
2389 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2391 return AVERROR(ENOMEM);
2394 /* open each encoder */
2395 for (i = 0; i < nb_output_streams; i++) {
2396 ost = &output_streams[i];
2397 if (ost->encoding_needed) {
2398 AVCodec *codec = ost->enc;
2399 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2401 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2402 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2403 ret = AVERROR(EINVAL);
2406 if (dec->subtitle_header) {
2407 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2408 if (!ost->st->codec->subtitle_header) {
2409 ret = AVERROR(ENOMEM);
2412 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2413 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2415 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2416 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2417 ost->file_index, ost->index);
2418 ret = AVERROR(EINVAL);
2421 assert_codec_experimental(ost->st->codec, 1);
2422 assert_avoptions(ost->opts);
2423 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2424 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2425 " It takes bits/s as argument, not kbits/s\n");
2426 extra_size += ost->st->codec->extradata_size;
2428 if (ost->st->codec->me_threshold)
2429 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2433 /* init input streams */
2434 for (i = 0; i < nb_input_streams; i++)
2435 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2438 /* discard unused programs */
2439 for (i = 0; i < nb_input_files; i++) {
2440 InputFile *ifile = &input_files[i];
2441 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2442 AVProgram *p = ifile->ctx->programs[j];
2443 int discard = AVDISCARD_ALL;
2445 for (k = 0; k < p->nb_stream_indexes; k++)
2446 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2447 discard = AVDISCARD_DEFAULT;
2450 p->discard = discard;
2454 /* open files and write file headers */
2455 for (i = 0; i < nb_output_files; i++) {
2456 oc = output_files[i].ctx;
2457 oc->interrupt_callback = int_cb;
2458 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2459 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2460 ret = AVERROR(EINVAL);
2463 // assert_avoptions(output_files[i].opts);
2464 if (strcmp(oc->oformat->name, "rtp")) {
2470 /* dump the file output parameters - cannot be done before in case
2472 for (i = 0; i < nb_output_files; i++) {
2473 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2476 /* dump the stream mapping */
2477 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2478 for (i = 0; i < nb_output_streams; i++) {
2479 ost = &output_streams[i];
2481 if (ost->attachment_filename) {
2482 /* an attached file */
2483 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2484 ost->attachment_filename, ost->file_index, ost->index);
2487 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2488 input_streams[ost->source_index].file_index,
2489 input_streams[ost->source_index].st->index,
2492 if (ost->audio_channels_mapped) {
2493 av_log(NULL, AV_LOG_INFO, " [ch:");
2494 for (j = 0; j < ost->audio_channels_mapped; j++)
2495 if (ost->audio_channels_map[j] == -1)
2496 av_log(NULL, AV_LOG_INFO, " M");
2498 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2499 av_log(NULL, AV_LOG_INFO, "]");
2501 if (ost->sync_ist != &input_streams[ost->source_index])
2502 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2503 ost->sync_ist->file_index,
2504 ost->sync_ist->st->index);
2505 if (ost->stream_copy)
2506 av_log(NULL, AV_LOG_INFO, " (copy)");
2508 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2509 input_streams[ost->source_index].dec->name : "?",
2510 ost->enc ? ost->enc->name : "?");
2511 av_log(NULL, AV_LOG_INFO, "\n");
2515 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2520 print_sdp(output_files, nb_output_files);
2527 * The following code is the main loop of the file converter
2529 static int transcode(OutputFile *output_files, int nb_output_files,
2530 InputFile *input_files, int nb_input_files)
2533 AVFormatContext *is, *os;
2537 int no_packet_count=0;
2538 int64_t timer_start;
2541 if (!(no_packet = av_mallocz(nb_input_files)))
2544 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2549 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2552 timer_start = av_gettime();
2554 for(; received_sigterm == 0;) {
2555 int file_index, ist_index;
2559 int64_t cur_time= av_gettime();
2561 ipts_min= INT64_MAX;
2563 /* if 'q' pressed, exits */
2565 static int64_t last_time;
2566 if (received_nb_signals)
2568 /* read_key() returns 0 on EOF */
2569 if(cur_time - last_time >= 100000 && !run_as_daemon){
2571 last_time = cur_time;
2576 if (key == '+') av_log_set_level(av_log_get_level()+10);
2577 if (key == '-') av_log_set_level(av_log_get_level()-10);
2578 if (key == 's') qp_hist ^= 1;
2581 do_hex_dump = do_pkt_dump = 0;
2582 } else if(do_pkt_dump){
2586 av_log_set_level(AV_LOG_DEBUG);
2589 if (key == 'c' || key == 'C'){
2590 char buf[4096], target[64], command[256], arg[256] = {0};
2593 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2595 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2600 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2601 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2602 target, time, command, arg);
2603 for (i = 0; i < nb_output_streams; i++) {
2604 ost = &output_streams[i];
2607 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2608 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2609 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2611 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2616 av_log(NULL, AV_LOG_ERROR,
2617 "Parse error, at least 3 arguments were expected, "
2618 "only %d given in string '%s'\n", n, buf);
2622 if (key == 'd' || key == 'D'){
2625 debug = input_streams[0].st->codec->debug<<1;
2626 if(!debug) debug = 1;
2627 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2630 if(scanf("%d", &debug)!=1)
2631 fprintf(stderr,"error parsing debug value\n");
2632 for(i=0;i<nb_input_streams;i++) {
2633 input_streams[i].st->codec->debug = debug;
2635 for(i=0;i<nb_output_streams;i++) {
2636 ost = &output_streams[i];
2637 ost->st->codec->debug = debug;
2639 if(debug) av_log_set_level(AV_LOG_DEBUG);
2640 fprintf(stderr,"debug=%d\n", debug);
2643 fprintf(stderr, "key function\n"
2644 "? show this help\n"
2645 "+ increase verbosity\n"
2646 "- decrease verbosity\n"
2647 "c Send command to filtergraph\n"
2648 "D cycle through available debug modes\n"
2649 "h dump packets/hex press to cycle through the 3 states\n"
2651 "s Show QP histogram\n"
2656 /* select the stream that we must read now by looking at the
2657 smallest output pts */
2659 for (i = 0; i < nb_output_streams; i++) {
2663 ost = &output_streams[i];
2664 of = &output_files[ost->file_index];
2665 os = output_files[ost->file_index].ctx;
2666 ist = &input_streams[ost->source_index];
2667 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2668 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2670 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2672 if (!input_files[ist->file_index].eof_reached){
2673 if(ipts < ipts_min) {
2675 if(input_sync ) file_index = ist->file_index;
2677 if(opts < opts_min) {
2679 if(!input_sync) file_index = ist->file_index;
2682 if (ost->frame_number >= ost->max_frames) {
2684 for (j = 0; j < of->ctx->nb_streams; j++)
2685 output_streams[of->ost_index + j].is_past_recording_time = 1;
2689 /* if none, if is finished */
2690 if (file_index < 0) {
2691 if(no_packet_count){
2693 memset(no_packet, 0, nb_input_files);
2700 /* read a frame from it and output it in the fifo */
2701 is = input_files[file_index].ctx;
2702 ret= av_read_frame(is, &pkt);
2703 if(ret == AVERROR(EAGAIN)){
2704 no_packet[file_index]=1;
2709 input_files[file_index].eof_reached = 1;
2717 memset(no_packet, 0, nb_input_files);
2720 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2721 is->streams[pkt.stream_index]);
2723 /* the following test is needed in case new streams appear
2724 dynamically in stream : we ignore them */
2725 if (pkt.stream_index >= input_files[file_index].nb_streams)
2726 goto discard_packet;
2727 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2728 ist = &input_streams[ist_index];
2730 goto discard_packet;
2732 if (pkt.dts != AV_NOPTS_VALUE)
2733 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2734 if (pkt.pts != AV_NOPTS_VALUE)
2735 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2737 if(pkt.pts != AV_NOPTS_VALUE)
2738 pkt.pts *= ist->ts_scale;
2739 if(pkt.dts != AV_NOPTS_VALUE)
2740 pkt.dts *= ist->ts_scale;
2742 // 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);
2743 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2744 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2745 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2746 int64_t delta= pkt_dts - ist->next_pts;
2747 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2748 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2749 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2750 pkt_dts+1<ist->pts)&& !copy_ts){
2751 input_files[ist->file_index].ts_offset -= delta;
2752 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2753 delta, input_files[ist->file_index].ts_offset);
2754 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2755 if(pkt.pts != AV_NOPTS_VALUE)
2756 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2760 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2761 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2763 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2764 ist->file_index, ist->st->index);
2767 av_free_packet(&pkt);
2772 av_free_packet(&pkt);
2774 /* dump report by using the output first video and audio streams */
2775 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
2778 /* at the end of stream, we must flush the decoder buffers */
2779 for (i = 0; i < nb_input_streams; i++) {
2780 ist = &input_streams[i];
2781 if (ist->decoding_needed) {
2782 output_packet(ist, output_streams, nb_output_streams, NULL);
2785 flush_encoders(output_streams, nb_output_streams);
2789 /* write the trailer if needed and close file */
2790 for(i=0;i<nb_output_files;i++) {
2791 os = output_files[i].ctx;
2792 av_write_trailer(os);
2795 /* dump report by using the first video and audio streams */
2796 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
2798 /* close each encoder */
2799 for (i = 0; i < nb_output_streams; i++) {
2800 ost = &output_streams[i];
2801 if (ost->encoding_needed) {
2802 av_freep(&ost->st->codec->stats_in);
2803 avcodec_close(ost->st->codec);
2806 avfilter_graph_free(&ost->graph);
2810 /* close each decoder */
2811 for (i = 0; i < nb_input_streams; i++) {
2812 ist = &input_streams[i];
2813 if (ist->decoding_needed) {
2814 avcodec_close(ist->st->codec);
2822 av_freep(&bit_buffer);
2823 av_freep(&no_packet);
2825 if (output_streams) {
2826 for (i = 0; i < nb_output_streams; i++) {
2827 ost = &output_streams[i];
2829 if (ost->stream_copy)
2830 av_freep(&ost->st->codec->extradata);
2832 fclose(ost->logfile);
2833 ost->logfile = NULL;
2835 av_fifo_free(ost->fifo); /* works even if fifo is not
2836 initialized but set to zero */
2837 av_freep(&ost->st->codec->subtitle_header);
2838 av_free(ost->resample_frame.data[0]);
2839 av_free(ost->forced_kf_pts);
2840 if (ost->video_resample)
2841 sws_freeContext(ost->img_resample_ctx);
2842 swr_free(&ost->swr);
2843 av_dict_free(&ost->opts);
2850 static int opt_frame_crop(const char *opt, const char *arg)
2852 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2853 return AVERROR(EINVAL);
2856 static int opt_pad(const char *opt, const char *arg)
2858 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2862 static double parse_frame_aspect_ratio(const char *arg)
2869 p = strchr(arg, ':');
2871 x = strtol(arg, &end, 10);
2873 y = strtol(end+1, &end, 10);
2875 ar = (double)x / (double)y;
2877 ar = strtod(arg, NULL);
2880 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2886 static int opt_video_channel(const char *opt, const char *arg)
2888 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2889 return opt_default("channel", arg);
2892 static int opt_video_standard(const char *opt, const char *arg)
2894 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2895 return opt_default("standard", arg);
2898 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2900 audio_codec_name = arg;
2901 return parse_option(o, "codec:a", arg, options);
2904 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2906 video_codec_name = arg;
2907 return parse_option(o, "codec:v", arg, options);
2910 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2912 subtitle_codec_name = arg;
2913 return parse_option(o, "codec:s", arg, options);
2916 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2918 return parse_option(o, "codec:d", arg, options);
2921 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2923 StreamMap *m = NULL;
2924 int i, negative = 0, file_idx;
2925 int sync_file_idx = -1, sync_stream_idx;
2933 map = av_strdup(arg);
2935 /* parse sync stream first, just pick first matching stream */
2936 if (sync = strchr(map, ',')) {
2938 sync_file_idx = strtol(sync + 1, &sync, 0);
2939 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2940 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2945 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2946 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2947 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2948 sync_stream_idx = i;
2951 if (i == input_files[sync_file_idx].nb_streams) {
2952 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2953 "match any streams.\n", arg);
2959 file_idx = strtol(map, &p, 0);
2960 if (file_idx >= nb_input_files || file_idx < 0) {
2961 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2965 /* disable some already defined maps */
2966 for (i = 0; i < o->nb_stream_maps; i++) {
2967 m = &o->stream_maps[i];
2968 if (file_idx == m->file_index &&
2969 check_stream_specifier(input_files[m->file_index].ctx,
2970 input_files[m->file_index].ctx->streams[m->stream_index],
2971 *p == ':' ? p + 1 : p) > 0)
2975 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2976 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2977 *p == ':' ? p + 1 : p) <= 0)
2979 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2980 &o->nb_stream_maps, o->nb_stream_maps + 1);
2981 m = &o->stream_maps[o->nb_stream_maps - 1];
2983 m->file_index = file_idx;
2984 m->stream_index = i;
2986 if (sync_file_idx >= 0) {
2987 m->sync_file_index = sync_file_idx;
2988 m->sync_stream_index = sync_stream_idx;
2990 m->sync_file_index = file_idx;
2991 m->sync_stream_index = i;
2996 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3004 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3006 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3007 &o->nb_attachments, o->nb_attachments + 1);
3008 o->attachments[o->nb_attachments - 1] = arg;
3012 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3018 o->audio_channel_maps =
3019 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3020 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3021 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3023 /* muted channel syntax */
3024 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3025 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3026 m->file_idx = m->stream_idx = -1;
3028 m->ofile_idx = m->ostream_idx = -1;
3033 n = sscanf(arg, "%d.%d.%d:%d.%d",
3034 &m->file_idx, &m->stream_idx, &m->channel_idx,
3035 &m->ofile_idx, &m->ostream_idx);
3037 if (n != 3 && n != 5) {
3038 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3039 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3043 if (n != 5) // only file.stream.channel specified
3044 m->ofile_idx = m->ostream_idx = -1;
3047 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3048 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3052 if (m->stream_idx < 0 ||
3053 m->stream_idx >= input_files[m->file_idx].nb_streams) {
3054 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3055 m->file_idx, m->stream_idx);
3058 st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3059 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3060 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3061 m->file_idx, m->stream_idx);
3064 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3065 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3066 m->file_idx, m->stream_idx, m->channel_idx);
3072 static void parse_meta_type(char *arg, char *type, int *index)
3082 if (*(++arg) == ':')
3083 *index = strtol(++arg, NULL, 0);
3086 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3093 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
3095 MetadataMap *m, *m1;
3098 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
3099 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
3101 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
3102 m->file = strtol(arg, &p, 0);
3103 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
3105 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
3106 if (p = strchr(opt, ':'))
3107 parse_meta_type(p + 1, &m1->type, &m1->index);
3111 if (m->type == 'g' || m1->type == 'g')
3112 o->metadata_global_manual = 1;
3113 if (m->type == 's' || m1->type == 's')
3114 o->metadata_streams_manual = 1;
3115 if (m->type == 'c' || m1->type == 'c')
3116 o->metadata_chapters_manual = 1;
3121 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
3123 av_log(NULL, AV_LOG_WARNING, "-map_meta_data is deprecated and will be removed soon. "
3124 "Use -map_metadata instead.\n");
3125 return opt_map_metadata(o, opt, arg);
3128 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3131 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3132 struct tm time = *gmtime((time_t*)&recording_timestamp);
3133 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3134 parse_option(o, "metadata", buf, options);
3136 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3137 "tag instead.\n", opt);
3141 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3143 const char *codec_string = encoder ? "encoder" : "decoder";
3147 avcodec_find_encoder_by_name(name) :
3148 avcodec_find_decoder_by_name(name);
3150 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3153 if(codec->type != type) {
3154 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3160 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3162 char *codec_name = NULL;
3164 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3166 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3167 st->codec->codec_id = codec->id;
3170 return avcodec_find_decoder(st->codec->codec_id);
3174 * Add all the streams from the given input file to the global
3175 * list of input streams.
3177 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3179 int i, rfps, rfps_base;
3180 char *next, *codec_tag = NULL;
3182 for (i = 0; i < ic->nb_streams; i++) {
3183 AVStream *st = ic->streams[i];
3184 AVCodecContext *dec = st->codec;
3187 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3188 ist = &input_streams[nb_input_streams - 1];
3190 ist->file_index = nb_input_files;
3192 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3194 ist->ts_scale = 1.0;
3195 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3197 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3199 uint32_t tag = strtol(codec_tag, &next, 0);
3201 tag = AV_RL32(codec_tag);
3202 st->codec->codec_tag = tag;
3205 ist->dec = choose_decoder(o, ic, st);
3207 switch (dec->codec_type) {
3208 case AVMEDIA_TYPE_AUDIO:
3210 ist->dec = avcodec_find_decoder(dec->codec_id);
3211 if(o->audio_disable)
3212 st->discard= AVDISCARD_ALL;
3214 case AVMEDIA_TYPE_VIDEO:
3216 ist->dec = avcodec_find_decoder(dec->codec_id);
3217 rfps = ic->streams[i]->r_frame_rate.num;
3218 rfps_base = ic->streams[i]->r_frame_rate.den;
3220 dec->flags |= CODEC_FLAG_EMU_EDGE;
3223 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3225 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",
3226 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3227 (float)rfps / rfps_base, rfps, rfps_base);
3230 if (o->video_disable)
3231 st->discard= AVDISCARD_ALL;
3232 else if(video_discard)
3233 st->discard= video_discard;
3235 case AVMEDIA_TYPE_DATA:
3237 case AVMEDIA_TYPE_SUBTITLE:
3239 ist->dec = avcodec_find_decoder(dec->codec_id);
3240 if(o->subtitle_disable)
3241 st->discard = AVDISCARD_ALL;
3243 case AVMEDIA_TYPE_ATTACHMENT:
3244 case AVMEDIA_TYPE_UNKNOWN:
3252 static void assert_file_overwrite(const char *filename)
3254 if ((!file_overwrite || no_file_overwrite) &&
3255 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3256 av_strstart(filename, "file:", NULL))) {
3257 if (avio_check(filename, 0) == 0) {
3258 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3259 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3262 if (!read_yesno()) {
3263 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3269 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3276 static void dump_attachment(AVStream *st, const char *filename)
3279 AVIOContext *out = NULL;
3280 AVDictionaryEntry *e;
3282 if (!st->codec->extradata_size) {
3283 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3284 nb_input_files - 1, st->index);
3287 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3288 filename = e->value;
3290 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3291 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3295 assert_file_overwrite(filename);
3297 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3298 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3303 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3308 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3310 AVFormatContext *ic;
3311 AVInputFormat *file_iformat = NULL;
3315 AVDictionary **opts;
3316 int orig_nb_streams; // number of streams before avformat_find_stream_info
3319 if (!(file_iformat = av_find_input_format(o->format))) {
3320 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3325 if (!strcmp(filename, "-"))
3328 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3329 !strcmp(filename, "/dev/stdin");
3331 /* get default parameters from command line */
3332 ic = avformat_alloc_context();
3334 print_error(filename, AVERROR(ENOMEM));
3337 if (o->nb_audio_sample_rate) {
3338 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3339 av_dict_set(&format_opts, "sample_rate", buf, 0);
3341 if (o->nb_audio_channels) {
3342 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3343 av_dict_set(&format_opts, "channels", buf, 0);
3345 if (o->nb_frame_rates) {
3346 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3348 if (o->nb_frame_sizes) {
3349 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3351 if (o->nb_frame_pix_fmts)
3352 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3354 ic->video_codec_id = video_codec_name ?
3355 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3356 ic->audio_codec_id = audio_codec_name ?
3357 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3358 ic->subtitle_codec_id= subtitle_codec_name ?
3359 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3360 ic->flags |= AVFMT_FLAG_NONBLOCK;
3361 ic->interrupt_callback = int_cb;
3364 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3365 ic->loop_input = loop_input;
3368 /* open the input file with generic libav function */
3369 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3371 print_error(filename, err);
3374 assert_avoptions(format_opts);
3376 /* apply forced codec ids */
3377 for (i = 0; i < ic->nb_streams; i++)
3378 choose_decoder(o, ic, ic->streams[i]);
3380 /* Set AVCodecContext options for avformat_find_stream_info */
3381 opts = setup_find_stream_info_opts(ic, codec_opts);
3382 orig_nb_streams = ic->nb_streams;
3384 /* If not enough info to get the stream parameters, we decode the
3385 first frames to get it. (used in mpeg case for example) */
3386 ret = avformat_find_stream_info(ic, opts);
3388 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3389 av_close_input_file(ic);
3393 timestamp = o->start_time;
3394 /* add the stream start time */
3395 if (ic->start_time != AV_NOPTS_VALUE)
3396 timestamp += ic->start_time;
3398 /* if seeking requested, we execute it */
3399 if (o->start_time != 0) {
3400 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3402 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3403 filename, (double)timestamp / AV_TIME_BASE);
3407 /* update the current parameters so that they match the one of the input stream */
3408 add_input_streams(o, ic);
3410 /* dump the file content */
3411 av_dump_format(ic, nb_input_files, filename, 0);
3413 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3414 input_files[nb_input_files - 1].ctx = ic;
3415 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3416 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3417 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3418 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3420 for (i = 0; i < o->nb_dump_attachment; i++) {
3423 for (j = 0; j < ic->nb_streams; j++) {
3424 AVStream *st = ic->streams[j];
3426 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3427 dump_attachment(st, o->dump_attachment[i].u.str);
3431 for (i = 0; i < orig_nb_streams; i++)
3432 av_dict_free(&opts[i]);
3435 reset_options(o, 1);
3439 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3444 for (p = kf; *p; p++)
3447 ost->forced_kf_count = n;
3448 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3449 if (!ost->forced_kf_pts) {
3450 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3453 for (i = 0; i < n; i++) {
3454 p = i ? strchr(p, ',') + 1 : kf;
3455 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3459 static uint8_t *get_line(AVIOContext *s)
3465 if (avio_open_dyn_buf(&line) < 0) {
3466 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3470 while ((c = avio_r8(s)) && c != '\n')
3473 avio_close_dyn_buf(line, &buf);
3478 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3481 char filename[1000];
3482 const char *base[3] = { getenv("AVCONV_DATADIR"),
3487 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3491 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3492 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3493 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3496 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3497 i != 1 ? "" : "/.avconv", preset_name);
3498 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3504 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3506 char *codec_name = NULL;
3508 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3510 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3511 NULL, ost->st->codec->codec_type);
3512 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3513 } else if (!strcmp(codec_name, "copy"))
3514 ost->stream_copy = 1;
3516 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3517 ost->st->codec->codec_id = ost->enc->id;
3521 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3524 AVStream *st = avformat_new_stream(oc, NULL);
3525 int idx = oc->nb_streams - 1, ret = 0;
3526 char *bsf = NULL, *next, *codec_tag = NULL;
3527 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3529 char *buf = NULL, *arg = NULL, *preset = NULL;
3530 AVIOContext *s = NULL;
3533 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3537 if (oc->nb_streams - 1 < o->nb_streamid_map)
3538 st->id = o->streamid_map[oc->nb_streams - 1];
3540 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3541 nb_output_streams + 1);
3542 ost = &output_streams[nb_output_streams - 1];
3543 ost->file_index = nb_output_files;
3546 st->codec->codec_type = type;
3547 choose_encoder(o, oc, ost);
3549 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3552 avcodec_get_context_defaults3(st->codec, ost->enc);
3553 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3555 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3556 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3559 if (!buf[0] || buf[0] == '#') {
3563 if (!(arg = strchr(buf, '='))) {
3564 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3568 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3570 } while (!s->eof_reached);
3574 av_log(NULL, AV_LOG_FATAL,
3575 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3576 preset, ost->file_index, ost->index);
3580 ost->max_frames = INT64_MAX;
3581 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3583 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3585 if (next = strchr(bsf, ','))
3587 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3588 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3592 bsfc_prev->next = bsfc;
3594 ost->bitstream_filters = bsfc;
3600 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3602 uint32_t tag = strtol(codec_tag, &next, 0);
3604 tag = AV_RL32(codec_tag);
3605 st->codec->codec_tag = tag;
3608 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3609 if (qscale >= 0 || same_quant) {
3610 st->codec->flags |= CODEC_FLAG_QSCALE;
3611 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3614 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3615 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3617 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3621 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3624 const char *p = str;
3631 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3638 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3642 AVCodecContext *video_enc;
3644 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3646 video_enc = st->codec;
3648 if (!ost->stream_copy) {
3649 const char *p = NULL;
3650 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3651 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3652 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3655 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3656 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3657 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3661 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3662 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3663 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3667 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3668 if (frame_aspect_ratio)
3669 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3671 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3672 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3673 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3674 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3677 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3680 video_enc->gop_size = 0;
3681 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3683 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3684 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3687 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3689 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3691 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3692 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3695 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3698 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3701 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3703 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3706 /* FIXME realloc failure */
3707 video_enc->rc_override=
3708 av_realloc(video_enc->rc_override,
3709 sizeof(RcOverride)*(i+1));
3710 video_enc->rc_override[i].start_frame= start;
3711 video_enc->rc_override[i].end_frame = end;
3713 video_enc->rc_override[i].qscale= q;
3714 video_enc->rc_override[i].quality_factor= 1.0;
3717 video_enc->rc_override[i].qscale= 0;
3718 video_enc->rc_override[i].quality_factor= -q/100.0;
3723 video_enc->rc_override_count=i;
3724 if (!video_enc->rc_initial_buffer_occupancy)
3725 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3726 video_enc->intra_dc_precision= intra_dc_precision - 8;
3729 video_enc->flags|= CODEC_FLAG_PSNR;
3734 video_enc->flags |= CODEC_FLAG_PASS1;
3737 video_enc->flags |= CODEC_FLAG_PASS2;
3741 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3742 if (forced_key_frames)
3743 parse_forced_key_frames(forced_key_frames, ost);
3745 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3747 ost->top_field_first = -1;
3748 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3750 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3753 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3755 ost->avfilter = av_strdup(filters);
3762 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3767 AVCodecContext *audio_enc;
3769 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3772 audio_enc = st->codec;
3773 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3775 if (!ost->stream_copy) {
3776 char *sample_fmt = NULL;
3778 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3780 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3782 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3783 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3787 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3789 ost->rematrix_volume=1.0;
3790 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3793 /* check for channel mapping for this audio stream */
3794 for (n = 0; n < o->nb_audio_channel_maps; n++) {
3795 AudioChannelMap *map = &o->audio_channel_maps[n];
3796 InputStream *ist = &input_streams[ost->source_index];
3797 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
3798 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
3799 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
3800 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
3801 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
3803 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
3804 ost->file_index, ost->st->index);
3811 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3815 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3816 if (!ost->stream_copy) {
3817 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3824 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3826 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3827 ost->stream_copy = 1;
3831 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3835 AVCodecContext *subtitle_enc;
3837 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3839 subtitle_enc = st->codec;
3841 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3846 /* arg format is "output-stream-index:streamid-value". */
3847 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3853 av_strlcpy(idx_str, arg, sizeof(idx_str));
3854 p = strchr(idx_str, ':');
3856 av_log(NULL, AV_LOG_FATAL,
3857 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3862 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3863 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3864 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3868 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3870 AVFormatContext *is = ifile->ctx;
3871 AVFormatContext *os = ofile->ctx;
3874 for (i = 0; i < is->nb_chapters; i++) {
3875 AVChapter *in_ch = is->chapters[i], *out_ch;
3876 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3877 AV_TIME_BASE_Q, in_ch->time_base);
3878 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3879 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3882 if (in_ch->end < ts_off)
3884 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3887 out_ch = av_mallocz(sizeof(AVChapter));
3889 return AVERROR(ENOMEM);
3891 out_ch->id = in_ch->id;
3892 out_ch->time_base = in_ch->time_base;
3893 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3894 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3897 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3900 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3902 return AVERROR(ENOMEM);
3903 os->chapters[os->nb_chapters - 1] = out_ch;
3908 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3911 AVFormatContext *ic = avformat_alloc_context();
3913 ic->interrupt_callback = int_cb;
3914 err = avformat_open_input(&ic, filename, NULL, NULL);
3917 /* copy stream format */
3918 for(i=0;i<ic->nb_streams;i++) {
3922 AVCodecContext *avctx;
3924 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3925 ost = new_output_stream(o, s, codec->type);
3929 // FIXME: a more elegant solution is needed
3930 memcpy(st, ic->streams[i], sizeof(AVStream));
3931 st->info = av_malloc(sizeof(*st->info));
3932 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3934 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3936 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3937 choose_sample_fmt(st, codec);
3938 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3939 choose_pixel_fmt(st, codec);
3942 av_close_input_file(ic);
3946 static void opt_output_file(void *optctx, const char *filename)
3948 OptionsContext *o = optctx;
3949 AVFormatContext *oc;
3951 AVOutputFormat *file_oformat;
3955 if (!strcmp(filename, "-"))
3958 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3960 print_error(filename, err);
3963 file_oformat= oc->oformat;
3964 oc->interrupt_callback = int_cb;
3966 if (!strcmp(file_oformat->name, "ffm") &&
3967 av_strstart(filename, "http:", NULL)) {
3969 /* special case for files sent to ffserver: we get the stream
3970 parameters from ffserver */
3971 int err = read_ffserver_streams(o, oc, filename);
3973 print_error(filename, err);
3976 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
3977 ost = &output_streams[j];
3978 for (i = 0; i < nb_input_streams; i++) {
3979 ist = &input_streams[i];
3980 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
3982 ost->source_index= i;
3988 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
3992 } else if (!o->nb_stream_maps) {
3993 /* pick the "best" stream of each type */
3994 #define NEW_STREAM(type, index)\
3996 ost = new_ ## type ## _stream(o, oc);\
3997 ost->source_index = index;\
3998 ost->sync_ist = &input_streams[index];\
3999 input_streams[index].discard = 0;\
4002 /* video: highest resolution */
4003 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4004 int area = 0, idx = -1;
4005 for (i = 0; i < nb_input_streams; i++) {
4006 ist = &input_streams[i];
4007 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4008 ist->st->codec->width * ist->st->codec->height > area) {
4009 area = ist->st->codec->width * ist->st->codec->height;
4013 NEW_STREAM(video, idx);
4016 /* audio: most channels */
4017 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4018 int channels = 0, idx = -1;
4019 for (i = 0; i < nb_input_streams; i++) {
4020 ist = &input_streams[i];
4021 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4022 ist->st->codec->channels > channels) {
4023 channels = ist->st->codec->channels;
4027 NEW_STREAM(audio, idx);
4030 /* subtitles: pick first */
4031 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4032 for (i = 0; i < nb_input_streams; i++)
4033 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4034 NEW_STREAM(subtitle, i);
4038 /* do something with data? */
4040 for (i = 0; i < o->nb_stream_maps; i++) {
4041 StreamMap *map = &o->stream_maps[i];
4046 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4047 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4049 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4051 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4054 switch (ist->st->codec->codec_type) {
4055 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4056 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4057 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4058 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4059 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4061 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4062 map->file_index, map->stream_index);
4066 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4067 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4068 map->sync_stream_index];
4073 /* handle attached files */
4074 for (i = 0; i < o->nb_attachments; i++) {
4076 uint8_t *attachment;
4080 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4081 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4085 if ((len = avio_size(pb)) <= 0) {
4086 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4090 if (!(attachment = av_malloc(len))) {
4091 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4095 avio_read(pb, attachment, len);
4097 ost = new_attachment_stream(o, oc);
4098 ost->stream_copy = 0;
4099 ost->source_index = -1;
4100 ost->attachment_filename = o->attachments[i];
4101 ost->st->codec->extradata = attachment;
4102 ost->st->codec->extradata_size = len;
4104 p = strrchr(o->attachments[i], '/');
4105 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4109 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4110 output_files[nb_output_files - 1].ctx = oc;
4111 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4112 output_files[nb_output_files - 1].recording_time = o->recording_time;
4113 output_files[nb_output_files - 1].start_time = o->start_time;
4114 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4115 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4117 /* check filename in case of an image number is expected */
4118 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4119 if (!av_filename_number_test(oc->filename)) {
4120 print_error(oc->filename, AVERROR(EINVAL));
4125 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4126 /* test if it already exists to avoid loosing precious files */
4127 assert_file_overwrite(filename);
4130 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4131 &oc->interrupt_callback,
4132 &output_files[nb_output_files - 1].opts)) < 0) {
4133 print_error(filename, err);
4138 if (o->mux_preload) {
4140 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4141 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4143 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4145 if (loop_output >= 0) {
4146 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4147 oc->loop_output = loop_output;
4151 if (o->chapters_input_file >= nb_input_files) {
4152 if (o->chapters_input_file == INT_MAX) {
4153 /* copy chapters from the first input file that has them*/
4154 o->chapters_input_file = -1;
4155 for (i = 0; i < nb_input_files; i++)
4156 if (input_files[i].ctx->nb_chapters) {
4157 o->chapters_input_file = i;
4161 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4162 o->chapters_input_file);
4166 if (o->chapters_input_file >= 0)
4167 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4168 !o->metadata_chapters_manual);
4171 for (i = 0; i < o->nb_meta_data_maps; i++) {
4172 AVFormatContext *files[2];
4173 AVDictionary **meta[2];
4176 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4177 if ((index) < 0 || (index) >= (nb_elems)) {\
4178 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
4183 int in_file_index = o->meta_data_maps[i][1].file;
4184 if (in_file_index < 0)
4186 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
4189 files[1] = input_files[in_file_index].ctx;
4191 for (j = 0; j < 2; j++) {
4192 MetadataMap *map = &o->meta_data_maps[i][j];
4194 switch (map->type) {
4196 meta[j] = &files[j]->metadata;
4199 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
4200 meta[j] = &files[j]->streams[map->index]->metadata;
4203 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
4204 meta[j] = &files[j]->chapters[map->index]->metadata;
4207 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
4208 meta[j] = &files[j]->programs[map->index]->metadata;
4215 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
4218 /* copy global metadata by default */
4219 if (!o->metadata_global_manual && nb_input_files){
4220 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4221 AV_DICT_DONT_OVERWRITE);
4222 if(o->recording_time != INT64_MAX)
4223 av_dict_set(&oc->metadata, "duration", NULL, 0);
4225 if (!o->metadata_streams_manual)
4226 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4228 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4230 ist = &input_streams[output_streams[i].source_index];
4231 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4234 /* process manually set metadata */
4235 for (i = 0; i < o->nb_metadata; i++) {
4240 val = strchr(o->metadata[i].u.str, '=');
4242 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4243 o->metadata[i].u.str);
4248 parse_meta_type(o->metadata[i].specifier, &type, &index);
4254 if (index < 0 || index >= oc->nb_streams) {
4255 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
4258 m = &oc->streams[index]->metadata;
4261 if (index < 0 || index >= oc->nb_chapters) {
4262 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4265 m = &oc->chapters[index]->metadata;
4268 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4272 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4275 reset_options(o, 0);
4278 /* same option as mencoder */
4279 static int opt_pass(const char *opt, const char *arg)
4281 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4285 static int64_t getutime(void)
4288 struct rusage rusage;
4290 getrusage(RUSAGE_SELF, &rusage);
4291 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4292 #elif HAVE_GETPROCESSTIMES
4294 FILETIME c, e, k, u;
4295 proc = GetCurrentProcess();
4296 GetProcessTimes(proc, &c, &e, &k, &u);
4297 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4299 return av_gettime();
4303 static int64_t getmaxrss(void)
4305 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4306 struct rusage rusage;
4307 getrusage(RUSAGE_SELF, &rusage);
4308 return (int64_t)rusage.ru_maxrss * 1024;
4309 #elif HAVE_GETPROCESSMEMORYINFO
4311 PROCESS_MEMORY_COUNTERS memcounters;
4312 proc = GetCurrentProcess();
4313 memcounters.cb = sizeof(memcounters);
4314 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4315 return memcounters.PeakPagefileUsage;
4321 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4323 return parse_option(o, "q:a", arg, options);
4326 static void show_usage(void)
4328 printf("Hyper fast Audio and Video encoder\n");
4329 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4333 static int opt_help(const char *opt, const char *arg)
4335 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4336 av_log_set_callback(log_callback_help);
4338 show_help_options(options, "Main options:\n",
4339 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4340 show_help_options(options, "\nAdvanced options:\n",
4341 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4343 show_help_options(options, "\nVideo options:\n",
4344 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4346 show_help_options(options, "\nAdvanced Video options:\n",
4347 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4348 OPT_VIDEO | OPT_EXPERT);
4349 show_help_options(options, "\nAudio options:\n",
4350 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4352 show_help_options(options, "\nAdvanced Audio options:\n",
4353 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4354 OPT_AUDIO | OPT_EXPERT);
4355 show_help_options(options, "\nSubtitle options:\n",
4356 OPT_SUBTITLE | OPT_GRAB,
4358 show_help_options(options, "\nAudio/Video grab options:\n",
4362 show_help_children(avcodec_get_class(), flags);
4363 show_help_children(avformat_get_class(), flags);
4364 show_help_children(sws_get_class(), flags);
4369 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4371 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4372 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4374 if(!strncmp(arg, "pal-", 4)) {
4377 } else if(!strncmp(arg, "ntsc-", 5)) {
4380 } else if(!strncmp(arg, "film-", 5)) {
4384 /* Try to determine PAL/NTSC by peeking in the input files */
4385 if(nb_input_files) {
4387 for (j = 0; j < nb_input_files; j++) {
4388 for (i = 0; i < input_files[j].nb_streams; i++) {
4389 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4390 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4392 fr = c->time_base.den * 1000 / c->time_base.num;
4396 } else if((fr == 29970) || (fr == 23976)) {
4405 if (norm != UNKNOWN)
4406 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4409 if(norm == UNKNOWN) {
4410 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4411 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4412 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4416 if(!strcmp(arg, "vcd")) {
4417 opt_video_codec(o, "c:v", "mpeg1video");
4418 opt_audio_codec(o, "c:a", "mp2");
4419 parse_option(o, "f", "vcd", options);
4421 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4422 parse_option(o, "r", frame_rates[norm], options);
4423 opt_default("g", norm == PAL ? "15" : "18");
4425 opt_default("b", "1150000");
4426 opt_default("maxrate", "1150000");
4427 opt_default("minrate", "1150000");
4428 opt_default("bufsize", "327680"); // 40*1024*8;
4430 opt_default("b:a", "224000");
4431 parse_option(o, "ar", "44100", options);
4432 parse_option(o, "ac", "2", options);
4434 opt_default("packetsize", "2324");
4435 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4437 /* We have to offset the PTS, so that it is consistent with the SCR.
4438 SCR starts at 36000, but the first two packs contain only padding
4439 and the first pack from the other stream, respectively, may also have
4440 been written before.
4441 So the real data starts at SCR 36000+3*1200. */
4442 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4443 } else if(!strcmp(arg, "svcd")) {
4445 opt_video_codec(o, "c:v", "mpeg2video");
4446 opt_audio_codec(o, "c:a", "mp2");
4447 parse_option(o, "f", "svcd", options);
4449 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4450 parse_option(o, "r", frame_rates[norm], options);
4451 parse_option(o, "pix_fmt", "yuv420p", options);
4452 opt_default("g", norm == PAL ? "15" : "18");
4454 opt_default("b", "2040000");
4455 opt_default("maxrate", "2516000");
4456 opt_default("minrate", "0"); //1145000;
4457 opt_default("bufsize", "1835008"); //224*1024*8;
4458 opt_default("flags", "+scan_offset");
4461 opt_default("b:a", "224000");
4462 parse_option(o, "ar", "44100", options);
4464 opt_default("packetsize", "2324");
4466 } else if(!strcmp(arg, "dvd")) {
4468 opt_video_codec(o, "c:v", "mpeg2video");
4469 opt_audio_codec(o, "c:a", "ac3");
4470 parse_option(o, "f", "dvd", options);
4472 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4473 parse_option(o, "r", frame_rates[norm], options);
4474 parse_option(o, "pix_fmt", "yuv420p", options);
4475 opt_default("g", norm == PAL ? "15" : "18");
4477 opt_default("b", "6000000");
4478 opt_default("maxrate", "9000000");
4479 opt_default("minrate", "0"); //1500000;
4480 opt_default("bufsize", "1835008"); //224*1024*8;
4482 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4483 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4485 opt_default("b:a", "448000");
4486 parse_option(o, "ar", "48000", options);
4488 } else if(!strncmp(arg, "dv", 2)) {
4490 parse_option(o, "f", "dv", options);
4492 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4493 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4494 norm == PAL ? "yuv420p" : "yuv411p", options);
4495 parse_option(o, "r", frame_rates[norm], options);
4497 parse_option(o, "ar", "48000", options);
4498 parse_option(o, "ac", "2", options);
4501 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4502 return AVERROR(EINVAL);
4507 static int opt_vstats_file(const char *opt, const char *arg)
4509 av_free (vstats_filename);
4510 vstats_filename=av_strdup (arg);
4514 static int opt_vstats(const char *opt, const char *arg)
4517 time_t today2 = time(NULL);
4518 struct tm *today = localtime(&today2);
4520 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4522 return opt_vstats_file(opt, filename);
4525 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4527 return parse_option(o, "frames:v", arg, options);
4530 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4532 return parse_option(o, "frames:a", arg, options);
4535 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4537 return parse_option(o, "frames:d", arg, options);
4540 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4543 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4544 const char *codec_name = *opt == 'v' ? video_codec_name :
4545 *opt == 'a' ? audio_codec_name :
4546 subtitle_codec_name;
4548 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4549 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4550 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4552 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4557 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4558 if(line[0] == '#' && !e)
4560 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4562 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4565 if(!strcmp(tmp, "acodec")){
4566 opt_audio_codec(o, tmp, tmp2);
4567 }else if(!strcmp(tmp, "vcodec")){
4568 opt_video_codec(o, tmp, tmp2);
4569 }else if(!strcmp(tmp, "scodec")){
4570 opt_subtitle_codec(o, tmp, tmp2);
4571 }else if(!strcmp(tmp, "dcodec")){
4572 opt_data_codec(o, tmp, tmp2);
4573 }else if(opt_default(tmp, tmp2) < 0){
4574 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4584 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4588 static int opt_passlogfile(const char *opt, const char *arg)
4590 pass_logfilename_prefix = arg;
4591 #if CONFIG_LIBX264_ENCODER
4592 return opt_default("passlogfile", arg);
4598 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4600 char *s= av_malloc(strlen(opt)+2);
4601 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4602 return parse_option(o, s, arg, options);
4605 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4607 if(!strcmp(opt, "b")){
4608 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4609 return parse_option(o, av_strdup("b:v"), arg, options);
4611 return opt_default(opt, arg);
4614 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4616 return parse_option(o, "filter:v", arg, options);
4619 #define OFFSET(x) offsetof(OptionsContext, x)
4620 static const OptionDef options[] = {
4622 #include "cmdutils_common_opts.h"
4623 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4624 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4625 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4626 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4627 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4628 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4629 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4630 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4631 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
4632 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4633 "outfile[,metadata]:infile[,metadata]" },
4634 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4635 "outfile[,metadata]:infile[,metadata]" },
4636 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4637 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4638 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4639 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4640 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4641 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4642 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4643 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4644 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4645 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4646 "add timings for benchmarking" },
4647 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4648 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4649 "dump each input packet" },
4650 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4651 "when dumping packets, also dump the payload" },
4652 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4653 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4654 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4655 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4656 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4657 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4658 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4659 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4660 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4661 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4662 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4663 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4664 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4665 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4666 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4667 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4668 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4670 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4672 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4673 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4674 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4677 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4678 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4679 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4680 { "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" },
4681 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4682 { "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" },
4683 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4684 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4685 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4686 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4687 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4688 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4689 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4690 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4691 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4692 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4693 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4694 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4695 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4696 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4697 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4698 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4699 "use same quantizer as source (implies VBR)" },
4700 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4701 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4702 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4703 "deinterlace pictures" },
4704 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4705 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4706 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4708 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4710 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4711 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4712 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4713 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4714 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4715 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4716 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4717 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4718 { "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" },
4719 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4722 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4723 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4724 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4725 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4726 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4727 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4728 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4729 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4730 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4731 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4733 /* subtitle options */
4734 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4735 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4736 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4739 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4740 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4741 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4744 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4745 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4747 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4748 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4749 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4751 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4752 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4753 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4754 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4755 /* data codec support */
4756 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4758 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4762 int main(int argc, char **argv)
4764 OptionsContext o = { 0 };
4767 reset_options(&o, 0);
4769 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4770 parse_loglevel(argc, argv, options);
4772 if(argc>1 && !strcmp(argv[1], "-d")){
4774 av_log_set_callback(log_callback_null);
4779 avcodec_register_all();
4781 avdevice_register_all();
4784 avfilter_register_all();
4787 avformat_network_init();
4794 parse_options(&o, argc, argv, options, opt_output_file);
4796 if(nb_output_files <= 0 && nb_input_files == 0) {
4798 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4802 /* file converter / grab */
4803 if (nb_output_files <= 0) {
4804 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4808 if (nb_input_files == 0) {
4809 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4814 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4816 ti = getutime() - ti;
4818 int maxrss = getmaxrss() / 1024;
4819 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);