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= -1;
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 uint8_t *input_tmp= NULL;
173 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
175 typedef struct InputStream {
178 int discard; /* true if stream data should be discarded */
179 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
181 AVFrame *decoded_frame;
182 AVFrame *filtered_frame;
184 int64_t start; /* time when read started */
185 int64_t next_pts; /* synthetic pts for cases where pkt.pts
187 int64_t pts; /* current pts */
189 int is_start; /* is 1 at the start and after a discontinuity */
190 int showed_multi_packet_warning;
194 typedef struct InputFile {
195 AVFormatContext *ctx;
196 int eof_reached; /* true if eof reached */
197 int ist_index; /* index of first stream in input_streams */
198 int buffer_size; /* current total buffer size */
200 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
201 from ctx.nb_streams if new streams appear during av_read_frame() */
205 typedef struct OutputStream {
206 int file_index; /* file index */
207 int index; /* stream index in the output file */
208 int source_index; /* InputStream index */
209 AVStream *st; /* stream in the output file */
210 int encoding_needed; /* true if encoding needed for this stream */
212 /* input pts and corresponding output pts
214 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
215 struct InputStream *sync_ist; /* input stream to sync against */
216 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
217 AVBitStreamFilterContext *bitstream_filters;
223 AVFrame resample_frame; /* temporary frame for image resampling */
224 struct SwsContext *img_resample_ctx; /* for image resampling */
227 int resample_pix_fmt;
228 AVRational frame_rate;
232 float frame_aspect_ratio;
234 /* forced key frames */
235 int64_t *forced_kf_pts;
241 int audio_channels_map[SWR_CH_MAX]; ///< list of the channels id to pick from the source stream
242 int audio_channels_mapped; ///< number of channels in audio_channels_map
243 int resample_sample_fmt;
244 int resample_channels;
245 int resample_sample_rate;
246 float rematrix_volume;
247 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
250 struct SwrContext *swr;
253 AVFilterContext *output_video_filter;
254 AVFilterContext *input_video_filter;
255 AVFilterBufferRef *picref;
257 AVFilterGraph *graph;
262 int is_past_recording_time;
264 const char *attachment_filename;
265 int copy_initial_nonkeyframes;
271 /* init terminal so that we can grab keys */
272 static struct termios oldtty;
275 typedef struct OutputFile {
276 AVFormatContext *ctx;
278 int ost_index; /* index of the first stream in output_streams */
279 int64_t recording_time; /* desired length of the resulting file in microseconds */
280 int64_t start_time; /* start time in microseconds */
281 uint64_t limit_filesize;
284 static InputStream *input_streams = NULL;
285 static int nb_input_streams = 0;
286 static InputFile *input_files = NULL;
287 static int nb_input_files = 0;
289 static OutputStream *output_streams = NULL;
290 static int nb_output_streams = 0;
291 static OutputFile *output_files = NULL;
292 static int nb_output_files = 0;
294 typedef struct OptionsContext {
295 /* input/output options */
299 SpecifierOpt *codec_names;
301 SpecifierOpt *audio_channels;
302 int nb_audio_channels;
303 SpecifierOpt *audio_sample_rate;
304 int nb_audio_sample_rate;
305 SpecifierOpt *rematrix_volume;
306 int nb_rematrix_volume;
307 SpecifierOpt *frame_rates;
309 SpecifierOpt *frame_sizes;
311 SpecifierOpt *frame_pix_fmts;
312 int nb_frame_pix_fmts;
315 int64_t input_ts_offset;
318 SpecifierOpt *ts_scale;
320 SpecifierOpt *dump_attachment;
321 int nb_dump_attachment;
324 StreamMap *stream_maps;
326 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
327 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
328 /* first item specifies output metadata, second is input */
329 MetadataMap (*meta_data_maps)[2];
330 int nb_meta_data_maps;
331 int metadata_global_manual;
332 int metadata_streams_manual;
333 int metadata_chapters_manual;
334 const char **attachments;
337 int chapters_input_file;
339 int64_t recording_time;
340 uint64_t limit_filesize;
346 int subtitle_disable;
349 /* indexed by output file stream index */
353 SpecifierOpt *metadata;
355 SpecifierOpt *max_frames;
357 SpecifierOpt *bitstream_filters;
358 int nb_bitstream_filters;
359 SpecifierOpt *codec_tags;
361 SpecifierOpt *sample_fmts;
363 SpecifierOpt *qscale;
365 SpecifierOpt *forced_key_frames;
366 int nb_forced_key_frames;
367 SpecifierOpt *force_fps;
369 SpecifierOpt *frame_aspect_ratios;
370 int nb_frame_aspect_ratios;
371 SpecifierOpt *rc_overrides;
373 SpecifierOpt *intra_matrices;
374 int nb_intra_matrices;
375 SpecifierOpt *inter_matrices;
376 int nb_inter_matrices;
377 SpecifierOpt *top_field_first;
378 int nb_top_field_first;
379 SpecifierOpt *metadata_map;
381 SpecifierOpt *presets;
383 SpecifierOpt *copy_initial_nonkeyframes;
384 int nb_copy_initial_nonkeyframes;
386 SpecifierOpt *filters;
391 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
394 for (i = 0; i < o->nb_ ## name; i++) {\
395 char *spec = o->name[i].specifier;\
396 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
397 outvar = o->name[i].u.type;\
403 static void reset_options(OptionsContext *o, int is_input)
405 const OptionDef *po = options;
406 OptionsContext bak= *o;
408 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
410 void *dst = (uint8_t*)o + po->u.off;
412 if (po->flags & OPT_SPEC) {
413 SpecifierOpt **so = dst;
414 int i, *count = (int*)(so + 1);
415 for (i = 0; i < *count; i++) {
416 av_freep(&(*so)[i].specifier);
417 if (po->flags & OPT_STRING)
418 av_freep(&(*so)[i].u.str);
422 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
427 av_freep(&o->stream_maps);
428 av_freep(&o->audio_channel_maps);
429 av_freep(&o->meta_data_maps);
430 av_freep(&o->streamid_map);
432 memset(o, 0, sizeof(*o));
434 if(is_input) o->recording_time = bak.recording_time;
435 else o->recording_time = INT64_MAX;
436 o->mux_max_delay = 0.7;
437 o->limit_filesize = UINT64_MAX;
438 o->chapters_input_file = INT_MAX;
446 static int configure_video_filters(InputStream *ist, OutputStream *ost)
448 AVFilterContext *last_filter, *filter;
449 /** filter graph containing all filters including input & output */
450 AVCodecContext *codec = ost->st->codec;
451 AVCodecContext *icodec = ist->st->codec;
452 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
453 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
454 AVRational sample_aspect_ratio;
458 ost->graph = avfilter_graph_alloc();
460 if (ist->st->sample_aspect_ratio.num){
461 sample_aspect_ratio = ist->st->sample_aspect_ratio;
463 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
465 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
466 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
467 sample_aspect_ratio.num, sample_aspect_ratio.den);
469 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
470 "src", args, NULL, ost->graph);
473 #if FF_API_OLD_VSINK_API
474 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
475 "out", NULL, pix_fmts, ost->graph);
477 buffersink_params->pixel_fmts = pix_fmts;
478 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
479 "out", NULL, buffersink_params, ost->graph);
481 av_freep(&buffersink_params);
484 last_filter = ost->input_video_filter;
486 if (codec->width != icodec->width || codec->height != icodec->height) {
487 snprintf(args, 255, "%d:%d:flags=0x%X",
490 (unsigned)ost->sws_flags);
491 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
492 NULL, args, NULL, ost->graph)) < 0)
494 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
496 last_filter = filter;
499 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
500 ost->graph->scale_sws_opts = av_strdup(args);
503 AVFilterInOut *outputs = avfilter_inout_alloc();
504 AVFilterInOut *inputs = avfilter_inout_alloc();
506 outputs->name = av_strdup("in");
507 outputs->filter_ctx = last_filter;
508 outputs->pad_idx = 0;
509 outputs->next = NULL;
511 inputs->name = av_strdup("out");
512 inputs->filter_ctx = ost->output_video_filter;
516 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
518 av_freep(&ost->avfilter);
520 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
524 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
527 codec->width = ost->output_video_filter->inputs[0]->w;
528 codec->height = ost->output_video_filter->inputs[0]->h;
529 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
530 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
531 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
532 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
536 #endif /* CONFIG_AVFILTER */
538 static void term_exit(void)
540 av_log(NULL, AV_LOG_QUIET, "%s", "");
543 tcsetattr (0, TCSANOW, &oldtty);
547 static volatile int received_sigterm = 0;
549 static void sigterm_handler(int sig)
551 received_sigterm = sig;
552 received_nb_signals++;
554 if(received_nb_signals > 3)
558 static void term_init(void)
568 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
569 |INLCR|IGNCR|ICRNL|IXON);
570 tty.c_oflag |= OPOST;
571 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
572 tty.c_cflag &= ~(CSIZE|PARENB);
577 tcsetattr (0, TCSANOW, &tty);
578 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
581 avformat_network_deinit();
583 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
584 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
586 signal(SIGXCPU, sigterm_handler);
590 /* read a key without blocking */
591 static int read_key(void)
603 n = select(1, &rfds, NULL, NULL, &tv);
612 # if HAVE_PEEKNAMEDPIPE
614 static HANDLE input_handle;
617 input_handle = GetStdHandle(STD_INPUT_HANDLE);
618 is_pipe = !GetConsoleMode(input_handle, &dw);
621 if (stdin->_cnt > 0) {
626 /* When running under a GUI, you will end here. */
627 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
644 static int decode_interrupt_cb(void *ctx)
646 return received_nb_signals > 1;
649 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
651 void av_noreturn exit_program(int ret)
656 for(i=0;i<nb_output_files;i++) {
657 AVFormatContext *s = output_files[i].ctx;
658 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
660 avformat_free_context(s);
661 av_dict_free(&output_files[i].opts);
663 for(i=0;i<nb_input_files;i++) {
664 avformat_close_input(&input_files[i].ctx);
666 for (i = 0; i < nb_input_streams; i++) {
667 av_freep(&input_streams[i].decoded_frame);
668 av_freep(&input_streams[i].filtered_frame);
669 av_dict_free(&input_streams[i].opts);
674 av_free(vstats_filename);
676 av_freep(&input_streams);
677 av_freep(&input_files);
678 av_freep(&output_streams);
679 av_freep(&output_files);
684 allocated_audio_buf_size= allocated_audio_out_size= 0;
689 avformat_network_deinit();
691 av_freep(&input_tmp);
693 if (received_sigterm) {
694 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
695 (int) received_sigterm);
699 exit(ret); /* not all OS-es handle main() return value */
702 static void assert_avoptions(AVDictionary *m)
704 AVDictionaryEntry *t;
705 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
706 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
711 static void assert_codec_experimental(AVCodecContext *c, int encoder)
713 const char *codec_string = encoder ? "encoder" : "decoder";
715 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
716 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
717 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
718 "results.\nAdd '-strict experimental' if you want to use it.\n",
719 codec_string, c->codec->name);
720 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
721 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
722 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
723 codec_string, codec->name);
728 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
730 if(codec && codec->sample_fmts){
731 const enum AVSampleFormat *p= codec->sample_fmts;
733 if(*p == st->codec->sample_fmt)
737 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
738 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
739 if(av_get_sample_fmt_name(st->codec->sample_fmt))
740 av_log(NULL, AV_LOG_WARNING,
741 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
742 av_get_sample_fmt_name(st->codec->sample_fmt),
744 av_get_sample_fmt_name(codec->sample_fmts[0]));
745 st->codec->sample_fmt = codec->sample_fmts[0];
750 static void choose_sample_rate(AVStream *st, AVCodec *codec)
752 if(codec && codec->supported_samplerates){
753 const int *p= codec->supported_samplerates;
755 int best_dist=INT_MAX;
757 int dist= abs(st->codec->sample_rate - *p);
758 if(dist < best_dist){
764 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
766 st->codec->sample_rate= best;
770 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
772 if(codec && codec->pix_fmts){
773 const enum PixelFormat *p= codec->pix_fmts;
774 int has_alpha= av_pix_fmt_descriptors[st->codec->pix_fmt].nb_components % 2 == 0;
775 enum PixelFormat best= PIX_FMT_NONE;
776 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
777 if(st->codec->codec_id==CODEC_ID_MJPEG){
778 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
779 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
780 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};
783 for (; *p != PIX_FMT_NONE; p++) {
784 best= avcodec_find_best_pix_fmt2(best, *p, st->codec->pix_fmt, has_alpha, NULL);
785 if(*p == st->codec->pix_fmt)
788 if (*p == PIX_FMT_NONE) {
789 if(st->codec->pix_fmt != PIX_FMT_NONE)
790 av_log(NULL, AV_LOG_WARNING,
791 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
792 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
794 av_pix_fmt_descriptors[best].name);
795 st->codec->pix_fmt = best;
800 static double get_sync_ipts(const OutputStream *ost)
802 const InputStream *ist = ost->sync_ist;
803 OutputFile *of = &output_files[ost->file_index];
804 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
807 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
812 AVPacket new_pkt= *pkt;
813 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
814 &new_pkt.data, &new_pkt.size,
815 pkt->data, pkt->size,
816 pkt->flags & AV_PKT_FLAG_KEY);
819 new_pkt.destruct= av_destruct_packet;
821 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
822 bsfc->filter->name, pkt->stream_index,
823 avctx->codec ? avctx->codec->name : "copy");
833 ret= av_interleaved_write_frame(s, pkt);
835 print_error("av_interleaved_write_frame()", ret);
840 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
842 int fill_char = 0x00;
843 if (sample_fmt == AV_SAMPLE_FMT_U8)
845 memset(buf, fill_char, size);
848 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
849 InputStream *ist, AVFrame *decoded_frame)
852 int64_t audio_out_size, audio_buf_size;
854 int size_out, frame_bytes, ret, resample_changed;
855 AVCodecContext *enc= ost->st->codec;
856 AVCodecContext *dec= ist->st->codec;
857 int osize = av_get_bytes_per_sample(enc->sample_fmt);
858 int isize = av_get_bytes_per_sample(dec->sample_fmt);
859 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
860 uint8_t *buf = decoded_frame->data[0];
861 int size = decoded_frame->nb_samples * dec->channels * isize;
862 int64_t allocated_for_size = size;
865 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
866 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
867 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
868 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
869 audio_buf_size*= osize*enc->channels;
871 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
872 if(coded_bps > 8*osize)
873 audio_out_size= audio_out_size * coded_bps / (8*osize);
874 audio_out_size += FF_MIN_BUFFER_SIZE;
876 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
877 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
881 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
882 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
883 if (!audio_buf || !audio_out){
884 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
888 if (enc->channels != dec->channels
889 || enc->sample_fmt != dec->sample_fmt
890 || enc->sample_rate!= dec->sample_rate
892 ost->audio_resample = 1;
894 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
895 ost->resample_channels != dec->channels ||
896 ost->resample_sample_rate != dec->sample_rate;
898 if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
899 if (resample_changed) {
900 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",
901 ist->file_index, ist->st->index,
902 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
903 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
904 ost->resample_sample_fmt = dec->sample_fmt;
905 ost->resample_channels = dec->channels;
906 ost->resample_sample_rate = dec->sample_rate;
909 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
910 if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
911 ost->resample_sample_fmt == enc->sample_fmt &&
912 ost->resample_channels == enc->channels &&
913 ost->resample_sample_rate == enc->sample_rate) {
915 ost->audio_resample = 0;
917 ost->swr = swr_alloc_set_opts(ost->swr,
918 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
919 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
921 if (ost->audio_channels_mapped)
922 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
923 av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
924 if (ost->audio_channels_mapped) {
925 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
926 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
928 av_opt_set_int(ost->swr, "ich", dec->channels, 0);
929 av_opt_set_int(ost->swr, "och", enc->channels, 0);
930 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
931 if(ost->swr && swr_init(ost->swr) < 0){
932 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
937 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
938 dec->channels, dec->sample_rate,
939 enc->channels, enc->sample_rate);
945 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
947 if(audio_sync_method){
948 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
949 - av_fifo_size(ost->fifo)/(enc->channels * osize);
950 int idelta = delta * dec->sample_rate / enc->sample_rate;
951 int byte_delta = idelta * isize * dec->channels;
953 //FIXME resample delay
954 if(fabs(delta) > 50){
955 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
957 byte_delta= FFMAX(byte_delta, -size);
960 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
961 -byte_delta / (isize * dec->channels));
966 input_tmp= av_realloc(input_tmp, byte_delta + size);
968 if(byte_delta > allocated_for_size - size){
969 allocated_for_size= byte_delta + (int64_t)size;
974 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
975 memcpy(input_tmp + byte_delta, buf, size);
978 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
980 }else if(audio_sync_method>1){
981 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
982 av_assert0(ost->audio_resample);
983 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
984 delta, comp, enc->sample_rate);
985 // 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));
986 swr_compensate(ost->swr, comp, enc->sample_rate);
990 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
991 - av_fifo_size(ost->fifo)/(enc->channels * osize); //FIXME wrong
993 if (ost->audio_resample) {
995 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
996 (const uint8_t*[]){buf }, size / (dec->channels * isize));
997 size_out = size_out * enc->channels * osize;
1003 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1005 /* now encode as many frames as possible */
1006 if (enc->frame_size > 1) {
1007 /* output resampled raw samples */
1008 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1009 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1012 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1014 frame_bytes = enc->frame_size * osize * enc->channels;
1016 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1018 av_init_packet(&pkt);
1020 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1022 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1024 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1025 (short *)audio_buf);
1027 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1031 pkt.stream_index= ost->index;
1032 pkt.data= audio_out;
1034 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1035 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1036 pkt.flags |= AV_PKT_FLAG_KEY;
1037 write_frame(s, &pkt, enc, ost->bitstream_filters);
1039 ost->sync_opts += enc->frame_size;
1043 av_init_packet(&pkt);
1045 ost->sync_opts += size_out / (osize * enc->channels);
1047 /* output a pcm frame */
1048 /* determine the size of the coded buffer */
1051 size_out = size_out*coded_bps/8;
1053 if(size_out > audio_out_size){
1054 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1058 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1059 ret = avcodec_encode_audio(enc, audio_out, size_out,
1062 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1066 pkt.stream_index= ost->index;
1067 pkt.data= audio_out;
1069 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1070 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1071 pkt.flags |= AV_PKT_FLAG_KEY;
1072 write_frame(s, &pkt, enc, ost->bitstream_filters);
1076 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1078 AVCodecContext *dec;
1079 AVPicture *picture2;
1080 AVPicture picture_tmp;
1083 dec = ist->st->codec;
1085 /* deinterlace : must be done before any resize */
1086 if (do_deinterlace) {
1089 /* create temporary picture */
1090 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1091 buf = av_malloc(size);
1095 picture2 = &picture_tmp;
1096 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1098 if(avpicture_deinterlace(picture2, picture,
1099 dec->pix_fmt, dec->width, dec->height) < 0) {
1100 /* if error, do not deinterlace */
1101 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1110 if (picture != picture2)
1111 *picture = *picture2;
1115 static void do_subtitle_out(AVFormatContext *s,
1121 static uint8_t *subtitle_out = NULL;
1122 int subtitle_out_max_size = 1024 * 1024;
1123 int subtitle_out_size, nb, i;
1124 AVCodecContext *enc;
1127 if (pts == AV_NOPTS_VALUE) {
1128 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1134 enc = ost->st->codec;
1136 if (!subtitle_out) {
1137 subtitle_out = av_malloc(subtitle_out_max_size);
1140 /* Note: DVB subtitle need one packet to draw them and one other
1141 packet to clear them */
1142 /* XXX: signal it in the codec context ? */
1143 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1148 for(i = 0; i < nb; i++) {
1149 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1150 // start_display_time is required to be 0
1151 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1152 sub->end_display_time -= sub->start_display_time;
1153 sub->start_display_time = 0;
1154 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1155 subtitle_out_max_size, sub);
1156 if (subtitle_out_size < 0) {
1157 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1161 av_init_packet(&pkt);
1162 pkt.stream_index = ost->index;
1163 pkt.data = subtitle_out;
1164 pkt.size = subtitle_out_size;
1165 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1166 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1167 /* XXX: the pts correction is handled here. Maybe handling
1168 it in the codec would be better */
1170 pkt.pts += 90 * sub->start_display_time;
1172 pkt.pts += 90 * sub->end_display_time;
1174 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1178 static int bit_buffer_size= 1024*256;
1179 static uint8_t *bit_buffer= NULL;
1181 static void do_video_resample(OutputStream *ost,
1183 AVFrame *in_picture,
1184 AVFrame **out_picture)
1187 *out_picture = in_picture;
1189 AVCodecContext *dec = ist->st->codec;
1190 AVCodecContext *enc = ost->st->codec;
1191 int resample_changed = ost->resample_width != dec->width ||
1192 ost->resample_height != dec->height ||
1193 ost->resample_pix_fmt != dec->pix_fmt;
1195 *out_picture = in_picture;
1196 if (resample_changed) {
1197 av_log(NULL, AV_LOG_INFO,
1198 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1199 ist->file_index, ist->st->index,
1200 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1201 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1202 ost->resample_width = dec->width;
1203 ost->resample_height = dec->height;
1204 ost->resample_pix_fmt = dec->pix_fmt;
1207 ost->video_resample = dec->width != enc->width ||
1208 dec->height != enc->height ||
1209 dec->pix_fmt != enc->pix_fmt;
1211 if (ost->video_resample) {
1212 *out_picture = &ost->resample_frame;
1213 if (!ost->img_resample_ctx || resample_changed) {
1214 /* initialize the destination picture */
1215 if (!ost->resample_frame.data[0]) {
1216 avcodec_get_frame_defaults(&ost->resample_frame);
1217 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1218 enc->width, enc->height)) {
1219 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1223 /* initialize a new scaler context */
1224 sws_freeContext(ost->img_resample_ctx);
1225 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1226 enc->width, enc->height, enc->pix_fmt,
1227 ost->sws_flags, NULL, NULL, NULL);
1228 if (ost->img_resample_ctx == NULL) {
1229 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1233 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1234 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1240 static void do_video_out(AVFormatContext *s,
1243 AVFrame *in_picture,
1244 int *frame_size, float quality)
1246 int nb_frames, i, ret, format_video_sync;
1247 AVFrame *final_picture;
1248 AVCodecContext *enc;
1250 double duration = 0;
1252 enc = ost->st->codec;
1254 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1255 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1256 if(ist->st->avg_frame_rate.num)
1257 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1259 duration /= av_q2d(enc->time_base);
1262 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1264 /* by default, we output a single frame */
1269 format_video_sync = video_sync_method;
1270 if (format_video_sync < 0)
1271 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? 0 : 2) : 1;
1273 if (format_video_sync) {
1274 double vdelta = sync_ipts - ost->sync_opts + duration;
1275 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1278 else if (format_video_sync == 2) {
1281 }else if(vdelta>0.6)
1282 ost->sync_opts= lrintf(sync_ipts);
1283 }else if (vdelta > 1.1)
1284 nb_frames = lrintf(vdelta);
1285 //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);
1286 if (nb_frames == 0){
1288 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1289 }else if (nb_frames > 1) {
1290 nb_frames_dup += nb_frames - 1;
1291 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1294 ost->sync_opts= lrintf(sync_ipts);
1296 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1300 do_video_resample(ost, ist, in_picture, &final_picture);
1302 /* duplicates frame if needed */
1303 for(i=0;i<nb_frames;i++) {
1305 av_init_packet(&pkt);
1306 pkt.stream_index= ost->index;
1308 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1309 enc->codec->id == CODEC_ID_RAWVIDEO) {
1310 /* raw pictures are written as AVPicture structure to
1311 avoid any copies. We support temporarily the older
1313 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1314 enc->coded_frame->top_field_first = in_picture->top_field_first;
1315 pkt.data= (uint8_t *)final_picture;
1316 pkt.size= sizeof(AVPicture);
1317 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1318 pkt.flags |= AV_PKT_FLAG_KEY;
1320 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1322 AVFrame big_picture;
1324 big_picture= *final_picture;
1325 /* better than nothing: use input picture interlaced
1327 big_picture.interlaced_frame = in_picture->interlaced_frame;
1328 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1329 if (ost->top_field_first == -1)
1330 big_picture.top_field_first = in_picture->top_field_first;
1332 big_picture.top_field_first = !!ost->top_field_first;
1335 /* handles same_quant here. This is not correct because it may
1336 not be a global option */
1337 big_picture.quality = quality;
1338 if (!enc->me_threshold)
1339 big_picture.pict_type = 0;
1340 // big_picture.pts = AV_NOPTS_VALUE;
1341 big_picture.pts= ost->sync_opts;
1342 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1343 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1344 if (ost->forced_kf_index < ost->forced_kf_count &&
1345 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1346 big_picture.pict_type = AV_PICTURE_TYPE_I;
1347 ost->forced_kf_index++;
1349 ret = avcodec_encode_video(enc,
1350 bit_buffer, bit_buffer_size,
1353 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1358 pkt.data= bit_buffer;
1360 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1361 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1362 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1363 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1364 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1366 if(enc->coded_frame->key_frame)
1367 pkt.flags |= AV_PKT_FLAG_KEY;
1368 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1371 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1372 // enc->frame_number-1, ret, enc->pict_type);
1373 /* if two pass, output log */
1374 if (ost->logfile && enc->stats_out) {
1375 fprintf(ost->logfile, "%s", enc->stats_out);
1380 ost->frame_number++;
1384 static double psnr(double d)
1386 return -10.0*log(d)/log(10.0);
1389 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1392 AVCodecContext *enc;
1394 double ti1, bitrate, avg_bitrate;
1396 /* this is executed just the first time do_video_stats is called */
1398 vstats_file = fopen(vstats_filename, "w");
1405 enc = ost->st->codec;
1406 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1407 frame_number = ost->frame_number;
1408 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1409 if (enc->flags&CODEC_FLAG_PSNR)
1410 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1412 fprintf(vstats_file,"f_size= %6d ", frame_size);
1413 /* compute pts value */
1414 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1418 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1419 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1420 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1421 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1422 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1426 static void print_report(OutputFile *output_files,
1427 OutputStream *ost_table, int nb_ostreams,
1428 int is_last_report, int64_t timer_start, int64_t cur_time)
1432 AVFormatContext *oc;
1434 AVCodecContext *enc;
1435 int frame_number, vid, i;
1437 int64_t pts = INT64_MAX;
1438 static int64_t last_time = -1;
1439 static int qp_histogram[52];
1440 int hours, mins, secs, us;
1442 if (!print_stats && !is_last_report)
1445 if (!is_last_report) {
1446 if (last_time == -1) {
1447 last_time = cur_time;
1450 if ((cur_time - last_time) < 500000)
1452 last_time = cur_time;
1456 oc = output_files[0].ctx;
1458 total_size = avio_size(oc->pb);
1459 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
1460 total_size= avio_tell(oc->pb);
1467 for(i=0;i<nb_ostreams;i++) {
1469 ost = &ost_table[i];
1470 enc = ost->st->codec;
1471 if (!ost->stream_copy && enc->coded_frame)
1472 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1473 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1474 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1476 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1477 float t = (cur_time-timer_start) / 1000000.0;
1479 frame_number = ost->frame_number;
1480 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1481 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1483 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1487 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1490 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1492 if (enc->flags&CODEC_FLAG_PSNR){
1494 double error, error_sum=0;
1495 double scale, scale_sum=0;
1496 char type[3]= {'Y','U','V'};
1497 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1500 error= enc->error[j];
1501 scale= enc->width*enc->height*255.0*255.0*frame_number;
1503 error= enc->coded_frame->error[j];
1504 scale= enc->width*enc->height*255.0*255.0;
1509 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1511 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1515 /* compute min output value */
1516 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1517 ost->st->time_base, AV_TIME_BASE_Q));
1520 secs = pts / AV_TIME_BASE;
1521 us = pts % AV_TIME_BASE;
1527 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1529 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1530 "size=%8.0fkB time=", total_size / 1024.0);
1531 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1532 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1533 (100 * us) / AV_TIME_BASE);
1534 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1535 "bitrate=%6.1fkbits/s", bitrate);
1537 if (nb_frames_dup || nb_frames_drop)
1538 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1539 nb_frames_dup, nb_frames_drop);
1541 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1545 if (is_last_report) {
1546 int64_t raw= audio_size + video_size + extra_size;
1547 av_log(NULL, AV_LOG_INFO, "\n");
1548 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1552 100.0*(total_size - raw)/raw
1554 if(video_size + audio_size + extra_size == 0){
1555 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1560 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1564 for (i = 0; i < nb_ostreams; i++) {
1565 OutputStream *ost = &ost_table[i];
1566 AVCodecContext *enc = ost->st->codec;
1567 AVFormatContext *os = output_files[ost->file_index].ctx;
1569 if (!ost->encoding_needed)
1572 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1574 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1580 av_init_packet(&pkt);
1581 pkt.stream_index= ost->index;
1583 switch (ost->st->codec->codec_type) {
1584 case AVMEDIA_TYPE_AUDIO:
1585 fifo_bytes = av_fifo_size(ost->fifo);
1587 /* encode any samples remaining in fifo */
1588 if (fifo_bytes > 0) {
1589 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1590 int fs_tmp = enc->frame_size;
1592 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1593 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1594 enc->frame_size = fifo_bytes / (osize * enc->channels);
1596 int frame_bytes = enc->frame_size*osize*enc->channels;
1597 if (allocated_audio_buf_size < frame_bytes)
1599 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1602 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1603 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1604 ost->st->time_base.num, enc->sample_rate);
1605 enc->frame_size = fs_tmp;
1608 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1611 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1615 pkt.flags |= AV_PKT_FLAG_KEY;
1617 case AVMEDIA_TYPE_VIDEO:
1618 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1620 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1624 if(enc->coded_frame && enc->coded_frame->key_frame)
1625 pkt.flags |= AV_PKT_FLAG_KEY;
1626 if (ost->logfile && enc->stats_out) {
1627 fprintf(ost->logfile, "%s", enc->stats_out);
1636 pkt.data = bit_buffer;
1638 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1639 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1640 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1646 * Check whether a packet from ist should be written into ost at this time
1648 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1650 OutputFile *of = &output_files[ost->file_index];
1651 int ist_index = ist - input_streams;
1653 if (ost->source_index != ist_index)
1656 if (of->start_time && ist->pts < of->start_time)
1659 if (of->recording_time != INT64_MAX &&
1660 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1661 (AVRational){1, 1000000}) >= 0) {
1662 ost->is_past_recording_time = 1;
1669 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1671 OutputFile *of = &output_files[ost->file_index];
1672 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1676 av_init_packet(&opkt);
1678 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1679 !ost->copy_initial_nonkeyframes)
1682 /* force the input stream PTS */
1683 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1684 audio_size += pkt->size;
1685 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1686 video_size += pkt->size;
1690 opkt.stream_index = ost->index;
1691 if (pkt->pts != AV_NOPTS_VALUE)
1692 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1694 opkt.pts = AV_NOPTS_VALUE;
1696 if (pkt->dts == AV_NOPTS_VALUE)
1697 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1699 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1700 opkt.dts -= ost_tb_start_time;
1702 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1703 opkt.flags = pkt->flags;
1705 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1706 if( ost->st->codec->codec_id != CODEC_ID_H264
1707 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1708 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1710 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1711 opkt.destruct = av_destruct_packet;
1713 opkt.data = pkt->data;
1714 opkt.size = pkt->size;
1716 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1717 /* store AVPicture in AVPacket, as expected by the output format */
1718 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1719 opkt.data = (uint8_t *)&pict;
1720 opkt.size = sizeof(AVPicture);
1721 opkt.flags |= AV_PKT_FLAG_KEY;
1724 write_frame(of->ctx, &opkt, ost->st->codec, ost->bitstream_filters);
1725 ost->st->codec->frame_number++;
1726 ost->frame_number++;
1727 av_free_packet(&opkt);
1730 static void rate_emu_sleep(InputStream *ist)
1732 if (input_files[ist->file_index].rate_emu) {
1733 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1734 int64_t now = av_gettime() - ist->start;
1740 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1742 AVFrame *decoded_frame;
1743 AVCodecContext *avctx = ist->st->codec;
1744 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1747 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1748 return AVERROR(ENOMEM);
1750 avcodec_get_frame_defaults(ist->decoded_frame);
1751 decoded_frame = ist->decoded_frame;
1753 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1759 /* no audio frame */
1763 /* if the decoder provides a pts, use it instead of the last packet pts.
1764 the decoder could be delaying output by a packet or more. */
1765 if (decoded_frame->pts != AV_NOPTS_VALUE)
1766 ist->next_pts = decoded_frame->pts;
1768 /* increment next_pts to use for the case where the input stream does not
1769 have timestamps or there are multiple frames in the packet */
1770 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1773 // preprocess audio (volume)
1774 if (audio_volume != 256) {
1775 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1776 void *samples = decoded_frame->data[0];
1777 switch (avctx->sample_fmt) {
1778 case AV_SAMPLE_FMT_U8:
1780 uint8_t *volp = samples;
1781 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1782 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1783 *volp++ = av_clip_uint8(v);
1787 case AV_SAMPLE_FMT_S16:
1789 int16_t *volp = samples;
1790 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1791 int v = ((*volp) * audio_volume + 128) >> 8;
1792 *volp++ = av_clip_int16(v);
1796 case AV_SAMPLE_FMT_S32:
1798 int32_t *volp = samples;
1799 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1800 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1801 *volp++ = av_clipl_int32(v);
1805 case AV_SAMPLE_FMT_FLT:
1807 float *volp = samples;
1808 float scale = audio_volume / 256.f;
1809 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1814 case AV_SAMPLE_FMT_DBL:
1816 double *volp = samples;
1817 double scale = audio_volume / 256.;
1818 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1824 av_log(NULL, AV_LOG_FATAL,
1825 "Audio volume adjustment on sample format %s is not supported.\n",
1826 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1831 rate_emu_sleep(ist);
1833 for (i = 0; i < nb_output_streams; i++) {
1834 OutputStream *ost = &output_streams[i];
1836 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1838 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
1844 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
1846 AVFrame *decoded_frame, *filtered_frame = NULL;
1847 void *buffer_to_free = NULL;
1851 int frame_available = 1;
1854 int64_t *best_effort_timestamp;
1855 AVRational *frame_sample_aspect;
1857 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1858 return AVERROR(ENOMEM);
1860 avcodec_get_frame_defaults(ist->decoded_frame);
1861 decoded_frame = ist->decoded_frame;
1862 pkt->pts = *pkt_pts;
1863 pkt->dts = *pkt_dts;
1864 *pkt_pts = AV_NOPTS_VALUE;
1866 if (pkt->duration) {
1867 duration = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
1868 } else if(ist->st->codec->time_base.num != 0) {
1869 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1870 duration = ((int64_t)AV_TIME_BASE *
1871 ist->st->codec->time_base.num * ticks) /
1872 ist->st->codec->time_base.den;
1875 if(*pkt_dts != AV_NOPTS_VALUE && duration) {
1876 *pkt_dts += duration;
1878 *pkt_dts = AV_NOPTS_VALUE;
1880 ret = avcodec_decode_video2(ist->st->codec,
1881 decoded_frame, got_output, pkt);
1885 quality = same_quant ? decoded_frame->quality : 0;
1887 /* no picture yet */
1891 best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
1892 if(*best_effort_timestamp != AV_NOPTS_VALUE)
1893 ist->next_pts = ist->pts = *best_effort_timestamp;
1895 ist->next_pts += duration;
1898 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1901 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
1902 for(i=0;i<nb_output_streams;i++) {
1903 OutputStream *ost = ost = &output_streams[i];
1904 if(check_output_constraints(ist, ost)){
1905 if (!frame_sample_aspect->num)
1906 *frame_sample_aspect = ist->st->sample_aspect_ratio;
1907 decoded_frame->pts = ist->pts;
1909 if((av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE)) < 0){
1910 av_log(0, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
1917 rate_emu_sleep(ist);
1919 for (i = 0; i < nb_output_streams; i++) {
1920 OutputStream *ost = &output_streams[i];
1923 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1927 if (ost->input_video_filter) {
1928 frame_available = av_buffersink_poll_frame(ost->output_video_filter);
1930 while (frame_available) {
1931 if (ost->output_video_filter) {
1932 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1933 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0){
1934 av_log(0, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");
1937 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
1938 av_free(buffer_to_free);
1939 return AVERROR(ENOMEM);
1941 avcodec_get_frame_defaults(ist->filtered_frame);
1942 filtered_frame = ist->filtered_frame;
1943 *filtered_frame= *decoded_frame; //for me_threshold
1945 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
1946 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1949 if (ost->picref->video && !ost->frame_aspect_ratio)
1950 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1952 filtered_frame = decoded_frame;
1955 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
1956 same_quant ? quality : ost->st->codec->global_quality);
1957 if (vstats_filename && frame_size)
1958 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
1961 frame_available = ost->output_video_filter && av_buffersink_poll_frame(ost->output_video_filter);
1962 avfilter_unref_buffer(ost->picref);
1967 av_free(buffer_to_free);
1971 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1973 AVSubtitle subtitle;
1974 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1975 &subtitle, got_output, pkt);
1981 rate_emu_sleep(ist);
1983 for (i = 0; i < nb_output_streams; i++) {
1984 OutputStream *ost = &output_streams[i];
1986 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1989 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
1992 avsubtitle_free(&subtitle);
1996 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1997 static int output_packet(InputStream *ist,
1998 OutputStream *ost_table, int nb_ostreams,
1999 const AVPacket *pkt)
2003 int64_t pkt_dts = AV_NOPTS_VALUE;
2004 int64_t pkt_pts = AV_NOPTS_VALUE;
2008 if (ist->next_pts == AV_NOPTS_VALUE)
2009 ist->next_pts = ist->pts;
2013 av_init_packet(&avpkt);
2021 if(pkt->dts != AV_NOPTS_VALUE){
2022 if(ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2023 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2024 pkt_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2026 if(pkt->pts != AV_NOPTS_VALUE)
2027 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2029 //while we have more to decode or while the decoder did output something on EOF
2030 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2033 ist->pts = ist->next_pts;
2035 if (avpkt.size && avpkt.size != pkt->size) {
2036 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2037 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2038 ist->showed_multi_packet_warning = 1;
2041 switch(ist->st->codec->codec_type) {
2042 case AVMEDIA_TYPE_AUDIO:
2043 ret = transcode_audio (ist, &avpkt, &got_output);
2045 case AVMEDIA_TYPE_VIDEO:
2046 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
2048 case AVMEDIA_TYPE_SUBTITLE:
2049 ret = transcode_subtitles(ist, &avpkt, &got_output);
2059 avpkt.pts= AV_NOPTS_VALUE;
2061 // touch data and size only if not EOF
2063 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2073 /* handle stream copy */
2074 if (!ist->decoding_needed) {
2075 rate_emu_sleep(ist);
2076 ist->pts = ist->next_pts;
2077 switch (ist->st->codec->codec_type) {
2078 case AVMEDIA_TYPE_AUDIO:
2079 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2080 ist->st->codec->sample_rate;
2082 case AVMEDIA_TYPE_VIDEO:
2083 if (pkt->duration) {
2084 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2085 } else if(ist->st->codec->time_base.num != 0) {
2086 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2087 ist->next_pts += ((int64_t)AV_TIME_BASE *
2088 ist->st->codec->time_base.num * ticks) /
2089 ist->st->codec->time_base.den;
2094 for (i = 0; pkt && i < nb_ostreams; i++) {
2095 OutputStream *ost = &ost_table[i];
2097 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2100 do_streamcopy(ist, ost, pkt);
2106 static void print_sdp(OutputFile *output_files, int n)
2110 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
2114 for (i = 0; i < n; i++)
2115 avc[i] = output_files[i].ctx;
2117 av_sdp_create(avc, n, sdp, sizeof(sdp));
2118 printf("SDP:\n%s\n", sdp);
2123 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2124 char *error, int error_len)
2126 InputStream *ist = &input_streams[ist_index];
2127 if (ist->decoding_needed) {
2128 AVCodec *codec = ist->dec;
2130 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2131 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2132 return AVERROR(EINVAL);
2134 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2135 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2136 ist->file_index, ist->st->index);
2137 return AVERROR(EINVAL);
2139 assert_codec_experimental(ist->st->codec, 0);
2140 assert_avoptions(ist->opts);
2143 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;
2144 ist->next_pts = AV_NOPTS_VALUE;
2150 static int transcode_init(OutputFile *output_files, int nb_output_files,
2151 InputFile *input_files, int nb_input_files)
2153 int ret = 0, i, j, k;
2154 AVFormatContext *oc;
2155 AVCodecContext *codec, *icodec;
2161 /* init framerate emulation */
2162 for (i = 0; i < nb_input_files; i++) {
2163 InputFile *ifile = &input_files[i];
2164 if (ifile->rate_emu)
2165 for (j = 0; j < ifile->nb_streams; j++)
2166 input_streams[j + ifile->ist_index].start = av_gettime();
2169 /* output stream init */
2170 for (i = 0; i < nb_output_files; i++) {
2171 oc = output_files[i].ctx;
2172 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2173 av_dump_format(oc, i, oc->filename, 1);
2174 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2175 return AVERROR(EINVAL);
2179 /* for each output stream, we compute the right encoding parameters */
2180 for (i = 0; i < nb_output_streams; i++) {
2181 ost = &output_streams[i];
2182 oc = output_files[ost->file_index].ctx;
2183 ist = &input_streams[ost->source_index];
2185 if (ost->attachment_filename)
2188 codec = ost->st->codec;
2189 icodec = ist->st->codec;
2191 ost->st->disposition = ist->st->disposition;
2192 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2193 codec->chroma_sample_location = icodec->chroma_sample_location;
2195 if (ost->stream_copy) {
2196 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2198 if (extra_size > INT_MAX) {
2199 return AVERROR(EINVAL);
2202 /* if stream_copy is selected, no need to decode or encode */
2203 codec->codec_id = icodec->codec_id;
2204 codec->codec_type = icodec->codec_type;
2206 if (!codec->codec_tag) {
2207 if (!oc->oformat->codec_tag ||
2208 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2209 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2210 codec->codec_tag = icodec->codec_tag;
2213 codec->bit_rate = icodec->bit_rate;
2214 codec->rc_max_rate = icodec->rc_max_rate;
2215 codec->rc_buffer_size = icodec->rc_buffer_size;
2216 codec->extradata = av_mallocz(extra_size);
2217 if (!codec->extradata) {
2218 return AVERROR(ENOMEM);
2220 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2221 codec->extradata_size= icodec->extradata_size;
2223 codec->time_base = ist->st->time_base;
2224 if(!strcmp(oc->oformat->name, "avi")) {
2225 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2226 && av_q2d(ist->st->time_base) < 1.0/500
2228 codec->time_base = icodec->time_base;
2229 codec->time_base.num *= icodec->ticks_per_frame;
2230 codec->time_base.den *= 2;
2232 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2233 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2234 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2236 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2237 && av_q2d(ist->st->time_base) < 1.0/500
2239 codec->time_base = icodec->time_base;
2240 codec->time_base.num *= icodec->ticks_per_frame;
2243 av_reduce(&codec->time_base.num, &codec->time_base.den,
2244 codec->time_base.num, codec->time_base.den, INT_MAX);
2246 switch(codec->codec_type) {
2247 case AVMEDIA_TYPE_AUDIO:
2248 if(audio_volume != 256) {
2249 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2252 codec->channel_layout = icodec->channel_layout;
2253 codec->sample_rate = icodec->sample_rate;
2254 codec->channels = icodec->channels;
2255 codec->frame_size = icodec->frame_size;
2256 codec->audio_service_type = icodec->audio_service_type;
2257 codec->block_align = icodec->block_align;
2259 case AVMEDIA_TYPE_VIDEO:
2260 codec->pix_fmt = icodec->pix_fmt;
2261 codec->width = icodec->width;
2262 codec->height = icodec->height;
2263 codec->has_b_frames = icodec->has_b_frames;
2264 if (!codec->sample_aspect_ratio.num) {
2265 codec->sample_aspect_ratio =
2266 ost->st->sample_aspect_ratio =
2267 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2268 ist->st->codec->sample_aspect_ratio.num ?
2269 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2271 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2273 case AVMEDIA_TYPE_SUBTITLE:
2274 codec->width = icodec->width;
2275 codec->height = icodec->height;
2277 case AVMEDIA_TYPE_DATA:
2278 case AVMEDIA_TYPE_ATTACHMENT:
2285 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2287 ist->decoding_needed = 1;
2288 ost->encoding_needed = 1;
2290 switch(codec->codec_type) {
2291 case AVMEDIA_TYPE_AUDIO:
2292 ost->fifo = av_fifo_alloc(1024);
2294 return AVERROR(ENOMEM);
2296 if (!codec->sample_rate)
2297 codec->sample_rate = icodec->sample_rate;
2298 choose_sample_rate(ost->st, ost->enc);
2299 codec->time_base = (AVRational){1, codec->sample_rate};
2301 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2302 codec->sample_fmt = icodec->sample_fmt;
2303 choose_sample_fmt(ost->st, ost->enc);
2305 if (ost->audio_channels_mapped) {
2306 /* the requested output channel is set to the number of
2307 * -map_channel only if no -ac are specified */
2308 if (!codec->channels) {
2309 codec->channels = ost->audio_channels_mapped;
2310 codec->channel_layout = av_get_default_channel_layout(codec->channels);
2311 if (!codec->channel_layout) {
2312 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2316 /* fill unused channel mapping with -1 (which means a muted
2317 * channel in case the number of output channels is bigger
2318 * than the number of mapped channel) */
2319 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2320 ost->audio_channels_map[j] = -1;
2321 } else if (!codec->channels) {
2322 codec->channels = icodec->channels;
2323 codec->channel_layout = icodec->channel_layout;
2325 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2326 codec->channel_layout = 0;
2328 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2329 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2330 || codec->channel_layout != icodec->channel_layout;
2331 icodec->request_channels = codec->channels;
2332 ost->resample_sample_fmt = icodec->sample_fmt;
2333 ost->resample_sample_rate = icodec->sample_rate;
2334 ost->resample_channels = icodec->channels;
2336 case AVMEDIA_TYPE_VIDEO:
2337 if (codec->pix_fmt == PIX_FMT_NONE)
2338 codec->pix_fmt = icodec->pix_fmt;
2339 choose_pixel_fmt(ost->st, ost->enc);
2341 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2342 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2346 if (!codec->width || !codec->height) {
2347 codec->width = icodec->width;
2348 codec->height = icodec->height;
2351 ost->video_resample = codec->width != icodec->width ||
2352 codec->height != icodec->height ||
2353 codec->pix_fmt != icodec->pix_fmt;
2354 if (ost->video_resample) {
2355 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2358 ost->resample_height = icodec->height;
2359 ost->resample_width = icodec->width;
2360 ost->resample_pix_fmt = icodec->pix_fmt;
2362 if (!ost->frame_rate.num)
2363 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2364 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2365 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2366 ost->frame_rate = ost->enc->supported_framerates[idx];
2368 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2369 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2370 && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2371 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2372 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2374 for (j = 0; j < ost->forced_kf_count; j++)
2375 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2380 if (configure_video_filters(ist, ost)) {
2381 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2386 case AVMEDIA_TYPE_SUBTITLE:
2393 if (codec->codec_id != CODEC_ID_H264 &&
2394 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2395 char logfilename[1024];
2398 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2399 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2401 if (codec->flags & CODEC_FLAG_PASS2) {
2403 size_t logbuffer_size;
2404 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2405 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2409 codec->stats_in = logbuffer;
2411 if (codec->flags & CODEC_FLAG_PASS1) {
2412 f = fopen(logfilename, "wb");
2414 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2415 logfilename, strerror(errno));
2422 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2423 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2424 int size = codec->width * codec->height;
2425 bit_buffer_size = FFMAX(bit_buffer_size, 7*size + 10000);
2430 bit_buffer = av_malloc(bit_buffer_size);
2432 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2434 return AVERROR(ENOMEM);
2437 /* open each encoder */
2438 for (i = 0; i < nb_output_streams; i++) {
2439 ost = &output_streams[i];
2440 if (ost->encoding_needed) {
2441 AVCodec *codec = ost->enc;
2442 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2444 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2445 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2446 ret = AVERROR(EINVAL);
2449 if (dec->subtitle_header) {
2450 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2451 if (!ost->st->codec->subtitle_header) {
2452 ret = AVERROR(ENOMEM);
2455 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2456 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2458 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2459 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2460 ost->file_index, ost->index);
2461 ret = AVERROR(EINVAL);
2464 assert_codec_experimental(ost->st->codec, 1);
2465 assert_avoptions(ost->opts);
2466 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2467 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2468 " It takes bits/s as argument, not kbits/s\n");
2469 extra_size += ost->st->codec->extradata_size;
2471 if (ost->st->codec->me_threshold)
2472 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2476 /* init input streams */
2477 for (i = 0; i < nb_input_streams; i++)
2478 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2481 /* discard unused programs */
2482 for (i = 0; i < nb_input_files; i++) {
2483 InputFile *ifile = &input_files[i];
2484 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2485 AVProgram *p = ifile->ctx->programs[j];
2486 int discard = AVDISCARD_ALL;
2488 for (k = 0; k < p->nb_stream_indexes; k++)
2489 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2490 discard = AVDISCARD_DEFAULT;
2493 p->discard = discard;
2497 /* open files and write file headers */
2498 for (i = 0; i < nb_output_files; i++) {
2499 oc = output_files[i].ctx;
2500 oc->interrupt_callback = int_cb;
2501 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2502 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2503 ret = AVERROR(EINVAL);
2506 // assert_avoptions(output_files[i].opts);
2507 if (strcmp(oc->oformat->name, "rtp")) {
2513 /* dump the file output parameters - cannot be done before in case
2515 for (i = 0; i < nb_output_files; i++) {
2516 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2519 /* dump the stream mapping */
2520 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2521 for (i = 0; i < nb_output_streams; i++) {
2522 ost = &output_streams[i];
2524 if (ost->attachment_filename) {
2525 /* an attached file */
2526 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2527 ost->attachment_filename, ost->file_index, ost->index);
2530 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2531 input_streams[ost->source_index].file_index,
2532 input_streams[ost->source_index].st->index,
2535 if (ost->audio_channels_mapped) {
2536 av_log(NULL, AV_LOG_INFO, " [ch:");
2537 for (j = 0; j < ost->audio_channels_mapped; j++)
2538 if (ost->audio_channels_map[j] == -1)
2539 av_log(NULL, AV_LOG_INFO, " M");
2541 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2542 av_log(NULL, AV_LOG_INFO, "]");
2544 if (ost->sync_ist != &input_streams[ost->source_index])
2545 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2546 ost->sync_ist->file_index,
2547 ost->sync_ist->st->index);
2548 if (ost->stream_copy)
2549 av_log(NULL, AV_LOG_INFO, " (copy)");
2551 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2552 input_streams[ost->source_index].dec->name : "?",
2553 ost->enc ? ost->enc->name : "?");
2554 av_log(NULL, AV_LOG_INFO, "\n");
2558 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2563 print_sdp(output_files, nb_output_files);
2570 * The following code is the main loop of the file converter
2572 static int transcode(OutputFile *output_files, int nb_output_files,
2573 InputFile *input_files, int nb_input_files)
2576 AVFormatContext *is, *os;
2580 int no_packet_count=0;
2581 int64_t timer_start;
2584 if (!(no_packet = av_mallocz(nb_input_files)))
2587 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2592 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2595 timer_start = av_gettime();
2597 for(; received_sigterm == 0;) {
2598 int file_index, ist_index;
2602 int64_t cur_time= av_gettime();
2604 ipts_min= INT64_MAX;
2606 /* if 'q' pressed, exits */
2608 static int64_t last_time;
2609 if (received_nb_signals)
2611 /* read_key() returns 0 on EOF */
2612 if(cur_time - last_time >= 100000 && !run_as_daemon){
2614 last_time = cur_time;
2619 if (key == '+') av_log_set_level(av_log_get_level()+10);
2620 if (key == '-') av_log_set_level(av_log_get_level()-10);
2621 if (key == 's') qp_hist ^= 1;
2624 do_hex_dump = do_pkt_dump = 0;
2625 } else if(do_pkt_dump){
2629 av_log_set_level(AV_LOG_DEBUG);
2632 if (key == 'c' || key == 'C'){
2633 char buf[4096], target[64], command[256], arg[256] = {0};
2636 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2638 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2643 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2644 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2645 target, time, command, arg);
2646 for (i = 0; i < nb_output_streams; i++) {
2647 ost = &output_streams[i];
2650 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2651 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2652 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2654 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2659 av_log(NULL, AV_LOG_ERROR,
2660 "Parse error, at least 3 arguments were expected, "
2661 "only %d given in string '%s'\n", n, buf);
2665 if (key == 'd' || key == 'D'){
2668 debug = input_streams[0].st->codec->debug<<1;
2669 if(!debug) debug = 1;
2670 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2673 if(scanf("%d", &debug)!=1)
2674 fprintf(stderr,"error parsing debug value\n");
2675 for(i=0;i<nb_input_streams;i++) {
2676 input_streams[i].st->codec->debug = debug;
2678 for(i=0;i<nb_output_streams;i++) {
2679 ost = &output_streams[i];
2680 ost->st->codec->debug = debug;
2682 if(debug) av_log_set_level(AV_LOG_DEBUG);
2683 fprintf(stderr,"debug=%d\n", debug);
2686 fprintf(stderr, "key function\n"
2687 "? show this help\n"
2688 "+ increase verbosity\n"
2689 "- decrease verbosity\n"
2690 "c Send command to filtergraph\n"
2691 "D cycle through available debug modes\n"
2692 "h dump packets/hex press to cycle through the 3 states\n"
2694 "s Show QP histogram\n"
2699 /* select the stream that we must read now by looking at the
2700 smallest output pts */
2702 for (i = 0; i < nb_output_streams; i++) {
2706 ost = &output_streams[i];
2707 of = &output_files[ost->file_index];
2708 os = output_files[ost->file_index].ctx;
2709 ist = &input_streams[ost->source_index];
2710 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2711 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2713 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2715 if (!input_files[ist->file_index].eof_reached){
2716 if(ipts < ipts_min) {
2718 if(input_sync ) file_index = ist->file_index;
2720 if(opts < opts_min) {
2722 if(!input_sync) file_index = ist->file_index;
2725 if (ost->frame_number >= ost->max_frames) {
2727 for (j = 0; j < of->ctx->nb_streams; j++)
2728 output_streams[of->ost_index + j].is_past_recording_time = 1;
2732 /* if none, if is finished */
2733 if (file_index < 0) {
2734 if(no_packet_count){
2736 memset(no_packet, 0, nb_input_files);
2743 /* read a frame from it and output it in the fifo */
2744 is = input_files[file_index].ctx;
2745 ret= av_read_frame(is, &pkt);
2746 if(ret == AVERROR(EAGAIN)){
2747 no_packet[file_index]=1;
2752 input_files[file_index].eof_reached = 1;
2760 memset(no_packet, 0, nb_input_files);
2763 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2764 is->streams[pkt.stream_index]);
2766 /* the following test is needed in case new streams appear
2767 dynamically in stream : we ignore them */
2768 if (pkt.stream_index >= input_files[file_index].nb_streams)
2769 goto discard_packet;
2770 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2771 ist = &input_streams[ist_index];
2773 goto discard_packet;
2775 if (pkt.dts != AV_NOPTS_VALUE)
2776 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2777 if (pkt.pts != AV_NOPTS_VALUE)
2778 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2780 if(pkt.pts != AV_NOPTS_VALUE)
2781 pkt.pts *= ist->ts_scale;
2782 if(pkt.dts != AV_NOPTS_VALUE)
2783 pkt.dts *= ist->ts_scale;
2785 // 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);
2786 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2787 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2788 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2789 int64_t delta= pkt_dts - ist->next_pts;
2790 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2791 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2792 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2793 pkt_dts+1<ist->pts)&& !copy_ts){
2794 input_files[ist->file_index].ts_offset -= delta;
2795 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2796 delta, input_files[ist->file_index].ts_offset);
2797 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2798 if(pkt.pts != AV_NOPTS_VALUE)
2799 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2803 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2804 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2806 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2807 ist->file_index, ist->st->index);
2810 av_free_packet(&pkt);
2815 av_free_packet(&pkt);
2817 /* dump report by using the output first video and audio streams */
2818 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
2821 /* at the end of stream, we must flush the decoder buffers */
2822 for (i = 0; i < nb_input_streams; i++) {
2823 ist = &input_streams[i];
2824 if (ist->decoding_needed) {
2825 output_packet(ist, output_streams, nb_output_streams, NULL);
2828 flush_encoders(output_streams, nb_output_streams);
2832 /* write the trailer if needed and close file */
2833 for(i=0;i<nb_output_files;i++) {
2834 os = output_files[i].ctx;
2835 av_write_trailer(os);
2838 /* dump report by using the first video and audio streams */
2839 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
2841 /* close each encoder */
2842 for (i = 0; i < nb_output_streams; i++) {
2843 ost = &output_streams[i];
2844 if (ost->encoding_needed) {
2845 av_freep(&ost->st->codec->stats_in);
2846 avcodec_close(ost->st->codec);
2849 avfilter_graph_free(&ost->graph);
2853 /* close each decoder */
2854 for (i = 0; i < nb_input_streams; i++) {
2855 ist = &input_streams[i];
2856 if (ist->decoding_needed) {
2857 avcodec_close(ist->st->codec);
2865 av_freep(&bit_buffer);
2866 av_freep(&no_packet);
2868 if (output_streams) {
2869 for (i = 0; i < nb_output_streams; i++) {
2870 ost = &output_streams[i];
2872 if (ost->stream_copy)
2873 av_freep(&ost->st->codec->extradata);
2875 fclose(ost->logfile);
2876 ost->logfile = NULL;
2878 av_fifo_free(ost->fifo); /* works even if fifo is not
2879 initialized but set to zero */
2880 av_freep(&ost->st->codec->subtitle_header);
2881 av_free(ost->resample_frame.data[0]);
2882 av_free(ost->forced_kf_pts);
2883 if (ost->video_resample)
2884 sws_freeContext(ost->img_resample_ctx);
2885 swr_free(&ost->swr);
2886 av_dict_free(&ost->opts);
2893 static int opt_frame_crop(const char *opt, const char *arg)
2895 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2896 return AVERROR(EINVAL);
2899 static int opt_pad(const char *opt, const char *arg)
2901 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2905 static double parse_frame_aspect_ratio(const char *arg)
2912 p = strchr(arg, ':');
2914 x = strtol(arg, &end, 10);
2916 y = strtol(end+1, &end, 10);
2918 ar = (double)x / (double)y;
2920 ar = strtod(arg, NULL);
2923 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2929 static int opt_video_channel(const char *opt, const char *arg)
2931 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2932 return opt_default("channel", arg);
2935 static int opt_video_standard(const char *opt, const char *arg)
2937 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2938 return opt_default("standard", arg);
2941 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2943 audio_codec_name = arg;
2944 return parse_option(o, "codec:a", arg, options);
2947 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2949 video_codec_name = arg;
2950 return parse_option(o, "codec:v", arg, options);
2953 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2955 subtitle_codec_name = arg;
2956 return parse_option(o, "codec:s", arg, options);
2959 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2961 return parse_option(o, "codec:d", arg, options);
2964 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2966 StreamMap *m = NULL;
2967 int i, negative = 0, file_idx;
2968 int sync_file_idx = -1, sync_stream_idx;
2976 map = av_strdup(arg);
2978 /* parse sync stream first, just pick first matching stream */
2979 if (sync = strchr(map, ',')) {
2981 sync_file_idx = strtol(sync + 1, &sync, 0);
2982 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2983 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2988 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2989 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2990 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2991 sync_stream_idx = i;
2994 if (i == input_files[sync_file_idx].nb_streams) {
2995 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2996 "match any streams.\n", arg);
3002 file_idx = strtol(map, &p, 0);
3003 if (file_idx >= nb_input_files || file_idx < 0) {
3004 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3008 /* disable some already defined maps */
3009 for (i = 0; i < o->nb_stream_maps; i++) {
3010 m = &o->stream_maps[i];
3011 if (file_idx == m->file_index &&
3012 check_stream_specifier(input_files[m->file_index].ctx,
3013 input_files[m->file_index].ctx->streams[m->stream_index],
3014 *p == ':' ? p + 1 : p) > 0)
3018 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3019 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3020 *p == ':' ? p + 1 : p) <= 0)
3022 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3023 &o->nb_stream_maps, o->nb_stream_maps + 1);
3024 m = &o->stream_maps[o->nb_stream_maps - 1];
3026 m->file_index = file_idx;
3027 m->stream_index = i;
3029 if (sync_file_idx >= 0) {
3030 m->sync_file_index = sync_file_idx;
3031 m->sync_stream_index = sync_stream_idx;
3033 m->sync_file_index = file_idx;
3034 m->sync_stream_index = i;
3039 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3047 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3049 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3050 &o->nb_attachments, o->nb_attachments + 1);
3051 o->attachments[o->nb_attachments - 1] = arg;
3055 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3061 o->audio_channel_maps =
3062 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3063 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3064 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3066 /* muted channel syntax */
3067 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3068 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3069 m->file_idx = m->stream_idx = -1;
3071 m->ofile_idx = m->ostream_idx = -1;
3076 n = sscanf(arg, "%d.%d.%d:%d.%d",
3077 &m->file_idx, &m->stream_idx, &m->channel_idx,
3078 &m->ofile_idx, &m->ostream_idx);
3080 if (n != 3 && n != 5) {
3081 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3082 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3086 if (n != 5) // only file.stream.channel specified
3087 m->ofile_idx = m->ostream_idx = -1;
3090 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3091 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3095 if (m->stream_idx < 0 ||
3096 m->stream_idx >= input_files[m->file_idx].nb_streams) {
3097 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3098 m->file_idx, m->stream_idx);
3101 st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3102 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3103 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3104 m->file_idx, m->stream_idx);
3107 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3108 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3109 m->file_idx, m->stream_idx, m->channel_idx);
3116 * Parse a metadata specifier in arg.
3117 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3118 * @param index for type c/p, chapter/program index is written here
3119 * @param stream_spec for type s, the stream specifier is written here
3121 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3129 if (*(++arg) && *arg != ':') {
3130 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3133 *stream_spec = *arg == ':' ? arg + 1 : "";
3137 if (*(++arg) == ':')
3138 *index = strtol(++arg, NULL, 0);
3141 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3148 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3150 AVDictionary **meta_in = NULL;
3151 AVDictionary **meta_out;
3153 char type_in, type_out;
3154 const char *istream_spec = NULL, *ostream_spec = NULL;
3155 int idx_in = 0, idx_out = 0;
3157 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3158 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3160 if (type_in == 'g' || type_out == 'g')
3161 o->metadata_global_manual = 1;
3162 if (type_in == 's' || type_out == 's')
3163 o->metadata_streams_manual = 1;
3164 if (type_in == 'c' || type_out == 'c')
3165 o->metadata_chapters_manual = 1;
3167 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3168 if ((index) < 0 || (index) >= (nb_elems)) {\
3169 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3174 #define SET_DICT(type, meta, context, index)\
3177 meta = &context->metadata;\
3180 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3181 meta = &context->chapters[index]->metadata;\
3184 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3185 meta = &context->programs[index]->metadata;\
3189 SET_DICT(type_in, meta_in, ic, idx_in);
3190 SET_DICT(type_out, meta_out, oc, idx_out);
3192 /* for input streams choose first matching stream */
3193 if (type_in == 's') {
3194 for (i = 0; i < ic->nb_streams; i++) {
3195 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3196 meta_in = &ic->streams[i]->metadata;
3202 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3207 if (type_out == 's') {
3208 for (i = 0; i < oc->nb_streams; i++) {
3209 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3210 meta_out = &oc->streams[i]->metadata;
3211 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3216 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3221 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3224 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3225 struct tm time = *gmtime((time_t*)&recording_timestamp);
3226 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3227 parse_option(o, "metadata", buf, options);
3229 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3230 "tag instead.\n", opt);
3234 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3236 const char *codec_string = encoder ? "encoder" : "decoder";
3240 avcodec_find_encoder_by_name(name) :
3241 avcodec_find_decoder_by_name(name);
3243 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3246 if(codec->type != type) {
3247 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3253 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3255 char *codec_name = NULL;
3257 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3259 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3260 st->codec->codec_id = codec->id;
3263 return avcodec_find_decoder(st->codec->codec_id);
3267 * Add all the streams from the given input file to the global
3268 * list of input streams.
3270 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3272 int i, rfps, rfps_base;
3273 char *next, *codec_tag = NULL;
3275 for (i = 0; i < ic->nb_streams; i++) {
3276 AVStream *st = ic->streams[i];
3277 AVCodecContext *dec = st->codec;
3280 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3281 ist = &input_streams[nb_input_streams - 1];
3283 ist->file_index = nb_input_files;
3285 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3287 ist->ts_scale = 1.0;
3288 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3290 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3292 uint32_t tag = strtol(codec_tag, &next, 0);
3294 tag = AV_RL32(codec_tag);
3295 st->codec->codec_tag = tag;
3298 ist->dec = choose_decoder(o, ic, st);
3300 switch (dec->codec_type) {
3301 case AVMEDIA_TYPE_AUDIO:
3303 ist->dec = avcodec_find_decoder(dec->codec_id);
3304 if(o->audio_disable)
3305 st->discard= AVDISCARD_ALL;
3307 case AVMEDIA_TYPE_VIDEO:
3309 ist->dec = avcodec_find_decoder(dec->codec_id);
3310 rfps = ic->streams[i]->r_frame_rate.num;
3311 rfps_base = ic->streams[i]->r_frame_rate.den;
3313 dec->flags |= CODEC_FLAG_EMU_EDGE;
3316 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3318 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",
3319 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3320 (float)rfps / rfps_base, rfps, rfps_base);
3323 if (o->video_disable)
3324 st->discard= AVDISCARD_ALL;
3325 else if(video_discard)
3326 st->discard= video_discard;
3328 case AVMEDIA_TYPE_DATA:
3329 if (o->data_disable)
3330 st->discard= AVDISCARD_ALL;
3332 case AVMEDIA_TYPE_SUBTITLE:
3334 ist->dec = avcodec_find_decoder(dec->codec_id);
3335 if(o->subtitle_disable)
3336 st->discard = AVDISCARD_ALL;
3338 case AVMEDIA_TYPE_ATTACHMENT:
3339 case AVMEDIA_TYPE_UNKNOWN:
3347 static void assert_file_overwrite(const char *filename)
3349 if ((!file_overwrite || no_file_overwrite) &&
3350 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3351 av_strstart(filename, "file:", NULL))) {
3352 if (avio_check(filename, 0) == 0) {
3353 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3354 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3357 signal(SIGINT, SIG_DFL);
3358 if (!read_yesno()) {
3359 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3365 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3372 static void dump_attachment(AVStream *st, const char *filename)
3375 AVIOContext *out = NULL;
3376 AVDictionaryEntry *e;
3378 if (!st->codec->extradata_size) {
3379 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3380 nb_input_files - 1, st->index);
3383 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3384 filename = e->value;
3386 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3387 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3391 assert_file_overwrite(filename);
3393 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3394 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3399 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3404 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3406 AVFormatContext *ic;
3407 AVInputFormat *file_iformat = NULL;
3411 AVDictionary **opts;
3412 int orig_nb_streams; // number of streams before avformat_find_stream_info
3415 if (!(file_iformat = av_find_input_format(o->format))) {
3416 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3421 if (!strcmp(filename, "-"))
3424 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3425 !strcmp(filename, "/dev/stdin");
3427 /* get default parameters from command line */
3428 ic = avformat_alloc_context();
3430 print_error(filename, AVERROR(ENOMEM));
3433 if (o->nb_audio_sample_rate) {
3434 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3435 av_dict_set(&format_opts, "sample_rate", buf, 0);
3437 if (o->nb_audio_channels) {
3438 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3439 av_dict_set(&format_opts, "channels", buf, 0);
3441 if (o->nb_frame_rates) {
3442 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3444 if (o->nb_frame_sizes) {
3445 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3447 if (o->nb_frame_pix_fmts)
3448 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3450 ic->video_codec_id = video_codec_name ?
3451 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3452 ic->audio_codec_id = audio_codec_name ?
3453 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3454 ic->subtitle_codec_id= subtitle_codec_name ?
3455 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3456 ic->flags |= AVFMT_FLAG_NONBLOCK;
3457 ic->interrupt_callback = int_cb;
3460 av_log(NULL, AV_LOG_WARNING,
3461 "-loop_input is deprecated, use -loop 1\n"
3462 "Note, both loop options only work with -f image2\n"
3464 ic->loop_input = loop_input;
3467 /* open the input file with generic avformat function */
3468 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3470 print_error(filename, err);
3473 assert_avoptions(format_opts);
3475 /* apply forced codec ids */
3476 for (i = 0; i < ic->nb_streams; i++)
3477 choose_decoder(o, ic, ic->streams[i]);
3479 /* Set AVCodecContext options for avformat_find_stream_info */
3480 opts = setup_find_stream_info_opts(ic, codec_opts);
3481 orig_nb_streams = ic->nb_streams;
3483 /* If not enough info to get the stream parameters, we decode the
3484 first frames to get it. (used in mpeg case for example) */
3485 ret = avformat_find_stream_info(ic, opts);
3487 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3488 avformat_close_input(&ic);
3492 timestamp = o->start_time;
3493 /* add the stream start time */
3494 if (ic->start_time != AV_NOPTS_VALUE)
3495 timestamp += ic->start_time;
3497 /* if seeking requested, we execute it */
3498 if (o->start_time != 0) {
3499 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3501 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3502 filename, (double)timestamp / AV_TIME_BASE);
3506 /* update the current parameters so that they match the one of the input stream */
3507 add_input_streams(o, ic);
3509 /* dump the file content */
3510 av_dump_format(ic, nb_input_files, filename, 0);
3512 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3513 input_files[nb_input_files - 1].ctx = ic;
3514 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3515 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3516 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3517 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3519 for (i = 0; i < o->nb_dump_attachment; i++) {
3522 for (j = 0; j < ic->nb_streams; j++) {
3523 AVStream *st = ic->streams[j];
3525 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3526 dump_attachment(st, o->dump_attachment[i].u.str);
3530 for (i = 0; i < orig_nb_streams; i++)
3531 av_dict_free(&opts[i]);
3534 reset_options(o, 1);
3538 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3543 for (p = kf; *p; p++)
3546 ost->forced_kf_count = n;
3547 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3548 if (!ost->forced_kf_pts) {
3549 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3552 for (i = 0; i < n; i++) {
3553 p = i ? strchr(p, ',') + 1 : kf;
3554 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3558 static uint8_t *get_line(AVIOContext *s)
3564 if (avio_open_dyn_buf(&line) < 0) {
3565 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3569 while ((c = avio_r8(s)) && c != '\n')
3572 avio_close_dyn_buf(line, &buf);
3577 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3580 char filename[1000];
3581 const char *base[3] = { getenv("AVCONV_DATADIR"),
3586 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3590 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3591 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3592 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3595 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3596 i != 1 ? "" : "/.avconv", preset_name);
3597 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3603 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3605 char *codec_name = NULL;
3607 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3609 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3610 NULL, ost->st->codec->codec_type);
3611 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3612 } else if (!strcmp(codec_name, "copy"))
3613 ost->stream_copy = 1;
3615 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3616 ost->st->codec->codec_id = ost->enc->id;
3620 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3623 AVStream *st = avformat_new_stream(oc, NULL);
3624 int idx = oc->nb_streams - 1, ret = 0;
3625 char *bsf = NULL, *next, *codec_tag = NULL;
3626 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3628 char *buf = NULL, *arg = NULL, *preset = NULL;
3629 AVIOContext *s = NULL;
3632 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3636 if (oc->nb_streams - 1 < o->nb_streamid_map)
3637 st->id = o->streamid_map[oc->nb_streams - 1];
3639 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3640 nb_output_streams + 1);
3641 ost = &output_streams[nb_output_streams - 1];
3642 ost->file_index = nb_output_files;
3645 st->codec->codec_type = type;
3646 choose_encoder(o, oc, ost);
3648 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3651 avcodec_get_context_defaults3(st->codec, ost->enc);
3652 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3654 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3655 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3658 if (!buf[0] || buf[0] == '#') {
3662 if (!(arg = strchr(buf, '='))) {
3663 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3667 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3669 } while (!s->eof_reached);
3673 av_log(NULL, AV_LOG_FATAL,
3674 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3675 preset, ost->file_index, ost->index);
3679 ost->max_frames = INT64_MAX;
3680 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3682 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3684 if (next = strchr(bsf, ','))
3686 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3687 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3691 bsfc_prev->next = bsfc;
3693 ost->bitstream_filters = bsfc;
3699 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3701 uint32_t tag = strtol(codec_tag, &next, 0);
3703 tag = AV_RL32(codec_tag);
3704 st->codec->codec_tag = tag;
3707 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3708 if (qscale >= 0 || same_quant) {
3709 st->codec->flags |= CODEC_FLAG_QSCALE;
3710 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3713 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3714 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3716 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3720 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3723 const char *p = str;
3730 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3737 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3741 AVCodecContext *video_enc;
3743 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3745 video_enc = st->codec;
3747 if (!ost->stream_copy) {
3748 const char *p = NULL;
3749 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3750 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3751 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3754 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3755 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3756 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3760 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3761 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3762 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3766 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3767 if (frame_aspect_ratio)
3768 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3770 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3771 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3772 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3773 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3776 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3779 video_enc->gop_size = 0;
3780 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3782 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3783 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3786 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3788 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3790 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3791 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3794 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3797 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3800 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3802 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3805 /* FIXME realloc failure */
3806 video_enc->rc_override=
3807 av_realloc(video_enc->rc_override,
3808 sizeof(RcOverride)*(i+1));
3809 video_enc->rc_override[i].start_frame= start;
3810 video_enc->rc_override[i].end_frame = end;
3812 video_enc->rc_override[i].qscale= q;
3813 video_enc->rc_override[i].quality_factor= 1.0;
3816 video_enc->rc_override[i].qscale= 0;
3817 video_enc->rc_override[i].quality_factor= -q/100.0;
3822 video_enc->rc_override_count=i;
3823 if (!video_enc->rc_initial_buffer_occupancy)
3824 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3825 video_enc->intra_dc_precision= intra_dc_precision - 8;
3828 video_enc->flags|= CODEC_FLAG_PSNR;
3833 video_enc->flags |= CODEC_FLAG_PASS1;
3836 video_enc->flags |= CODEC_FLAG_PASS2;
3840 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3841 if (forced_key_frames)
3842 parse_forced_key_frames(forced_key_frames, ost);
3844 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3846 ost->top_field_first = -1;
3847 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3849 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3852 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3854 ost->avfilter = av_strdup(filters);
3861 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3866 AVCodecContext *audio_enc;
3868 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3871 audio_enc = st->codec;
3872 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3874 if (!ost->stream_copy) {
3875 char *sample_fmt = NULL;
3877 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3879 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3881 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3882 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3886 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3888 ost->rematrix_volume=1.0;
3889 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3892 /* check for channel mapping for this audio stream */
3893 for (n = 0; n < o->nb_audio_channel_maps; n++) {
3894 AudioChannelMap *map = &o->audio_channel_maps[n];
3895 InputStream *ist = &input_streams[ost->source_index];
3896 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
3897 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
3898 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
3899 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
3900 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
3902 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
3903 ost->file_index, ost->st->index);
3910 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3914 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3915 if (!ost->stream_copy) {
3916 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3923 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3925 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3926 ost->stream_copy = 1;
3930 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3934 AVCodecContext *subtitle_enc;
3936 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3938 subtitle_enc = st->codec;
3940 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3945 /* arg format is "output-stream-index:streamid-value". */
3946 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3952 av_strlcpy(idx_str, arg, sizeof(idx_str));
3953 p = strchr(idx_str, ':');
3955 av_log(NULL, AV_LOG_FATAL,
3956 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3961 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3962 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3963 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3967 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3969 AVFormatContext *is = ifile->ctx;
3970 AVFormatContext *os = ofile->ctx;
3973 for (i = 0; i < is->nb_chapters; i++) {
3974 AVChapter *in_ch = is->chapters[i], *out_ch;
3975 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3976 AV_TIME_BASE_Q, in_ch->time_base);
3977 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3978 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3981 if (in_ch->end < ts_off)
3983 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3986 out_ch = av_mallocz(sizeof(AVChapter));
3988 return AVERROR(ENOMEM);
3990 out_ch->id = in_ch->id;
3991 out_ch->time_base = in_ch->time_base;
3992 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3993 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3996 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3999 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4001 return AVERROR(ENOMEM);
4002 os->chapters[os->nb_chapters - 1] = out_ch;
4007 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4010 AVFormatContext *ic = avformat_alloc_context();
4012 ic->interrupt_callback = int_cb;
4013 err = avformat_open_input(&ic, filename, NULL, NULL);
4016 /* copy stream format */
4017 for(i=0;i<ic->nb_streams;i++) {
4021 AVCodecContext *avctx;
4023 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4024 ost = new_output_stream(o, s, codec->type);
4029 // FIXME: a more elegant solution is needed
4030 memcpy(st, ic->streams[i], sizeof(AVStream));
4031 st->info = av_malloc(sizeof(*st->info));
4032 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4034 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4036 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4037 choose_sample_fmt(st, codec);
4038 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4039 choose_pixel_fmt(st, codec);
4042 av_close_input_file(ic);
4046 static void opt_output_file(void *optctx, const char *filename)
4048 OptionsContext *o = optctx;
4049 AVFormatContext *oc;
4051 AVOutputFormat *file_oformat;
4055 if (!strcmp(filename, "-"))
4058 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4060 print_error(filename, err);
4063 file_oformat= oc->oformat;
4064 oc->interrupt_callback = int_cb;
4066 if (!strcmp(file_oformat->name, "ffm") &&
4067 av_strstart(filename, "http:", NULL)) {
4069 /* special case for files sent to ffserver: we get the stream
4070 parameters from ffserver */
4071 int err = read_ffserver_streams(o, oc, filename);
4073 print_error(filename, err);
4076 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4077 ost = &output_streams[j];
4078 for (i = 0; i < nb_input_streams; i++) {
4079 ist = &input_streams[i];
4080 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4082 ost->source_index= i;
4088 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));
4092 } else if (!o->nb_stream_maps) {
4093 /* pick the "best" stream of each type */
4094 #define NEW_STREAM(type, index)\
4096 ost = new_ ## type ## _stream(o, oc);\
4097 ost->source_index = index;\
4098 ost->sync_ist = &input_streams[index];\
4099 input_streams[index].discard = 0;\
4102 /* video: highest resolution */
4103 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4104 int area = 0, idx = -1;
4105 for (i = 0; i < nb_input_streams; i++) {
4106 ist = &input_streams[i];
4107 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4108 ist->st->codec->width * ist->st->codec->height > area) {
4109 area = ist->st->codec->width * ist->st->codec->height;
4113 NEW_STREAM(video, idx);
4116 /* audio: most channels */
4117 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4118 int channels = 0, idx = -1;
4119 for (i = 0; i < nb_input_streams; i++) {
4120 ist = &input_streams[i];
4121 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4122 ist->st->codec->channels > channels) {
4123 channels = ist->st->codec->channels;
4127 NEW_STREAM(audio, idx);
4130 /* subtitles: pick first */
4131 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4132 for (i = 0; i < nb_input_streams; i++)
4133 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4134 NEW_STREAM(subtitle, i);
4138 /* do something with data? */
4140 for (i = 0; i < o->nb_stream_maps; i++) {
4141 StreamMap *map = &o->stream_maps[i];
4146 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4147 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4149 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4151 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4153 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4156 switch (ist->st->codec->codec_type) {
4157 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4158 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4159 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4160 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4161 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4163 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4164 map->file_index, map->stream_index);
4168 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4169 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4170 map->sync_stream_index];
4175 /* handle attached files */
4176 for (i = 0; i < o->nb_attachments; i++) {
4178 uint8_t *attachment;
4182 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4183 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4187 if ((len = avio_size(pb)) <= 0) {
4188 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4192 if (!(attachment = av_malloc(len))) {
4193 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4197 avio_read(pb, attachment, len);
4199 ost = new_attachment_stream(o, oc);
4200 ost->stream_copy = 0;
4201 ost->source_index = -1;
4202 ost->attachment_filename = o->attachments[i];
4203 ost->st->codec->extradata = attachment;
4204 ost->st->codec->extradata_size = len;
4206 p = strrchr(o->attachments[i], '/');
4207 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4211 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4212 output_files[nb_output_files - 1].ctx = oc;
4213 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4214 output_files[nb_output_files - 1].recording_time = o->recording_time;
4215 output_files[nb_output_files - 1].start_time = o->start_time;
4216 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4217 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4219 /* check filename in case of an image number is expected */
4220 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4221 if (!av_filename_number_test(oc->filename)) {
4222 print_error(oc->filename, AVERROR(EINVAL));
4227 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4228 /* test if it already exists to avoid losing precious files */
4229 assert_file_overwrite(filename);
4232 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4233 &oc->interrupt_callback,
4234 &output_files[nb_output_files - 1].opts)) < 0) {
4235 print_error(filename, err);
4240 if (o->mux_preload) {
4242 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4243 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4245 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4247 if (loop_output >= 0) {
4248 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4249 oc->loop_output = loop_output;
4253 for (i = 0; i < o->nb_metadata_map; i++) {
4255 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4257 if (in_file_index < 0)
4259 if (in_file_index >= nb_input_files) {
4260 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4263 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4267 if (o->chapters_input_file >= nb_input_files) {
4268 if (o->chapters_input_file == INT_MAX) {
4269 /* copy chapters from the first input file that has them*/
4270 o->chapters_input_file = -1;
4271 for (i = 0; i < nb_input_files; i++)
4272 if (input_files[i].ctx->nb_chapters) {
4273 o->chapters_input_file = i;
4277 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4278 o->chapters_input_file);
4282 if (o->chapters_input_file >= 0)
4283 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4284 !o->metadata_chapters_manual);
4286 /* copy global metadata by default */
4287 if (!o->metadata_global_manual && nb_input_files){
4288 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4289 AV_DICT_DONT_OVERWRITE);
4290 if(o->recording_time != INT64_MAX)
4291 av_dict_set(&oc->metadata, "duration", NULL, 0);
4293 if (!o->metadata_streams_manual)
4294 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4296 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4298 ist = &input_streams[output_streams[i].source_index];
4299 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4302 /* process manually set metadata */
4303 for (i = 0; i < o->nb_metadata; i++) {
4306 const char *stream_spec;
4307 int index = 0, j, ret;
4309 val = strchr(o->metadata[i].u.str, '=');
4311 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4312 o->metadata[i].u.str);
4317 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4319 for (j = 0; j < oc->nb_streams; j++) {
4320 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4321 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4325 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4333 if (index < 0 || index >= oc->nb_chapters) {
4334 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4337 m = &oc->chapters[index]->metadata;
4340 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4343 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4347 reset_options(o, 0);
4350 /* same option as mencoder */
4351 static int opt_pass(const char *opt, const char *arg)
4353 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4357 static int64_t getutime(void)
4360 struct rusage rusage;
4362 getrusage(RUSAGE_SELF, &rusage);
4363 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4364 #elif HAVE_GETPROCESSTIMES
4366 FILETIME c, e, k, u;
4367 proc = GetCurrentProcess();
4368 GetProcessTimes(proc, &c, &e, &k, &u);
4369 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4371 return av_gettime();
4375 static int64_t getmaxrss(void)
4377 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4378 struct rusage rusage;
4379 getrusage(RUSAGE_SELF, &rusage);
4380 return (int64_t)rusage.ru_maxrss * 1024;
4381 #elif HAVE_GETPROCESSMEMORYINFO
4383 PROCESS_MEMORY_COUNTERS memcounters;
4384 proc = GetCurrentProcess();
4385 memcounters.cb = sizeof(memcounters);
4386 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4387 return memcounters.PeakPagefileUsage;
4393 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4395 return parse_option(o, "q:a", arg, options);
4398 static void show_usage(void)
4400 printf("Hyper fast Audio and Video encoder\n");
4401 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4405 static int opt_help(const char *opt, const char *arg)
4407 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4408 av_log_set_callback(log_callback_help);
4410 show_help_options(options, "Main options:\n",
4411 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4412 show_help_options(options, "\nAdvanced options:\n",
4413 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4415 show_help_options(options, "\nVideo options:\n",
4416 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4418 show_help_options(options, "\nAdvanced Video options:\n",
4419 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4420 OPT_VIDEO | OPT_EXPERT);
4421 show_help_options(options, "\nAudio options:\n",
4422 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4424 show_help_options(options, "\nAdvanced Audio options:\n",
4425 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4426 OPT_AUDIO | OPT_EXPERT);
4427 show_help_options(options, "\nSubtitle options:\n",
4428 OPT_SUBTITLE | OPT_GRAB,
4430 show_help_options(options, "\nAudio/Video grab options:\n",
4434 show_help_children(avcodec_get_class(), flags);
4435 show_help_children(avformat_get_class(), flags);
4436 show_help_children(sws_get_class(), flags);
4441 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4443 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4444 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4446 if(!strncmp(arg, "pal-", 4)) {
4449 } else if(!strncmp(arg, "ntsc-", 5)) {
4452 } else if(!strncmp(arg, "film-", 5)) {
4456 /* Try to determine PAL/NTSC by peeking in the input files */
4457 if(nb_input_files) {
4459 for (j = 0; j < nb_input_files; j++) {
4460 for (i = 0; i < input_files[j].nb_streams; i++) {
4461 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4462 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4464 fr = c->time_base.den * 1000 / c->time_base.num;
4468 } else if((fr == 29970) || (fr == 23976)) {
4477 if (norm != UNKNOWN)
4478 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4481 if(norm == UNKNOWN) {
4482 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4483 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4484 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4488 if(!strcmp(arg, "vcd")) {
4489 opt_video_codec(o, "c:v", "mpeg1video");
4490 opt_audio_codec(o, "c:a", "mp2");
4491 parse_option(o, "f", "vcd", options);
4493 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4494 parse_option(o, "r", frame_rates[norm], options);
4495 opt_default("g", norm == PAL ? "15" : "18");
4497 opt_default("b:v", "1150000");
4498 opt_default("maxrate", "1150000");
4499 opt_default("minrate", "1150000");
4500 opt_default("bufsize", "327680"); // 40*1024*8;
4502 opt_default("b:a", "224000");
4503 parse_option(o, "ar", "44100", options);
4504 parse_option(o, "ac", "2", options);
4506 opt_default("packetsize", "2324");
4507 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4509 /* We have to offset the PTS, so that it is consistent with the SCR.
4510 SCR starts at 36000, but the first two packs contain only padding
4511 and the first pack from the other stream, respectively, may also have
4512 been written before.
4513 So the real data starts at SCR 36000+3*1200. */
4514 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4515 } else if(!strcmp(arg, "svcd")) {
4517 opt_video_codec(o, "c:v", "mpeg2video");
4518 opt_audio_codec(o, "c:a", "mp2");
4519 parse_option(o, "f", "svcd", options);
4521 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4522 parse_option(o, "r", frame_rates[norm], options);
4523 parse_option(o, "pix_fmt", "yuv420p", options);
4524 opt_default("g", norm == PAL ? "15" : "18");
4526 opt_default("b:v", "2040000");
4527 opt_default("maxrate", "2516000");
4528 opt_default("minrate", "0"); //1145000;
4529 opt_default("bufsize", "1835008"); //224*1024*8;
4530 opt_default("flags", "+scan_offset");
4533 opt_default("b:a", "224000");
4534 parse_option(o, "ar", "44100", options);
4536 opt_default("packetsize", "2324");
4538 } else if(!strcmp(arg, "dvd")) {
4540 opt_video_codec(o, "c:v", "mpeg2video");
4541 opt_audio_codec(o, "c:a", "ac3");
4542 parse_option(o, "f", "dvd", options);
4544 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4545 parse_option(o, "r", frame_rates[norm], options);
4546 parse_option(o, "pix_fmt", "yuv420p", options);
4547 opt_default("g", norm == PAL ? "15" : "18");
4549 opt_default("b:v", "6000000");
4550 opt_default("maxrate", "9000000");
4551 opt_default("minrate", "0"); //1500000;
4552 opt_default("bufsize", "1835008"); //224*1024*8;
4554 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4555 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4557 opt_default("b:a", "448000");
4558 parse_option(o, "ar", "48000", options);
4560 } else if(!strncmp(arg, "dv", 2)) {
4562 parse_option(o, "f", "dv", options);
4564 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4565 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4566 norm == PAL ? "yuv420p" : "yuv411p", options);
4567 parse_option(o, "r", frame_rates[norm], options);
4569 parse_option(o, "ar", "48000", options);
4570 parse_option(o, "ac", "2", options);
4573 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4574 return AVERROR(EINVAL);
4579 static int opt_vstats_file(const char *opt, const char *arg)
4581 av_free (vstats_filename);
4582 vstats_filename=av_strdup (arg);
4586 static int opt_vstats(const char *opt, const char *arg)
4589 time_t today2 = time(NULL);
4590 struct tm *today = localtime(&today2);
4592 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4594 return opt_vstats_file(opt, filename);
4597 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4599 return parse_option(o, "frames:v", arg, options);
4602 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4604 return parse_option(o, "frames:a", arg, options);
4607 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4609 return parse_option(o, "frames:d", arg, options);
4612 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4615 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4616 const char *codec_name = *opt == 'v' ? video_codec_name :
4617 *opt == 'a' ? audio_codec_name :
4618 subtitle_codec_name;
4620 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4621 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4622 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4624 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4629 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4630 if(line[0] == '#' && !e)
4632 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4634 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4637 if(!strcmp(tmp, "acodec")){
4638 opt_audio_codec(o, tmp, tmp2);
4639 }else if(!strcmp(tmp, "vcodec")){
4640 opt_video_codec(o, tmp, tmp2);
4641 }else if(!strcmp(tmp, "scodec")){
4642 opt_subtitle_codec(o, tmp, tmp2);
4643 }else if(!strcmp(tmp, "dcodec")){
4644 opt_data_codec(o, tmp, tmp2);
4645 }else if(opt_default(tmp, tmp2) < 0){
4646 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4656 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4660 static int opt_passlogfile(const char *opt, const char *arg)
4662 pass_logfilename_prefix = arg;
4663 #if CONFIG_LIBX264_ENCODER
4664 return opt_default("passlogfile", arg);
4670 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4672 char *s= av_malloc(strlen(opt)+2);
4673 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4674 return parse_option(o, s, arg, options);
4677 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4679 if(!strcmp(opt, "b")){
4680 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4681 return parse_option(o, av_strdup("b:v"), arg, options);
4683 return opt_default(opt, arg);
4686 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4688 return parse_option(o, "filter:v", arg, options);
4691 #define OFFSET(x) offsetof(OptionsContext, x)
4692 static const OptionDef options[] = {
4694 #include "cmdutils_common_opts.h"
4695 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4696 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4697 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4698 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4699 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4700 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4701 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4702 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4703 { "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]" },
4704 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4705 "outfile[,metadata]:infile[,metadata]" },
4706 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4707 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4708 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4709 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4710 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4711 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4712 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4713 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4714 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4715 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4716 "add timings for benchmarking" },
4717 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4718 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4719 "dump each input packet" },
4720 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4721 "when dumping packets, also dump the payload" },
4722 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4723 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4724 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4725 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4726 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4727 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4728 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4729 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4730 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
4731 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4732 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4733 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4734 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4735 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4736 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4737 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4738 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4740 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4742 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4743 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4744 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4747 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4748 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4749 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4750 { "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" },
4751 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4752 { "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" },
4753 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4754 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4755 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4756 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4757 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4758 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4759 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4760 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4761 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4762 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4763 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4764 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4765 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4766 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4767 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4768 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4769 "use same quantizer as source (implies VBR)" },
4770 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4771 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4772 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4773 "deinterlace pictures" },
4774 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4775 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4776 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4778 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4780 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4781 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4782 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4783 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4784 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4785 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4786 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4787 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4788 { "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" },
4789 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4792 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4793 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4794 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4795 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4796 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4797 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4798 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4799 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4800 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4801 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4803 /* subtitle options */
4804 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4805 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4806 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4809 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4810 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4811 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4814 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4815 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4817 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4818 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4819 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4821 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4822 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4823 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4824 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4825 /* data codec support */
4826 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4827 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
4829 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4833 int main(int argc, char **argv)
4835 OptionsContext o = { 0 };
4838 reset_options(&o, 0);
4840 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4841 parse_loglevel(argc, argv, options);
4843 if(argc>1 && !strcmp(argv[1], "-d")){
4845 av_log_set_callback(log_callback_null);
4850 avcodec_register_all();
4852 avdevice_register_all();
4855 avfilter_register_all();
4858 avformat_network_init();
4860 show_banner(argc, argv, options);
4865 parse_options(&o, argc, argv, options, opt_output_file);
4867 if(nb_output_files <= 0 && nb_input_files == 0) {
4869 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4873 /* file converter / grab */
4874 if (nb_output_files <= 0) {
4875 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4879 if (nb_input_files == 0) {
4880 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4885 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4887 ti = getutime() - ti;
4889 int maxrss = getmaxrss() / 1024;
4890 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);