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->field_order = icodec->field_order;
2217 codec->extradata = av_mallocz(extra_size);
2218 if (!codec->extradata) {
2219 return AVERROR(ENOMEM);
2221 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2222 codec->extradata_size= icodec->extradata_size;
2224 codec->time_base = ist->st->time_base;
2225 if(!strcmp(oc->oformat->name, "avi")) {
2226 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2227 && av_q2d(ist->st->time_base) < 1.0/500
2229 codec->time_base = icodec->time_base;
2230 codec->time_base.num *= icodec->ticks_per_frame;
2231 codec->time_base.den *= 2;
2233 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2234 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2235 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2237 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2238 && av_q2d(ist->st->time_base) < 1.0/500
2240 codec->time_base = icodec->time_base;
2241 codec->time_base.num *= icodec->ticks_per_frame;
2244 av_reduce(&codec->time_base.num, &codec->time_base.den,
2245 codec->time_base.num, codec->time_base.den, INT_MAX);
2247 switch(codec->codec_type) {
2248 case AVMEDIA_TYPE_AUDIO:
2249 if(audio_volume != 256) {
2250 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2253 codec->channel_layout = icodec->channel_layout;
2254 codec->sample_rate = icodec->sample_rate;
2255 codec->channels = icodec->channels;
2256 codec->frame_size = icodec->frame_size;
2257 codec->audio_service_type = icodec->audio_service_type;
2258 codec->block_align = icodec->block_align;
2260 case AVMEDIA_TYPE_VIDEO:
2261 codec->pix_fmt = icodec->pix_fmt;
2262 codec->width = icodec->width;
2263 codec->height = icodec->height;
2264 codec->has_b_frames = icodec->has_b_frames;
2265 if (!codec->sample_aspect_ratio.num) {
2266 codec->sample_aspect_ratio =
2267 ost->st->sample_aspect_ratio =
2268 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2269 ist->st->codec->sample_aspect_ratio.num ?
2270 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2272 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2274 case AVMEDIA_TYPE_SUBTITLE:
2275 codec->width = icodec->width;
2276 codec->height = icodec->height;
2278 case AVMEDIA_TYPE_DATA:
2279 case AVMEDIA_TYPE_ATTACHMENT:
2286 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2288 ist->decoding_needed = 1;
2289 ost->encoding_needed = 1;
2291 switch(codec->codec_type) {
2292 case AVMEDIA_TYPE_AUDIO:
2293 ost->fifo = av_fifo_alloc(1024);
2295 return AVERROR(ENOMEM);
2297 if (!codec->sample_rate)
2298 codec->sample_rate = icodec->sample_rate;
2299 choose_sample_rate(ost->st, ost->enc);
2300 codec->time_base = (AVRational){1, codec->sample_rate};
2302 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2303 codec->sample_fmt = icodec->sample_fmt;
2304 choose_sample_fmt(ost->st, ost->enc);
2306 if (ost->audio_channels_mapped) {
2307 /* the requested output channel is set to the number of
2308 * -map_channel only if no -ac are specified */
2309 if (!codec->channels) {
2310 codec->channels = ost->audio_channels_mapped;
2311 codec->channel_layout = av_get_default_channel_layout(codec->channels);
2312 if (!codec->channel_layout) {
2313 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2317 /* fill unused channel mapping with -1 (which means a muted
2318 * channel in case the number of output channels is bigger
2319 * than the number of mapped channel) */
2320 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2321 ost->audio_channels_map[j] = -1;
2322 } else if (!codec->channels) {
2323 codec->channels = icodec->channels;
2324 codec->channel_layout = icodec->channel_layout;
2326 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2327 codec->channel_layout = 0;
2329 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2330 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2331 || codec->channel_layout != icodec->channel_layout;
2332 icodec->request_channels = codec->channels;
2333 ost->resample_sample_fmt = icodec->sample_fmt;
2334 ost->resample_sample_rate = icodec->sample_rate;
2335 ost->resample_channels = icodec->channels;
2337 case AVMEDIA_TYPE_VIDEO:
2338 if (codec->pix_fmt == PIX_FMT_NONE)
2339 codec->pix_fmt = icodec->pix_fmt;
2340 choose_pixel_fmt(ost->st, ost->enc);
2342 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2343 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2347 if (!codec->width || !codec->height) {
2348 codec->width = icodec->width;
2349 codec->height = icodec->height;
2352 ost->video_resample = codec->width != icodec->width ||
2353 codec->height != icodec->height ||
2354 codec->pix_fmt != icodec->pix_fmt;
2355 if (ost->video_resample) {
2356 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2359 ost->resample_height = icodec->height;
2360 ost->resample_width = icodec->width;
2361 ost->resample_pix_fmt = icodec->pix_fmt;
2363 if (!ost->frame_rate.num)
2364 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2365 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2366 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2367 ost->frame_rate = ost->enc->supported_framerates[idx];
2369 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2370 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2371 && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2372 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2373 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2375 for (j = 0; j < ost->forced_kf_count; j++)
2376 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2381 if (configure_video_filters(ist, ost)) {
2382 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2387 case AVMEDIA_TYPE_SUBTITLE:
2394 if (codec->codec_id != CODEC_ID_H264 &&
2395 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2396 char logfilename[1024];
2399 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2400 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2402 if (codec->flags & CODEC_FLAG_PASS2) {
2404 size_t logbuffer_size;
2405 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2406 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2410 codec->stats_in = logbuffer;
2412 if (codec->flags & CODEC_FLAG_PASS1) {
2413 f = fopen(logfilename, "wb");
2415 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2416 logfilename, strerror(errno));
2423 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2424 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2425 int size = codec->width * codec->height;
2426 bit_buffer_size = FFMAX(bit_buffer_size, 7*size + 10000);
2431 bit_buffer = av_malloc(bit_buffer_size);
2433 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2435 return AVERROR(ENOMEM);
2438 /* open each encoder */
2439 for (i = 0; i < nb_output_streams; i++) {
2440 ost = &output_streams[i];
2441 if (ost->encoding_needed) {
2442 AVCodec *codec = ost->enc;
2443 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2445 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2446 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2447 ret = AVERROR(EINVAL);
2450 if (dec->subtitle_header) {
2451 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2452 if (!ost->st->codec->subtitle_header) {
2453 ret = AVERROR(ENOMEM);
2456 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2457 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2459 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2460 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2461 ost->file_index, ost->index);
2462 ret = AVERROR(EINVAL);
2465 assert_codec_experimental(ost->st->codec, 1);
2466 assert_avoptions(ost->opts);
2467 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2468 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2469 " It takes bits/s as argument, not kbits/s\n");
2470 extra_size += ost->st->codec->extradata_size;
2472 if (ost->st->codec->me_threshold)
2473 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2477 /* init input streams */
2478 for (i = 0; i < nb_input_streams; i++)
2479 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2482 /* discard unused programs */
2483 for (i = 0; i < nb_input_files; i++) {
2484 InputFile *ifile = &input_files[i];
2485 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2486 AVProgram *p = ifile->ctx->programs[j];
2487 int discard = AVDISCARD_ALL;
2489 for (k = 0; k < p->nb_stream_indexes; k++)
2490 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2491 discard = AVDISCARD_DEFAULT;
2494 p->discard = discard;
2498 /* open files and write file headers */
2499 for (i = 0; i < nb_output_files; i++) {
2500 oc = output_files[i].ctx;
2501 oc->interrupt_callback = int_cb;
2502 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2503 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2504 ret = AVERROR(EINVAL);
2507 // assert_avoptions(output_files[i].opts);
2508 if (strcmp(oc->oformat->name, "rtp")) {
2514 /* dump the file output parameters - cannot be done before in case
2516 for (i = 0; i < nb_output_files; i++) {
2517 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2520 /* dump the stream mapping */
2521 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2522 for (i = 0; i < nb_output_streams; i++) {
2523 ost = &output_streams[i];
2525 if (ost->attachment_filename) {
2526 /* an attached file */
2527 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2528 ost->attachment_filename, ost->file_index, ost->index);
2531 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2532 input_streams[ost->source_index].file_index,
2533 input_streams[ost->source_index].st->index,
2536 if (ost->audio_channels_mapped) {
2537 av_log(NULL, AV_LOG_INFO, " [ch:");
2538 for (j = 0; j < ost->audio_channels_mapped; j++)
2539 if (ost->audio_channels_map[j] == -1)
2540 av_log(NULL, AV_LOG_INFO, " M");
2542 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2543 av_log(NULL, AV_LOG_INFO, "]");
2545 if (ost->sync_ist != &input_streams[ost->source_index])
2546 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2547 ost->sync_ist->file_index,
2548 ost->sync_ist->st->index);
2549 if (ost->stream_copy)
2550 av_log(NULL, AV_LOG_INFO, " (copy)");
2552 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2553 input_streams[ost->source_index].dec->name : "?",
2554 ost->enc ? ost->enc->name : "?");
2555 av_log(NULL, AV_LOG_INFO, "\n");
2559 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2564 print_sdp(output_files, nb_output_files);
2571 * The following code is the main loop of the file converter
2573 static int transcode(OutputFile *output_files, int nb_output_files,
2574 InputFile *input_files, int nb_input_files)
2577 AVFormatContext *is, *os;
2581 int no_packet_count=0;
2582 int64_t timer_start;
2585 if (!(no_packet = av_mallocz(nb_input_files)))
2588 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2593 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2596 timer_start = av_gettime();
2598 for(; received_sigterm == 0;) {
2599 int file_index, ist_index;
2603 int64_t cur_time= av_gettime();
2605 ipts_min= INT64_MAX;
2607 /* if 'q' pressed, exits */
2609 static int64_t last_time;
2610 if (received_nb_signals)
2612 /* read_key() returns 0 on EOF */
2613 if(cur_time - last_time >= 100000 && !run_as_daemon){
2615 last_time = cur_time;
2620 if (key == '+') av_log_set_level(av_log_get_level()+10);
2621 if (key == '-') av_log_set_level(av_log_get_level()-10);
2622 if (key == 's') qp_hist ^= 1;
2625 do_hex_dump = do_pkt_dump = 0;
2626 } else if(do_pkt_dump){
2630 av_log_set_level(AV_LOG_DEBUG);
2633 if (key == 'c' || key == 'C'){
2634 char buf[4096], target[64], command[256], arg[256] = {0};
2637 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2639 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2644 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2645 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2646 target, time, command, arg);
2647 for (i = 0; i < nb_output_streams; i++) {
2648 ost = &output_streams[i];
2651 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2652 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2653 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2655 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2660 av_log(NULL, AV_LOG_ERROR,
2661 "Parse error, at least 3 arguments were expected, "
2662 "only %d given in string '%s'\n", n, buf);
2666 if (key == 'd' || key == 'D'){
2669 debug = input_streams[0].st->codec->debug<<1;
2670 if(!debug) debug = 1;
2671 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2674 if(scanf("%d", &debug)!=1)
2675 fprintf(stderr,"error parsing debug value\n");
2676 for(i=0;i<nb_input_streams;i++) {
2677 input_streams[i].st->codec->debug = debug;
2679 for(i=0;i<nb_output_streams;i++) {
2680 ost = &output_streams[i];
2681 ost->st->codec->debug = debug;
2683 if(debug) av_log_set_level(AV_LOG_DEBUG);
2684 fprintf(stderr,"debug=%d\n", debug);
2687 fprintf(stderr, "key function\n"
2688 "? show this help\n"
2689 "+ increase verbosity\n"
2690 "- decrease verbosity\n"
2691 "c Send command to filtergraph\n"
2692 "D cycle through available debug modes\n"
2693 "h dump packets/hex press to cycle through the 3 states\n"
2695 "s Show QP histogram\n"
2700 /* select the stream that we must read now by looking at the
2701 smallest output pts */
2703 for (i = 0; i < nb_output_streams; i++) {
2707 ost = &output_streams[i];
2708 of = &output_files[ost->file_index];
2709 os = output_files[ost->file_index].ctx;
2710 ist = &input_streams[ost->source_index];
2711 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2712 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2714 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2716 if (!input_files[ist->file_index].eof_reached){
2717 if(ipts < ipts_min) {
2719 if(input_sync ) file_index = ist->file_index;
2721 if(opts < opts_min) {
2723 if(!input_sync) file_index = ist->file_index;
2726 if (ost->frame_number >= ost->max_frames) {
2728 for (j = 0; j < of->ctx->nb_streams; j++)
2729 output_streams[of->ost_index + j].is_past_recording_time = 1;
2733 /* if none, if is finished */
2734 if (file_index < 0) {
2735 if(no_packet_count){
2737 memset(no_packet, 0, nb_input_files);
2744 /* read a frame from it and output it in the fifo */
2745 is = input_files[file_index].ctx;
2746 ret= av_read_frame(is, &pkt);
2747 if(ret == AVERROR(EAGAIN)){
2748 no_packet[file_index]=1;
2753 input_files[file_index].eof_reached = 1;
2761 memset(no_packet, 0, nb_input_files);
2764 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2765 is->streams[pkt.stream_index]);
2767 /* the following test is needed in case new streams appear
2768 dynamically in stream : we ignore them */
2769 if (pkt.stream_index >= input_files[file_index].nb_streams)
2770 goto discard_packet;
2771 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2772 ist = &input_streams[ist_index];
2774 goto discard_packet;
2776 if (pkt.dts != AV_NOPTS_VALUE)
2777 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2778 if (pkt.pts != AV_NOPTS_VALUE)
2779 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2781 if(pkt.pts != AV_NOPTS_VALUE)
2782 pkt.pts *= ist->ts_scale;
2783 if(pkt.dts != AV_NOPTS_VALUE)
2784 pkt.dts *= ist->ts_scale;
2786 // 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);
2787 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2788 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2789 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2790 int64_t delta= pkt_dts - ist->next_pts;
2791 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2792 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2793 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2794 pkt_dts+1<ist->pts)&& !copy_ts){
2795 input_files[ist->file_index].ts_offset -= delta;
2796 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2797 delta, input_files[ist->file_index].ts_offset);
2798 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2799 if(pkt.pts != AV_NOPTS_VALUE)
2800 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2804 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2805 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2807 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2808 ist->file_index, ist->st->index);
2811 av_free_packet(&pkt);
2816 av_free_packet(&pkt);
2818 /* dump report by using the output first video and audio streams */
2819 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
2822 /* at the end of stream, we must flush the decoder buffers */
2823 for (i = 0; i < nb_input_streams; i++) {
2824 ist = &input_streams[i];
2825 if (ist->decoding_needed) {
2826 output_packet(ist, output_streams, nb_output_streams, NULL);
2829 flush_encoders(output_streams, nb_output_streams);
2833 /* write the trailer if needed and close file */
2834 for(i=0;i<nb_output_files;i++) {
2835 os = output_files[i].ctx;
2836 av_write_trailer(os);
2839 /* dump report by using the first video and audio streams */
2840 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
2842 /* close each encoder */
2843 for (i = 0; i < nb_output_streams; i++) {
2844 ost = &output_streams[i];
2845 if (ost->encoding_needed) {
2846 av_freep(&ost->st->codec->stats_in);
2847 avcodec_close(ost->st->codec);
2850 avfilter_graph_free(&ost->graph);
2854 /* close each decoder */
2855 for (i = 0; i < nb_input_streams; i++) {
2856 ist = &input_streams[i];
2857 if (ist->decoding_needed) {
2858 avcodec_close(ist->st->codec);
2866 av_freep(&bit_buffer);
2867 av_freep(&no_packet);
2869 if (output_streams) {
2870 for (i = 0; i < nb_output_streams; i++) {
2871 ost = &output_streams[i];
2873 if (ost->stream_copy)
2874 av_freep(&ost->st->codec->extradata);
2876 fclose(ost->logfile);
2877 ost->logfile = NULL;
2879 av_fifo_free(ost->fifo); /* works even if fifo is not
2880 initialized but set to zero */
2881 av_freep(&ost->st->codec->subtitle_header);
2882 av_free(ost->resample_frame.data[0]);
2883 av_free(ost->forced_kf_pts);
2884 if (ost->video_resample)
2885 sws_freeContext(ost->img_resample_ctx);
2886 swr_free(&ost->swr);
2887 av_dict_free(&ost->opts);
2894 static int opt_frame_crop(const char *opt, const char *arg)
2896 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2897 return AVERROR(EINVAL);
2900 static int opt_pad(const char *opt, const char *arg)
2902 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2906 static double parse_frame_aspect_ratio(const char *arg)
2913 p = strchr(arg, ':');
2915 x = strtol(arg, &end, 10);
2917 y = strtol(end+1, &end, 10);
2919 ar = (double)x / (double)y;
2921 ar = strtod(arg, NULL);
2924 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2930 static int opt_video_channel(const char *opt, const char *arg)
2932 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2933 return opt_default("channel", arg);
2936 static int opt_video_standard(const char *opt, const char *arg)
2938 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2939 return opt_default("standard", arg);
2942 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2944 audio_codec_name = arg;
2945 return parse_option(o, "codec:a", arg, options);
2948 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2950 video_codec_name = arg;
2951 return parse_option(o, "codec:v", arg, options);
2954 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2956 subtitle_codec_name = arg;
2957 return parse_option(o, "codec:s", arg, options);
2960 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2962 return parse_option(o, "codec:d", arg, options);
2965 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2967 StreamMap *m = NULL;
2968 int i, negative = 0, file_idx;
2969 int sync_file_idx = -1, sync_stream_idx;
2977 map = av_strdup(arg);
2979 /* parse sync stream first, just pick first matching stream */
2980 if (sync = strchr(map, ',')) {
2982 sync_file_idx = strtol(sync + 1, &sync, 0);
2983 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2984 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2989 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2990 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2991 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2992 sync_stream_idx = i;
2995 if (i == input_files[sync_file_idx].nb_streams) {
2996 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2997 "match any streams.\n", arg);
3003 file_idx = strtol(map, &p, 0);
3004 if (file_idx >= nb_input_files || file_idx < 0) {
3005 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3009 /* disable some already defined maps */
3010 for (i = 0; i < o->nb_stream_maps; i++) {
3011 m = &o->stream_maps[i];
3012 if (file_idx == m->file_index &&
3013 check_stream_specifier(input_files[m->file_index].ctx,
3014 input_files[m->file_index].ctx->streams[m->stream_index],
3015 *p == ':' ? p + 1 : p) > 0)
3019 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3020 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3021 *p == ':' ? p + 1 : p) <= 0)
3023 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3024 &o->nb_stream_maps, o->nb_stream_maps + 1);
3025 m = &o->stream_maps[o->nb_stream_maps - 1];
3027 m->file_index = file_idx;
3028 m->stream_index = i;
3030 if (sync_file_idx >= 0) {
3031 m->sync_file_index = sync_file_idx;
3032 m->sync_stream_index = sync_stream_idx;
3034 m->sync_file_index = file_idx;
3035 m->sync_stream_index = i;
3040 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3048 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3050 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3051 &o->nb_attachments, o->nb_attachments + 1);
3052 o->attachments[o->nb_attachments - 1] = arg;
3056 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3062 o->audio_channel_maps =
3063 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3064 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3065 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3067 /* muted channel syntax */
3068 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3069 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3070 m->file_idx = m->stream_idx = -1;
3072 m->ofile_idx = m->ostream_idx = -1;
3077 n = sscanf(arg, "%d.%d.%d:%d.%d",
3078 &m->file_idx, &m->stream_idx, &m->channel_idx,
3079 &m->ofile_idx, &m->ostream_idx);
3081 if (n != 3 && n != 5) {
3082 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3083 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3087 if (n != 5) // only file.stream.channel specified
3088 m->ofile_idx = m->ostream_idx = -1;
3091 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3092 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3096 if (m->stream_idx < 0 ||
3097 m->stream_idx >= input_files[m->file_idx].nb_streams) {
3098 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3099 m->file_idx, m->stream_idx);
3102 st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3103 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3104 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3105 m->file_idx, m->stream_idx);
3108 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3109 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3110 m->file_idx, m->stream_idx, m->channel_idx);
3117 * Parse a metadata specifier in arg.
3118 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3119 * @param index for type c/p, chapter/program index is written here
3120 * @param stream_spec for type s, the stream specifier is written here
3122 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3130 if (*(++arg) && *arg != ':') {
3131 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3134 *stream_spec = *arg == ':' ? arg + 1 : "";
3138 if (*(++arg) == ':')
3139 *index = strtol(++arg, NULL, 0);
3142 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3149 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3151 AVDictionary **meta_in = NULL;
3152 AVDictionary **meta_out;
3154 char type_in, type_out;
3155 const char *istream_spec = NULL, *ostream_spec = NULL;
3156 int idx_in = 0, idx_out = 0;
3158 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3159 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3161 if (type_in == 'g' || type_out == 'g')
3162 o->metadata_global_manual = 1;
3163 if (type_in == 's' || type_out == 's')
3164 o->metadata_streams_manual = 1;
3165 if (type_in == 'c' || type_out == 'c')
3166 o->metadata_chapters_manual = 1;
3168 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3169 if ((index) < 0 || (index) >= (nb_elems)) {\
3170 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3175 #define SET_DICT(type, meta, context, index)\
3178 meta = &context->metadata;\
3181 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3182 meta = &context->chapters[index]->metadata;\
3185 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3186 meta = &context->programs[index]->metadata;\
3190 SET_DICT(type_in, meta_in, ic, idx_in);
3191 SET_DICT(type_out, meta_out, oc, idx_out);
3193 /* for input streams choose first matching stream */
3194 if (type_in == 's') {
3195 for (i = 0; i < ic->nb_streams; i++) {
3196 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3197 meta_in = &ic->streams[i]->metadata;
3203 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3208 if (type_out == 's') {
3209 for (i = 0; i < oc->nb_streams; i++) {
3210 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3211 meta_out = &oc->streams[i]->metadata;
3212 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3217 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3222 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3225 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3226 struct tm time = *gmtime((time_t*)&recording_timestamp);
3227 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3228 parse_option(o, "metadata", buf, options);
3230 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3231 "tag instead.\n", opt);
3235 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3237 const char *codec_string = encoder ? "encoder" : "decoder";
3241 avcodec_find_encoder_by_name(name) :
3242 avcodec_find_decoder_by_name(name);
3244 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3247 if(codec->type != type) {
3248 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3254 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3256 char *codec_name = NULL;
3258 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3260 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3261 st->codec->codec_id = codec->id;
3264 return avcodec_find_decoder(st->codec->codec_id);
3268 * Add all the streams from the given input file to the global
3269 * list of input streams.
3271 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3273 int i, rfps, rfps_base;
3274 char *next, *codec_tag = NULL;
3276 for (i = 0; i < ic->nb_streams; i++) {
3277 AVStream *st = ic->streams[i];
3278 AVCodecContext *dec = st->codec;
3281 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3282 ist = &input_streams[nb_input_streams - 1];
3284 ist->file_index = nb_input_files;
3286 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3288 ist->ts_scale = 1.0;
3289 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3291 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3293 uint32_t tag = strtol(codec_tag, &next, 0);
3295 tag = AV_RL32(codec_tag);
3296 st->codec->codec_tag = tag;
3299 ist->dec = choose_decoder(o, ic, st);
3301 switch (dec->codec_type) {
3302 case AVMEDIA_TYPE_AUDIO:
3304 ist->dec = avcodec_find_decoder(dec->codec_id);
3305 if(o->audio_disable)
3306 st->discard= AVDISCARD_ALL;
3308 case AVMEDIA_TYPE_VIDEO:
3310 ist->dec = avcodec_find_decoder(dec->codec_id);
3311 rfps = ic->streams[i]->r_frame_rate.num;
3312 rfps_base = ic->streams[i]->r_frame_rate.den;
3314 dec->flags |= CODEC_FLAG_EMU_EDGE;
3317 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3319 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",
3320 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3321 (float)rfps / rfps_base, rfps, rfps_base);
3324 if (o->video_disable)
3325 st->discard= AVDISCARD_ALL;
3326 else if(video_discard)
3327 st->discard= video_discard;
3329 case AVMEDIA_TYPE_DATA:
3330 if (o->data_disable)
3331 st->discard= AVDISCARD_ALL;
3333 case AVMEDIA_TYPE_SUBTITLE:
3335 ist->dec = avcodec_find_decoder(dec->codec_id);
3336 if(o->subtitle_disable)
3337 st->discard = AVDISCARD_ALL;
3339 case AVMEDIA_TYPE_ATTACHMENT:
3340 case AVMEDIA_TYPE_UNKNOWN:
3348 static void assert_file_overwrite(const char *filename)
3350 if ((!file_overwrite || no_file_overwrite) &&
3351 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3352 av_strstart(filename, "file:", NULL))) {
3353 if (avio_check(filename, 0) == 0) {
3354 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3355 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3358 signal(SIGINT, SIG_DFL);
3359 if (!read_yesno()) {
3360 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3366 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3373 static void dump_attachment(AVStream *st, const char *filename)
3376 AVIOContext *out = NULL;
3377 AVDictionaryEntry *e;
3379 if (!st->codec->extradata_size) {
3380 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3381 nb_input_files - 1, st->index);
3384 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3385 filename = e->value;
3387 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3388 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3392 assert_file_overwrite(filename);
3394 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3395 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3400 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3405 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3407 AVFormatContext *ic;
3408 AVInputFormat *file_iformat = NULL;
3412 AVDictionary **opts;
3413 int orig_nb_streams; // number of streams before avformat_find_stream_info
3416 if (!(file_iformat = av_find_input_format(o->format))) {
3417 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3422 if (!strcmp(filename, "-"))
3425 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3426 !strcmp(filename, "/dev/stdin");
3428 /* get default parameters from command line */
3429 ic = avformat_alloc_context();
3431 print_error(filename, AVERROR(ENOMEM));
3434 if (o->nb_audio_sample_rate) {
3435 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3436 av_dict_set(&format_opts, "sample_rate", buf, 0);
3438 if (o->nb_audio_channels) {
3439 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3440 av_dict_set(&format_opts, "channels", buf, 0);
3442 if (o->nb_frame_rates) {
3443 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3445 if (o->nb_frame_sizes) {
3446 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3448 if (o->nb_frame_pix_fmts)
3449 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3451 ic->video_codec_id = video_codec_name ?
3452 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3453 ic->audio_codec_id = audio_codec_name ?
3454 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3455 ic->subtitle_codec_id= subtitle_codec_name ?
3456 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3457 ic->flags |= AVFMT_FLAG_NONBLOCK;
3458 ic->interrupt_callback = int_cb;
3461 av_log(NULL, AV_LOG_WARNING,
3462 "-loop_input is deprecated, use -loop 1\n"
3463 "Note, both loop options only work with -f image2\n"
3465 ic->loop_input = loop_input;
3468 /* open the input file with generic avformat function */
3469 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3471 print_error(filename, err);
3474 assert_avoptions(format_opts);
3476 /* apply forced codec ids */
3477 for (i = 0; i < ic->nb_streams; i++)
3478 choose_decoder(o, ic, ic->streams[i]);
3480 /* Set AVCodecContext options for avformat_find_stream_info */
3481 opts = setup_find_stream_info_opts(ic, codec_opts);
3482 orig_nb_streams = ic->nb_streams;
3484 /* If not enough info to get the stream parameters, we decode the
3485 first frames to get it. (used in mpeg case for example) */
3486 ret = avformat_find_stream_info(ic, opts);
3488 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3489 avformat_close_input(&ic);
3493 timestamp = o->start_time;
3494 /* add the stream start time */
3495 if (ic->start_time != AV_NOPTS_VALUE)
3496 timestamp += ic->start_time;
3498 /* if seeking requested, we execute it */
3499 if (o->start_time != 0) {
3500 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3502 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3503 filename, (double)timestamp / AV_TIME_BASE);
3507 /* update the current parameters so that they match the one of the input stream */
3508 add_input_streams(o, ic);
3510 /* dump the file content */
3511 av_dump_format(ic, nb_input_files, filename, 0);
3513 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3514 input_files[nb_input_files - 1].ctx = ic;
3515 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3516 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3517 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3518 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3520 for (i = 0; i < o->nb_dump_attachment; i++) {
3523 for (j = 0; j < ic->nb_streams; j++) {
3524 AVStream *st = ic->streams[j];
3526 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3527 dump_attachment(st, o->dump_attachment[i].u.str);
3531 for (i = 0; i < orig_nb_streams; i++)
3532 av_dict_free(&opts[i]);
3535 reset_options(o, 1);
3539 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3544 for (p = kf; *p; p++)
3547 ost->forced_kf_count = n;
3548 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3549 if (!ost->forced_kf_pts) {
3550 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3553 for (i = 0; i < n; i++) {
3554 p = i ? strchr(p, ',') + 1 : kf;
3555 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3559 static uint8_t *get_line(AVIOContext *s)
3565 if (avio_open_dyn_buf(&line) < 0) {
3566 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3570 while ((c = avio_r8(s)) && c != '\n')
3573 avio_close_dyn_buf(line, &buf);
3578 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3581 char filename[1000];
3582 const char *base[3] = { getenv("AVCONV_DATADIR"),
3587 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3591 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3592 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3593 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3596 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3597 i != 1 ? "" : "/.avconv", preset_name);
3598 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3604 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3606 char *codec_name = NULL;
3608 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3610 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3611 NULL, ost->st->codec->codec_type);
3612 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3613 } else if (!strcmp(codec_name, "copy"))
3614 ost->stream_copy = 1;
3616 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3617 ost->st->codec->codec_id = ost->enc->id;
3621 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3624 AVStream *st = avformat_new_stream(oc, NULL);
3625 int idx = oc->nb_streams - 1, ret = 0;
3626 char *bsf = NULL, *next, *codec_tag = NULL;
3627 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3629 char *buf = NULL, *arg = NULL, *preset = NULL;
3630 AVIOContext *s = NULL;
3633 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3637 if (oc->nb_streams - 1 < o->nb_streamid_map)
3638 st->id = o->streamid_map[oc->nb_streams - 1];
3640 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3641 nb_output_streams + 1);
3642 ost = &output_streams[nb_output_streams - 1];
3643 ost->file_index = nb_output_files;
3646 st->codec->codec_type = type;
3647 choose_encoder(o, oc, ost);
3649 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3652 avcodec_get_context_defaults3(st->codec, ost->enc);
3653 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3655 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3656 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3659 if (!buf[0] || buf[0] == '#') {
3663 if (!(arg = strchr(buf, '='))) {
3664 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3668 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3670 } while (!s->eof_reached);
3674 av_log(NULL, AV_LOG_FATAL,
3675 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3676 preset, ost->file_index, ost->index);
3680 ost->max_frames = INT64_MAX;
3681 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3683 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3685 if (next = strchr(bsf, ','))
3687 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3688 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3692 bsfc_prev->next = bsfc;
3694 ost->bitstream_filters = bsfc;
3700 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3702 uint32_t tag = strtol(codec_tag, &next, 0);
3704 tag = AV_RL32(codec_tag);
3705 st->codec->codec_tag = tag;
3708 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3709 if (qscale >= 0 || same_quant) {
3710 st->codec->flags |= CODEC_FLAG_QSCALE;
3711 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3714 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3715 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3717 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3721 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3724 const char *p = str;
3731 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3738 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3742 AVCodecContext *video_enc;
3744 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3746 video_enc = st->codec;
3748 if (!ost->stream_copy) {
3749 const char *p = NULL;
3750 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3751 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3752 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3755 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3756 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3757 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3761 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3762 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3763 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3767 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3768 if (frame_aspect_ratio)
3769 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3771 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3772 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3773 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3774 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3777 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3780 video_enc->gop_size = 0;
3781 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3783 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3784 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3787 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3789 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3791 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3792 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3795 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3798 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3801 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3803 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3806 /* FIXME realloc failure */
3807 video_enc->rc_override=
3808 av_realloc(video_enc->rc_override,
3809 sizeof(RcOverride)*(i+1));
3810 video_enc->rc_override[i].start_frame= start;
3811 video_enc->rc_override[i].end_frame = end;
3813 video_enc->rc_override[i].qscale= q;
3814 video_enc->rc_override[i].quality_factor= 1.0;
3817 video_enc->rc_override[i].qscale= 0;
3818 video_enc->rc_override[i].quality_factor= -q/100.0;
3823 video_enc->rc_override_count=i;
3824 if (!video_enc->rc_initial_buffer_occupancy)
3825 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3826 video_enc->intra_dc_precision= intra_dc_precision - 8;
3829 video_enc->flags|= CODEC_FLAG_PSNR;
3834 video_enc->flags |= CODEC_FLAG_PASS1;
3837 video_enc->flags |= CODEC_FLAG_PASS2;
3841 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3842 if (forced_key_frames)
3843 parse_forced_key_frames(forced_key_frames, ost);
3845 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3847 ost->top_field_first = -1;
3848 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3850 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3853 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3855 ost->avfilter = av_strdup(filters);
3862 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3867 AVCodecContext *audio_enc;
3869 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3872 audio_enc = st->codec;
3873 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3875 if (!ost->stream_copy) {
3876 char *sample_fmt = NULL;
3878 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3880 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3882 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3883 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3887 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3889 ost->rematrix_volume=1.0;
3890 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3893 /* check for channel mapping for this audio stream */
3894 for (n = 0; n < o->nb_audio_channel_maps; n++) {
3895 AudioChannelMap *map = &o->audio_channel_maps[n];
3896 InputStream *ist = &input_streams[ost->source_index];
3897 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
3898 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
3899 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
3900 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
3901 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
3903 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
3904 ost->file_index, ost->st->index);
3911 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3915 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3916 if (!ost->stream_copy) {
3917 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3924 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3926 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3927 ost->stream_copy = 1;
3931 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3935 AVCodecContext *subtitle_enc;
3937 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3939 subtitle_enc = st->codec;
3941 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3946 /* arg format is "output-stream-index:streamid-value". */
3947 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3953 av_strlcpy(idx_str, arg, sizeof(idx_str));
3954 p = strchr(idx_str, ':');
3956 av_log(NULL, AV_LOG_FATAL,
3957 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3962 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3963 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3964 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3968 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3970 AVFormatContext *is = ifile->ctx;
3971 AVFormatContext *os = ofile->ctx;
3974 for (i = 0; i < is->nb_chapters; i++) {
3975 AVChapter *in_ch = is->chapters[i], *out_ch;
3976 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3977 AV_TIME_BASE_Q, in_ch->time_base);
3978 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3979 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3982 if (in_ch->end < ts_off)
3984 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3987 out_ch = av_mallocz(sizeof(AVChapter));
3989 return AVERROR(ENOMEM);
3991 out_ch->id = in_ch->id;
3992 out_ch->time_base = in_ch->time_base;
3993 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3994 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3997 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4000 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4002 return AVERROR(ENOMEM);
4003 os->chapters[os->nb_chapters - 1] = out_ch;
4008 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4011 AVFormatContext *ic = avformat_alloc_context();
4013 ic->interrupt_callback = int_cb;
4014 err = avformat_open_input(&ic, filename, NULL, NULL);
4017 /* copy stream format */
4018 for(i=0;i<ic->nb_streams;i++) {
4022 AVCodecContext *avctx;
4024 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4025 ost = new_output_stream(o, s, codec->type);
4030 // FIXME: a more elegant solution is needed
4031 memcpy(st, ic->streams[i], sizeof(AVStream));
4032 st->info = av_malloc(sizeof(*st->info));
4033 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4035 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4037 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4038 choose_sample_fmt(st, codec);
4039 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4040 choose_pixel_fmt(st, codec);
4043 av_close_input_file(ic);
4047 static void opt_output_file(void *optctx, const char *filename)
4049 OptionsContext *o = optctx;
4050 AVFormatContext *oc;
4052 AVOutputFormat *file_oformat;
4056 if (!strcmp(filename, "-"))
4059 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4061 print_error(filename, err);
4064 file_oformat= oc->oformat;
4065 oc->interrupt_callback = int_cb;
4067 if (!strcmp(file_oformat->name, "ffm") &&
4068 av_strstart(filename, "http:", NULL)) {
4070 /* special case for files sent to ffserver: we get the stream
4071 parameters from ffserver */
4072 int err = read_ffserver_streams(o, oc, filename);
4074 print_error(filename, err);
4077 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4078 ost = &output_streams[j];
4079 for (i = 0; i < nb_input_streams; i++) {
4080 ist = &input_streams[i];
4081 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4083 ost->source_index= i;
4089 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));
4093 } else if (!o->nb_stream_maps) {
4094 /* pick the "best" stream of each type */
4095 #define NEW_STREAM(type, index)\
4097 ost = new_ ## type ## _stream(o, oc);\
4098 ost->source_index = index;\
4099 ost->sync_ist = &input_streams[index];\
4100 input_streams[index].discard = 0;\
4103 /* video: highest resolution */
4104 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4105 int area = 0, idx = -1;
4106 for (i = 0; i < nb_input_streams; i++) {
4107 ist = &input_streams[i];
4108 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4109 ist->st->codec->width * ist->st->codec->height > area) {
4110 area = ist->st->codec->width * ist->st->codec->height;
4114 NEW_STREAM(video, idx);
4117 /* audio: most channels */
4118 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4119 int channels = 0, idx = -1;
4120 for (i = 0; i < nb_input_streams; i++) {
4121 ist = &input_streams[i];
4122 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4123 ist->st->codec->channels > channels) {
4124 channels = ist->st->codec->channels;
4128 NEW_STREAM(audio, idx);
4131 /* subtitles: pick first */
4132 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4133 for (i = 0; i < nb_input_streams; i++)
4134 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4135 NEW_STREAM(subtitle, i);
4139 /* do something with data? */
4141 for (i = 0; i < o->nb_stream_maps; i++) {
4142 StreamMap *map = &o->stream_maps[i];
4147 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4148 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4150 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4152 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4154 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4157 switch (ist->st->codec->codec_type) {
4158 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4159 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4160 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4161 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4162 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4164 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4165 map->file_index, map->stream_index);
4169 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4170 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4171 map->sync_stream_index];
4176 /* handle attached files */
4177 for (i = 0; i < o->nb_attachments; i++) {
4179 uint8_t *attachment;
4183 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4184 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4188 if ((len = avio_size(pb)) <= 0) {
4189 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4193 if (!(attachment = av_malloc(len))) {
4194 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4198 avio_read(pb, attachment, len);
4200 ost = new_attachment_stream(o, oc);
4201 ost->stream_copy = 0;
4202 ost->source_index = -1;
4203 ost->attachment_filename = o->attachments[i];
4204 ost->st->codec->extradata = attachment;
4205 ost->st->codec->extradata_size = len;
4207 p = strrchr(o->attachments[i], '/');
4208 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4212 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4213 output_files[nb_output_files - 1].ctx = oc;
4214 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4215 output_files[nb_output_files - 1].recording_time = o->recording_time;
4216 output_files[nb_output_files - 1].start_time = o->start_time;
4217 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4218 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4220 /* check filename in case of an image number is expected */
4221 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4222 if (!av_filename_number_test(oc->filename)) {
4223 print_error(oc->filename, AVERROR(EINVAL));
4228 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4229 /* test if it already exists to avoid losing precious files */
4230 assert_file_overwrite(filename);
4233 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4234 &oc->interrupt_callback,
4235 &output_files[nb_output_files - 1].opts)) < 0) {
4236 print_error(filename, err);
4241 if (o->mux_preload) {
4243 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4244 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4246 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4248 if (loop_output >= 0) {
4249 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4250 oc->loop_output = loop_output;
4254 for (i = 0; i < o->nb_metadata_map; i++) {
4256 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4258 if (in_file_index < 0)
4260 if (in_file_index >= nb_input_files) {
4261 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4264 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4268 if (o->chapters_input_file >= nb_input_files) {
4269 if (o->chapters_input_file == INT_MAX) {
4270 /* copy chapters from the first input file that has them*/
4271 o->chapters_input_file = -1;
4272 for (i = 0; i < nb_input_files; i++)
4273 if (input_files[i].ctx->nb_chapters) {
4274 o->chapters_input_file = i;
4278 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4279 o->chapters_input_file);
4283 if (o->chapters_input_file >= 0)
4284 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4285 !o->metadata_chapters_manual);
4287 /* copy global metadata by default */
4288 if (!o->metadata_global_manual && nb_input_files){
4289 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4290 AV_DICT_DONT_OVERWRITE);
4291 if(o->recording_time != INT64_MAX)
4292 av_dict_set(&oc->metadata, "duration", NULL, 0);
4294 if (!o->metadata_streams_manual)
4295 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4297 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4299 ist = &input_streams[output_streams[i].source_index];
4300 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4303 /* process manually set metadata */
4304 for (i = 0; i < o->nb_metadata; i++) {
4307 const char *stream_spec;
4308 int index = 0, j, ret;
4310 val = strchr(o->metadata[i].u.str, '=');
4312 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4313 o->metadata[i].u.str);
4318 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4320 for (j = 0; j < oc->nb_streams; j++) {
4321 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4322 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4326 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4334 if (index < 0 || index >= oc->nb_chapters) {
4335 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4338 m = &oc->chapters[index]->metadata;
4341 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4344 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4348 reset_options(o, 0);
4351 /* same option as mencoder */
4352 static int opt_pass(const char *opt, const char *arg)
4354 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4358 static int64_t getutime(void)
4361 struct rusage rusage;
4363 getrusage(RUSAGE_SELF, &rusage);
4364 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4365 #elif HAVE_GETPROCESSTIMES
4367 FILETIME c, e, k, u;
4368 proc = GetCurrentProcess();
4369 GetProcessTimes(proc, &c, &e, &k, &u);
4370 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4372 return av_gettime();
4376 static int64_t getmaxrss(void)
4378 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4379 struct rusage rusage;
4380 getrusage(RUSAGE_SELF, &rusage);
4381 return (int64_t)rusage.ru_maxrss * 1024;
4382 #elif HAVE_GETPROCESSMEMORYINFO
4384 PROCESS_MEMORY_COUNTERS memcounters;
4385 proc = GetCurrentProcess();
4386 memcounters.cb = sizeof(memcounters);
4387 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4388 return memcounters.PeakPagefileUsage;
4394 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4396 return parse_option(o, "q:a", arg, options);
4399 static void show_usage(void)
4401 printf("Hyper fast Audio and Video encoder\n");
4402 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4406 static int opt_help(const char *opt, const char *arg)
4408 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4409 av_log_set_callback(log_callback_help);
4411 show_help_options(options, "Main options:\n",
4412 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4413 show_help_options(options, "\nAdvanced options:\n",
4414 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4416 show_help_options(options, "\nVideo options:\n",
4417 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4419 show_help_options(options, "\nAdvanced Video options:\n",
4420 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4421 OPT_VIDEO | OPT_EXPERT);
4422 show_help_options(options, "\nAudio options:\n",
4423 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4425 show_help_options(options, "\nAdvanced Audio options:\n",
4426 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4427 OPT_AUDIO | OPT_EXPERT);
4428 show_help_options(options, "\nSubtitle options:\n",
4429 OPT_SUBTITLE | OPT_GRAB,
4431 show_help_options(options, "\nAudio/Video grab options:\n",
4435 show_help_children(avcodec_get_class(), flags);
4436 show_help_children(avformat_get_class(), flags);
4437 show_help_children(sws_get_class(), flags);
4442 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4444 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4445 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4447 if(!strncmp(arg, "pal-", 4)) {
4450 } else if(!strncmp(arg, "ntsc-", 5)) {
4453 } else if(!strncmp(arg, "film-", 5)) {
4457 /* Try to determine PAL/NTSC by peeking in the input files */
4458 if(nb_input_files) {
4460 for (j = 0; j < nb_input_files; j++) {
4461 for (i = 0; i < input_files[j].nb_streams; i++) {
4462 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4463 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4465 fr = c->time_base.den * 1000 / c->time_base.num;
4469 } else if((fr == 29970) || (fr == 23976)) {
4478 if (norm != UNKNOWN)
4479 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4482 if(norm == UNKNOWN) {
4483 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4484 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4485 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4489 if(!strcmp(arg, "vcd")) {
4490 opt_video_codec(o, "c:v", "mpeg1video");
4491 opt_audio_codec(o, "c:a", "mp2");
4492 parse_option(o, "f", "vcd", options);
4494 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4495 parse_option(o, "r", frame_rates[norm], options);
4496 opt_default("g", norm == PAL ? "15" : "18");
4498 opt_default("b:v", "1150000");
4499 opt_default("maxrate", "1150000");
4500 opt_default("minrate", "1150000");
4501 opt_default("bufsize", "327680"); // 40*1024*8;
4503 opt_default("b:a", "224000");
4504 parse_option(o, "ar", "44100", options);
4505 parse_option(o, "ac", "2", options);
4507 opt_default("packetsize", "2324");
4508 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4510 /* We have to offset the PTS, so that it is consistent with the SCR.
4511 SCR starts at 36000, but the first two packs contain only padding
4512 and the first pack from the other stream, respectively, may also have
4513 been written before.
4514 So the real data starts at SCR 36000+3*1200. */
4515 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4516 } else if(!strcmp(arg, "svcd")) {
4518 opt_video_codec(o, "c:v", "mpeg2video");
4519 opt_audio_codec(o, "c:a", "mp2");
4520 parse_option(o, "f", "svcd", options);
4522 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4523 parse_option(o, "r", frame_rates[norm], options);
4524 parse_option(o, "pix_fmt", "yuv420p", options);
4525 opt_default("g", norm == PAL ? "15" : "18");
4527 opt_default("b:v", "2040000");
4528 opt_default("maxrate", "2516000");
4529 opt_default("minrate", "0"); //1145000;
4530 opt_default("bufsize", "1835008"); //224*1024*8;
4531 opt_default("flags", "+scan_offset");
4534 opt_default("b:a", "224000");
4535 parse_option(o, "ar", "44100", options);
4537 opt_default("packetsize", "2324");
4539 } else if(!strcmp(arg, "dvd")) {
4541 opt_video_codec(o, "c:v", "mpeg2video");
4542 opt_audio_codec(o, "c:a", "ac3");
4543 parse_option(o, "f", "dvd", options);
4545 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4546 parse_option(o, "r", frame_rates[norm], options);
4547 parse_option(o, "pix_fmt", "yuv420p", options);
4548 opt_default("g", norm == PAL ? "15" : "18");
4550 opt_default("b:v", "6000000");
4551 opt_default("maxrate", "9000000");
4552 opt_default("minrate", "0"); //1500000;
4553 opt_default("bufsize", "1835008"); //224*1024*8;
4555 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4556 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4558 opt_default("b:a", "448000");
4559 parse_option(o, "ar", "48000", options);
4561 } else if(!strncmp(arg, "dv", 2)) {
4563 parse_option(o, "f", "dv", options);
4565 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4566 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4567 norm == PAL ? "yuv420p" : "yuv411p", options);
4568 parse_option(o, "r", frame_rates[norm], options);
4570 parse_option(o, "ar", "48000", options);
4571 parse_option(o, "ac", "2", options);
4574 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4575 return AVERROR(EINVAL);
4580 static int opt_vstats_file(const char *opt, const char *arg)
4582 av_free (vstats_filename);
4583 vstats_filename=av_strdup (arg);
4587 static int opt_vstats(const char *opt, const char *arg)
4590 time_t today2 = time(NULL);
4591 struct tm *today = localtime(&today2);
4593 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4595 return opt_vstats_file(opt, filename);
4598 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4600 return parse_option(o, "frames:v", arg, options);
4603 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4605 return parse_option(o, "frames:a", arg, options);
4608 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4610 return parse_option(o, "frames:d", arg, options);
4613 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4616 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4617 const char *codec_name = *opt == 'v' ? video_codec_name :
4618 *opt == 'a' ? audio_codec_name :
4619 subtitle_codec_name;
4621 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4622 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4623 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4625 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4630 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4631 if(line[0] == '#' && !e)
4633 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4635 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4638 if(!strcmp(tmp, "acodec")){
4639 opt_audio_codec(o, tmp, tmp2);
4640 }else if(!strcmp(tmp, "vcodec")){
4641 opt_video_codec(o, tmp, tmp2);
4642 }else if(!strcmp(tmp, "scodec")){
4643 opt_subtitle_codec(o, tmp, tmp2);
4644 }else if(!strcmp(tmp, "dcodec")){
4645 opt_data_codec(o, tmp, tmp2);
4646 }else if(opt_default(tmp, tmp2) < 0){
4647 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4657 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4661 static int opt_passlogfile(const char *opt, const char *arg)
4663 pass_logfilename_prefix = arg;
4664 #if CONFIG_LIBX264_ENCODER
4665 return opt_default("passlogfile", arg);
4671 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4673 char *s= av_malloc(strlen(opt)+2);
4674 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4675 return parse_option(o, s, arg, options);
4678 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4680 if(!strcmp(opt, "b")){
4681 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4682 return parse_option(o, av_strdup("b:v"), arg, options);
4684 return opt_default(opt, arg);
4687 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4689 return parse_option(o, "filter:v", arg, options);
4692 #define OFFSET(x) offsetof(OptionsContext, x)
4693 static const OptionDef options[] = {
4695 #include "cmdutils_common_opts.h"
4696 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4697 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4698 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4699 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4700 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4701 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4702 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4703 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4704 { "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]" },
4705 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4706 "outfile[,metadata]:infile[,metadata]" },
4707 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4708 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4709 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4710 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4711 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4712 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4713 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4714 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4715 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4716 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4717 "add timings for benchmarking" },
4718 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4719 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4720 "dump each input packet" },
4721 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4722 "when dumping packets, also dump the payload" },
4723 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4724 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4725 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4726 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4727 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4728 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4729 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4730 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4731 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
4732 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4733 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4734 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4735 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4736 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4737 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4738 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4739 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4741 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4743 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4744 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4745 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4748 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4749 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4750 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4751 { "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" },
4752 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4753 { "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" },
4754 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4755 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4756 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4757 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4758 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4759 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4760 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4761 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4762 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4763 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4764 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4765 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4766 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4767 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4768 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4769 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4770 "use same quantizer as source (implies VBR)" },
4771 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4772 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4773 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4774 "deinterlace pictures" },
4775 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4776 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4777 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4779 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4781 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4782 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4783 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4784 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4785 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4786 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4787 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4788 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4789 { "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" },
4790 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4793 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4794 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4795 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4796 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4797 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4798 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4799 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4800 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4801 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4802 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4804 /* subtitle options */
4805 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4806 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4807 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4810 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4811 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4812 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4815 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4816 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4818 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4819 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4820 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4822 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4823 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4824 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4825 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4826 /* data codec support */
4827 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4828 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
4830 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4834 int main(int argc, char **argv)
4836 OptionsContext o = { 0 };
4839 reset_options(&o, 0);
4841 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4842 parse_loglevel(argc, argv, options);
4844 if(argc>1 && !strcmp(argv[1], "-d")){
4846 av_log_set_callback(log_callback_null);
4851 avcodec_register_all();
4853 avdevice_register_all();
4856 avfilter_register_all();
4859 avformat_network_init();
4861 show_banner(argc, argv, options);
4866 parse_options(&o, argc, argv, options, opt_output_file);
4868 if(nb_output_files <= 0 && nb_input_files == 0) {
4870 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4874 /* file converter / grab */
4875 if (nb_output_files <= 0) {
4876 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4880 if (nb_input_files == 0) {
4881 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4886 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4888 ti = getutime() - ti;
4890 int maxrss = getmaxrss() / 1024;
4891 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);