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 * select an input file for an output file
105 typedef struct MetadataMap {
106 int file; ///< file index
107 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
108 int index; ///< stream/chapter/program number
111 static const OptionDef options[];
113 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
115 static int frame_bits_per_raw_sample = 0;
116 static int video_discard = 0;
117 static int same_quant = 0;
118 static int do_deinterlace = 0;
119 static int intra_dc_precision = 8;
120 static int loop_input = 0;
121 static int loop_output = AVFMT_NOOUTPUTLOOP;
122 static int qp_hist = 0;
123 static int intra_only = 0;
124 static const char *video_codec_name = NULL;
125 static const char *audio_codec_name = NULL;
126 static const char *subtitle_codec_name = NULL;
128 static int file_overwrite = 0;
129 static int do_benchmark = 0;
130 static int do_hex_dump = 0;
131 static int do_pkt_dump = 0;
132 static int do_pass = 0;
133 static const char *pass_logfilename_prefix;
134 static int video_sync_method= -1;
135 static int audio_sync_method= 0;
136 static float audio_drift_threshold= 0.1;
137 static int copy_ts= 0;
138 static int copy_tb= 0;
139 static int opt_shortest = 0;
140 static char *vstats_filename;
141 static FILE *vstats_file;
142 static int copy_initial_nonkeyframes = 0;
144 static int audio_volume = 256;
146 static int exit_on_error = 0;
147 static int using_stdin = 0;
148 static int run_as_daemon = 0;
149 static volatile int received_nb_signals = 0;
150 static int64_t video_size = 0;
151 static int64_t audio_size = 0;
152 static int64_t extra_size = 0;
153 static int nb_frames_dup = 0;
154 static int nb_frames_drop = 0;
155 static int input_sync;
157 static float dts_delta_threshold = 10;
159 static int print_stats = 1;
161 static uint8_t *audio_buf;
162 static uint8_t *audio_out;
163 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
165 static void *samples;
166 static uint8_t *input_tmp= NULL;
168 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
170 typedef struct InputStream {
173 int discard; /* true if stream data should be discarded */
174 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
177 int64_t start; /* time when read started */
178 int64_t next_pts; /* synthetic pts for cases where pkt.pts
180 int64_t pts; /* current pts */
182 int is_start; /* is 1 at the start and after a discontinuity */
183 int showed_multi_packet_warning;
187 typedef struct InputFile {
188 AVFormatContext *ctx;
189 int eof_reached; /* true if eof reached */
190 int ist_index; /* index of first stream in input_streams */
191 int buffer_size; /* current total buffer size */
193 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
194 from ctx.nb_streams if new streams appear during av_read_frame() */
198 typedef struct OutputStream {
199 int file_index; /* file index */
200 int index; /* stream index in the output file */
201 int source_index; /* InputStream index */
202 AVStream *st; /* stream in the output file */
203 int encoding_needed; /* true if encoding needed for this stream */
205 /* input pts and corresponding output pts
207 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
208 struct InputStream *sync_ist; /* input stream to sync against */
209 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
210 AVBitStreamFilterContext *bitstream_filters;
216 AVFrame resample_frame; /* temporary frame for image resampling */
217 struct SwsContext *img_resample_ctx; /* for image resampling */
220 int resample_pix_fmt;
221 AVRational frame_rate;
225 float frame_aspect_ratio;
227 /* forced key frames */
228 int64_t *forced_kf_pts;
234 int resample_sample_fmt;
235 int resample_channels;
236 int resample_sample_rate;
237 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
240 struct SwrContext *swr;
243 AVFilterContext *output_video_filter;
244 AVFilterContext *input_video_filter;
245 AVFilterBufferRef *picref;
247 AVFilterGraph *graph;
252 int is_past_recording_time;
258 /* init terminal so that we can grab keys */
259 static struct termios oldtty;
262 typedef struct OutputFile {
263 AVFormatContext *ctx;
265 int ost_index; /* index of the first stream in output_streams */
266 int64_t recording_time; /* desired length of the resulting file in microseconds */
267 int64_t start_time; /* start time in microseconds */
268 uint64_t limit_filesize;
271 static InputStream *input_streams = NULL;
272 static int nb_input_streams = 0;
273 static InputFile *input_files = NULL;
274 static int nb_input_files = 0;
276 static OutputStream *output_streams = NULL;
277 static int nb_output_streams = 0;
278 static OutputFile *output_files = NULL;
279 static int nb_output_files = 0;
281 typedef struct OptionsContext {
282 /* input/output options */
286 SpecifierOpt *codec_names;
288 SpecifierOpt *audio_channels;
289 int nb_audio_channels;
290 SpecifierOpt *audio_sample_rate;
291 int nb_audio_sample_rate;
292 SpecifierOpt *frame_rates;
294 SpecifierOpt *frame_sizes;
296 SpecifierOpt *frame_pix_fmts;
297 int nb_frame_pix_fmts;
300 int64_t input_ts_offset;
303 SpecifierOpt *ts_scale;
307 StreamMap *stream_maps;
309 /* first item specifies output metadata, second is input */
310 MetadataMap (*meta_data_maps)[2];
311 int nb_meta_data_maps;
312 int metadata_global_manual;
313 int metadata_streams_manual;
314 int metadata_chapters_manual;
316 int chapters_input_file;
318 int64_t recording_time;
319 uint64_t limit_filesize;
325 int subtitle_disable;
328 /* indexed by output file stream index */
332 SpecifierOpt *metadata;
334 SpecifierOpt *max_frames;
336 SpecifierOpt *bitstream_filters;
337 int nb_bitstream_filters;
338 SpecifierOpt *codec_tags;
340 SpecifierOpt *sample_fmts;
342 SpecifierOpt *qscale;
344 SpecifierOpt *forced_key_frames;
345 int nb_forced_key_frames;
346 SpecifierOpt *force_fps;
348 SpecifierOpt *frame_aspect_ratios;
349 int nb_frame_aspect_ratios;
350 SpecifierOpt *rc_overrides;
352 SpecifierOpt *intra_matrices;
353 int nb_intra_matrices;
354 SpecifierOpt *inter_matrices;
355 int nb_inter_matrices;
356 SpecifierOpt *top_field_first;
357 int nb_top_field_first;
358 SpecifierOpt *presets;
361 SpecifierOpt *filters;
366 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
369 for (i = 0; i < o->nb_ ## name; i++) {\
370 char *spec = o->name[i].specifier;\
371 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
372 outvar = o->name[i].u.type;\
378 static void reset_options(OptionsContext *o, int is_input)
380 const OptionDef *po = options;
381 OptionsContext bak= *o;
383 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
385 void *dst = (uint8_t*)o + po->u.off;
387 if (po->flags & OPT_SPEC) {
388 SpecifierOpt **so = dst;
389 int i, *count = (int*)(so + 1);
390 for (i = 0; i < *count; i++) {
391 av_freep(&(*so)[i].specifier);
392 if (po->flags & OPT_STRING)
393 av_freep(&(*so)[i].u.str);
397 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
402 av_freep(&o->stream_maps);
403 av_freep(&o->meta_data_maps);
404 av_freep(&o->streamid_map);
406 memset(o, 0, sizeof(*o));
408 if(is_input) o->recording_time = bak.recording_time;
409 else o->recording_time = INT64_MAX;
410 o->mux_preload = 0.5;
411 o->mux_max_delay = 0.7;
412 o->limit_filesize = UINT64_MAX;
413 o->chapters_input_file = INT_MAX;
421 static int configure_video_filters(InputStream *ist, OutputStream *ost)
423 AVFilterContext *last_filter, *filter;
424 /** filter graph containing all filters including input & output */
425 AVCodecContext *codec = ost->st->codec;
426 AVCodecContext *icodec = ist->st->codec;
427 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
428 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
429 AVRational sample_aspect_ratio;
433 ost->graph = avfilter_graph_alloc();
435 if (ist->st->sample_aspect_ratio.num){
436 sample_aspect_ratio = ist->st->sample_aspect_ratio;
438 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
440 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
441 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
442 sample_aspect_ratio.num, sample_aspect_ratio.den);
444 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
445 "src", args, NULL, ost->graph);
448 #if FF_API_OLD_VSINK_API
449 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
450 "out", NULL, pix_fmts, ost->graph);
452 buffersink_params->pixel_fmts = pix_fmts;
453 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
454 "out", NULL, buffersink_params, ost->graph);
456 av_freep(&buffersink_params);
459 last_filter = ost->input_video_filter;
461 if (codec->width != icodec->width || codec->height != icodec->height) {
462 snprintf(args, 255, "%d:%d:flags=0x%X",
465 (unsigned)ost->sws_flags);
466 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
467 NULL, args, NULL, ost->graph)) < 0)
469 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
471 last_filter = filter;
474 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
475 ost->graph->scale_sws_opts = av_strdup(args);
478 AVFilterInOut *outputs = avfilter_inout_alloc();
479 AVFilterInOut *inputs = avfilter_inout_alloc();
481 outputs->name = av_strdup("in");
482 outputs->filter_ctx = last_filter;
483 outputs->pad_idx = 0;
484 outputs->next = NULL;
486 inputs->name = av_strdup("out");
487 inputs->filter_ctx = ost->output_video_filter;
491 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
493 av_freep(&ost->avfilter);
495 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
499 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
502 codec->width = ost->output_video_filter->inputs[0]->w;
503 codec->height = ost->output_video_filter->inputs[0]->h;
504 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
505 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
506 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
507 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
511 #endif /* CONFIG_AVFILTER */
513 static void term_exit(void)
515 av_log(NULL, AV_LOG_QUIET, "%s", "");
518 tcsetattr (0, TCSANOW, &oldtty);
522 static volatile int received_sigterm = 0;
524 static void sigterm_handler(int sig)
526 received_sigterm = sig;
527 received_nb_signals++;
531 static void term_init(void)
541 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
542 |INLCR|IGNCR|ICRNL|IXON);
543 tty.c_oflag |= OPOST;
544 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
545 tty.c_cflag &= ~(CSIZE|PARENB);
550 tcsetattr (0, TCSANOW, &tty);
551 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
555 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
556 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
558 signal(SIGXCPU, sigterm_handler);
562 /* read a key without blocking */
563 static int read_key(void)
575 n = select(1, &rfds, NULL, NULL, &tv);
584 # if HAVE_PEEKNAMEDPIPE
586 static HANDLE input_handle;
589 input_handle = GetStdHandle(STD_INPUT_HANDLE);
590 is_pipe = !GetConsoleMode(input_handle, &dw);
593 if (stdin->_cnt > 0) {
598 /* When running under a GUI, you will end here. */
599 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
616 static int decode_interrupt_cb(void)
618 return received_nb_signals > 1;
621 void exit_program(int ret)
626 for(i=0;i<nb_output_files;i++) {
627 AVFormatContext *s = output_files[i].ctx;
628 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
630 avformat_free_context(s);
631 av_dict_free(&output_files[i].opts);
633 for(i=0;i<nb_input_files;i++) {
634 av_close_input_file(input_files[i].ctx);
636 for (i = 0; i < nb_input_streams; i++)
637 av_dict_free(&input_streams[i].opts);
641 av_free(vstats_filename);
643 av_freep(&input_streams);
644 av_freep(&input_files);
645 av_freep(&output_streams);
646 av_freep(&output_files);
651 allocated_audio_buf_size= allocated_audio_out_size= 0;
658 av_freep(&input_tmp);
660 if (received_sigterm) {
661 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
662 (int) received_sigterm);
666 exit(ret); /* not all OS-es handle main() return value */
669 static void assert_avoptions(AVDictionary *m)
671 AVDictionaryEntry *t;
672 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
673 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
678 static void assert_codec_experimental(AVCodecContext *c, int encoder)
680 const char *codec_string = encoder ? "encoder" : "decoder";
682 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
683 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
684 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
685 "results.\nAdd '-strict experimental' if you want to use it.\n",
686 codec_string, c->codec->name);
687 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
688 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
689 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
690 codec_string, codec->name);
695 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
697 if(codec && codec->sample_fmts){
698 const enum AVSampleFormat *p= codec->sample_fmts;
700 if(*p == st->codec->sample_fmt)
704 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
705 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
706 if(av_get_sample_fmt_name(st->codec->sample_fmt))
707 av_log(NULL, AV_LOG_WARNING,
708 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
709 av_get_sample_fmt_name(st->codec->sample_fmt),
711 av_get_sample_fmt_name(codec->sample_fmts[0]));
712 st->codec->sample_fmt = codec->sample_fmts[0];
717 static void choose_sample_rate(AVStream *st, AVCodec *codec)
719 if(codec && codec->supported_samplerates){
720 const int *p= codec->supported_samplerates;
722 int best_dist=INT_MAX;
724 int dist= abs(st->codec->sample_rate - *p);
725 if(dist < best_dist){
731 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
733 st->codec->sample_rate= best;
737 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
739 if(codec && codec->pix_fmts){
740 const enum PixelFormat *p= codec->pix_fmts;
741 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
742 if(st->codec->codec_id==CODEC_ID_MJPEG){
743 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
744 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
745 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};
749 if(*p == st->codec->pix_fmt)
753 if(st->codec->pix_fmt != PIX_FMT_NONE)
754 av_log(NULL, AV_LOG_WARNING,
755 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
756 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
758 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
759 st->codec->pix_fmt = codec->pix_fmts[0];
764 static double get_sync_ipts(const OutputStream *ost)
766 const InputStream *ist = ost->sync_ist;
767 OutputFile *of = &output_files[ost->file_index];
768 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
771 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
776 AVPacket new_pkt= *pkt;
777 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
778 &new_pkt.data, &new_pkt.size,
779 pkt->data, pkt->size,
780 pkt->flags & AV_PKT_FLAG_KEY);
783 new_pkt.destruct= av_destruct_packet;
785 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
786 bsfc->filter->name, pkt->stream_index,
787 avctx->codec ? avctx->codec->name : "copy");
797 ret= av_interleaved_write_frame(s, pkt);
799 print_error("av_interleaved_write_frame()", ret);
804 static void do_audio_out(AVFormatContext *s,
807 unsigned char *buf, int size)
810 int64_t audio_out_size, audio_buf_size;
811 int64_t allocated_for_size= size;
813 int size_out, frame_bytes, ret, resample_changed;
814 AVCodecContext *enc= ost->st->codec;
815 AVCodecContext *dec= ist->st->codec;
816 int osize = av_get_bytes_per_sample(enc->sample_fmt);
817 int isize = av_get_bytes_per_sample(dec->sample_fmt);
818 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
821 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
822 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
823 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
824 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
825 audio_buf_size*= osize*enc->channels;
827 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
828 if(coded_bps > 8*osize)
829 audio_out_size= audio_out_size * coded_bps / (8*osize);
830 audio_out_size += FF_MIN_BUFFER_SIZE;
832 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
833 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
837 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
838 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
839 if (!audio_buf || !audio_out){
840 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
844 if (enc->channels != dec->channels
845 || enc->sample_fmt != dec->sample_fmt)
846 ost->audio_resample = 1;
848 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
849 ost->resample_channels != dec->channels ||
850 ost->resample_sample_rate != dec->sample_rate;
852 if ((ost->audio_resample && !ost->swr) || resample_changed) {
853 if (resample_changed) {
854 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",
855 ist->file_index, ist->st->index,
856 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
857 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
858 ost->resample_sample_fmt = dec->sample_fmt;
859 ost->resample_channels = dec->channels;
860 ost->resample_sample_rate = dec->sample_rate;
863 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
864 if (audio_sync_method <= 1 &&
865 ost->resample_sample_fmt == enc->sample_fmt &&
866 ost->resample_channels == enc->channels &&
867 ost->resample_sample_rate == enc->sample_rate) {
869 ost->audio_resample = 0;
871 ost->swr = swr_alloc2(ost->swr,
872 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
873 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
875 av_set_int(ost->swr, "ich", dec->channels);
876 av_set_int(ost->swr, "och", enc->channels);
877 if(audio_sync_method>1) av_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE);
878 if(ost->swr && swr_init(ost->swr) < 0){
879 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
884 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
885 dec->channels, dec->sample_rate,
886 enc->channels, enc->sample_rate);
892 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
894 if(audio_sync_method){
895 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
896 - av_fifo_size(ost->fifo)/(enc->channels * 2);
897 double idelta= delta*dec->sample_rate / enc->sample_rate;
898 int byte_delta= ((int)idelta)*2*dec->channels;
900 //FIXME resample delay
901 if(fabs(delta) > 50){
902 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
904 byte_delta= FFMAX(byte_delta, -size);
907 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
912 input_tmp= av_realloc(input_tmp, byte_delta + size);
914 if(byte_delta > allocated_for_size - size){
915 allocated_for_size= byte_delta + (int64_t)size;
920 memset(input_tmp, 0, byte_delta);
921 memcpy(input_tmp + byte_delta, buf, size);
924 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
926 }else if(audio_sync_method>1){
927 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
928 av_assert0(ost->audio_resample);
929 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
930 delta, comp, enc->sample_rate);
931 // 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));
932 swr_compensate(ost->swr, comp, enc->sample_rate);
936 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
937 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
939 if (ost->audio_resample) {
941 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
942 (const uint8_t*[]){buf }, size / (dec->channels * isize));
943 size_out = size_out * enc->channels * osize;
949 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
951 /* now encode as many frames as possible */
952 if (enc->frame_size > 1) {
953 /* output resampled raw samples */
954 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
955 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
958 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
960 frame_bytes = enc->frame_size * osize * enc->channels;
962 while (av_fifo_size(ost->fifo) >= frame_bytes) {
964 av_init_packet(&pkt);
966 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
968 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
970 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
973 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
977 pkt.stream_index= ost->index;
980 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
981 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
982 pkt.flags |= AV_PKT_FLAG_KEY;
983 write_frame(s, &pkt, enc, ost->bitstream_filters);
985 ost->sync_opts += enc->frame_size;
989 av_init_packet(&pkt);
991 ost->sync_opts += size_out / (osize * enc->channels);
993 /* output a pcm frame */
994 /* determine the size of the coded buffer */
997 size_out = size_out*coded_bps/8;
999 if(size_out > audio_out_size){
1000 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1004 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1005 ret = avcodec_encode_audio(enc, audio_out, size_out,
1008 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1012 pkt.stream_index= ost->index;
1013 pkt.data= audio_out;
1015 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1016 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1017 pkt.flags |= AV_PKT_FLAG_KEY;
1018 write_frame(s, &pkt, enc, ost->bitstream_filters);
1022 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1024 AVCodecContext *dec;
1025 AVPicture *picture2;
1026 AVPicture picture_tmp;
1029 dec = ist->st->codec;
1031 /* deinterlace : must be done before any resize */
1032 if (do_deinterlace) {
1035 /* create temporary picture */
1036 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1037 buf = av_malloc(size);
1041 picture2 = &picture_tmp;
1042 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1044 if(avpicture_deinterlace(picture2, picture,
1045 dec->pix_fmt, dec->width, dec->height) < 0) {
1046 /* if error, do not deinterlace */
1047 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1056 if (picture != picture2)
1057 *picture = *picture2;
1061 static void do_subtitle_out(AVFormatContext *s,
1067 static uint8_t *subtitle_out = NULL;
1068 int subtitle_out_max_size = 1024 * 1024;
1069 int subtitle_out_size, nb, i;
1070 AVCodecContext *enc;
1073 if (pts == AV_NOPTS_VALUE) {
1074 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1080 enc = ost->st->codec;
1082 if (!subtitle_out) {
1083 subtitle_out = av_malloc(subtitle_out_max_size);
1086 /* Note: DVB subtitle need one packet to draw them and one other
1087 packet to clear them */
1088 /* XXX: signal it in the codec context ? */
1089 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1094 for(i = 0; i < nb; i++) {
1095 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1096 // start_display_time is required to be 0
1097 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1098 sub->end_display_time -= sub->start_display_time;
1099 sub->start_display_time = 0;
1100 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1101 subtitle_out_max_size, sub);
1102 if (subtitle_out_size < 0) {
1103 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1107 av_init_packet(&pkt);
1108 pkt.stream_index = ost->index;
1109 pkt.data = subtitle_out;
1110 pkt.size = subtitle_out_size;
1111 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1112 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1113 /* XXX: the pts correction is handled here. Maybe handling
1114 it in the codec would be better */
1116 pkt.pts += 90 * sub->start_display_time;
1118 pkt.pts += 90 * sub->end_display_time;
1120 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1124 static int bit_buffer_size= 1024*256;
1125 static uint8_t *bit_buffer= NULL;
1127 static void do_video_resample(OutputStream *ost,
1129 AVFrame *in_picture,
1130 AVFrame **out_picture)
1133 *out_picture = in_picture;
1135 AVCodecContext *dec = ist->st->codec;
1136 AVCodecContext *enc = ost->st->codec;
1137 int resample_changed = ost->resample_width != dec->width ||
1138 ost->resample_height != dec->height ||
1139 ost->resample_pix_fmt != dec->pix_fmt;
1141 *out_picture = in_picture;
1142 if (resample_changed) {
1143 av_log(NULL, AV_LOG_INFO,
1144 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1145 ist->file_index, ist->st->index,
1146 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1147 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1148 ost->resample_width = dec->width;
1149 ost->resample_height = dec->height;
1150 ost->resample_pix_fmt = dec->pix_fmt;
1153 ost->video_resample = dec->width != enc->width ||
1154 dec->height != enc->height ||
1155 dec->pix_fmt != enc->pix_fmt;
1157 if (ost->video_resample) {
1158 *out_picture = &ost->resample_frame;
1159 if (!ost->img_resample_ctx || resample_changed) {
1160 /* initialize the destination picture */
1161 if (!ost->resample_frame.data[0]) {
1162 avcodec_get_frame_defaults(&ost->resample_frame);
1163 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1164 enc->width, enc->height)) {
1165 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1169 /* initialize a new scaler context */
1170 sws_freeContext(ost->img_resample_ctx);
1171 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1172 enc->width, enc->height, enc->pix_fmt,
1173 ost->sws_flags, NULL, NULL, NULL);
1174 if (ost->img_resample_ctx == NULL) {
1175 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1179 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1180 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1186 static void do_video_out(AVFormatContext *s,
1189 AVFrame *in_picture,
1190 int *frame_size, float quality)
1192 int nb_frames, i, ret, format_video_sync;
1193 AVFrame *final_picture;
1194 AVCodecContext *enc;
1196 double duration = 0;
1198 enc = ost->st->codec;
1200 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1201 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1202 if(ist->st->avg_frame_rate.num)
1203 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1205 duration /= av_q2d(enc->time_base);
1208 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1210 /* by default, we output a single frame */
1215 format_video_sync = video_sync_method;
1216 if (format_video_sync < 0)
1217 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1219 if (format_video_sync) {
1220 double vdelta = sync_ipts - ost->sync_opts + duration;
1221 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1224 else if (format_video_sync == 2) {
1227 }else if(vdelta>0.6)
1228 ost->sync_opts= lrintf(sync_ipts);
1229 }else if (vdelta > 1.1)
1230 nb_frames = lrintf(vdelta);
1231 //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);
1232 if (nb_frames == 0){
1234 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1235 }else if (nb_frames > 1) {
1236 nb_frames_dup += nb_frames - 1;
1237 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1240 ost->sync_opts= lrintf(sync_ipts);
1242 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1246 do_video_resample(ost, ist, in_picture, &final_picture);
1248 /* duplicates frame if needed */
1249 for(i=0;i<nb_frames;i++) {
1251 av_init_packet(&pkt);
1252 pkt.stream_index= ost->index;
1254 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1255 /* raw pictures are written as AVPicture structure to
1256 avoid any copies. We support temporarily the older
1258 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1259 enc->coded_frame->top_field_first = in_picture->top_field_first;
1260 pkt.data= (uint8_t *)final_picture;
1261 pkt.size= sizeof(AVPicture);
1262 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1263 pkt.flags |= AV_PKT_FLAG_KEY;
1265 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1267 AVFrame big_picture;
1269 big_picture= *final_picture;
1270 /* better than nothing: use input picture interlaced
1272 big_picture.interlaced_frame = in_picture->interlaced_frame;
1273 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1274 if (ost->top_field_first == -1)
1275 big_picture.top_field_first = in_picture->top_field_first;
1277 big_picture.top_field_first = !!ost->top_field_first;
1280 /* handles same_quant here. This is not correct because it may
1281 not be a global option */
1282 big_picture.quality = quality;
1283 if (!enc->me_threshold)
1284 big_picture.pict_type = 0;
1285 // big_picture.pts = AV_NOPTS_VALUE;
1286 big_picture.pts= ost->sync_opts;
1287 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1288 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1289 if (ost->forced_kf_index < ost->forced_kf_count &&
1290 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1291 big_picture.pict_type = AV_PICTURE_TYPE_I;
1292 ost->forced_kf_index++;
1294 ret = avcodec_encode_video(enc,
1295 bit_buffer, bit_buffer_size,
1298 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1303 pkt.data= bit_buffer;
1305 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1306 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1307 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1308 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1309 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1311 if(enc->coded_frame->key_frame)
1312 pkt.flags |= AV_PKT_FLAG_KEY;
1313 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1316 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1317 // enc->frame_number-1, ret, enc->pict_type);
1318 /* if two pass, output log */
1319 if (ost->logfile && enc->stats_out) {
1320 fprintf(ost->logfile, "%s", enc->stats_out);
1325 ost->frame_number++;
1329 static double psnr(double d)
1331 return -10.0*log(d)/log(10.0);
1334 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1337 AVCodecContext *enc;
1339 double ti1, bitrate, avg_bitrate;
1341 /* this is executed just the first time do_video_stats is called */
1343 vstats_file = fopen(vstats_filename, "w");
1350 enc = ost->st->codec;
1351 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1352 frame_number = ost->frame_number;
1353 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1354 if (enc->flags&CODEC_FLAG_PSNR)
1355 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1357 fprintf(vstats_file,"f_size= %6d ", frame_size);
1358 /* compute pts value */
1359 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1363 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1364 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1365 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1366 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1367 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1371 static void print_report(OutputFile *output_files,
1372 OutputStream *ost_table, int nb_ostreams,
1373 int is_last_report, int64_t timer_start, int64_t cur_time)
1377 AVFormatContext *oc;
1379 AVCodecContext *enc;
1380 int frame_number, vid, i;
1382 int64_t pts = INT64_MAX;
1383 static int64_t last_time = -1;
1384 static int qp_histogram[52];
1385 int hours, mins, secs, us;
1387 if (!print_stats && !is_last_report)
1390 if (!is_last_report) {
1391 if (last_time == -1) {
1392 last_time = cur_time;
1395 if ((cur_time - last_time) < 500000)
1397 last_time = cur_time;
1401 oc = output_files[0].ctx;
1403 total_size = avio_size(oc->pb);
1404 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1405 total_size= avio_tell(oc->pb);
1409 for(i=0;i<nb_ostreams;i++) {
1411 ost = &ost_table[i];
1412 enc = ost->st->codec;
1413 if (!ost->st->stream_copy && enc->coded_frame)
1414 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1415 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1416 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1418 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1419 float t = (cur_time-timer_start) / 1000000.0;
1421 frame_number = ost->frame_number;
1422 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1423 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1425 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1429 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1432 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1434 if (enc->flags&CODEC_FLAG_PSNR){
1436 double error, error_sum=0;
1437 double scale, scale_sum=0;
1438 char type[3]= {'Y','U','V'};
1439 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1442 error= enc->error[j];
1443 scale= enc->width*enc->height*255.0*255.0*frame_number;
1445 error= enc->coded_frame->error[j];
1446 scale= enc->width*enc->height*255.0*255.0;
1451 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1453 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1457 /* compute min output value */
1458 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1459 ost->st->time_base, AV_TIME_BASE_Q));
1462 secs = pts / AV_TIME_BASE;
1463 us = pts % AV_TIME_BASE;
1469 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1471 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1472 "size=%8.0fkB time=", total_size / 1024.0);
1473 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1474 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1475 (100 * us) / AV_TIME_BASE);
1476 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1477 "bitrate=%6.1fkbits/s", bitrate);
1479 if (nb_frames_dup || nb_frames_drop)
1480 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1481 nb_frames_dup, nb_frames_drop);
1483 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1487 if (is_last_report) {
1488 int64_t raw= audio_size + video_size + extra_size;
1489 av_log(NULL, AV_LOG_INFO, "\n");
1490 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1494 100.0*(total_size - raw)/raw
1499 static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
1501 int fill_char = 0x00;
1502 if (sample_fmt == AV_SAMPLE_FMT_U8)
1504 memset(buf, fill_char, size);
1507 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1511 for (i = 0; i < nb_ostreams; i++) {
1512 OutputStream *ost = &ost_table[i];
1513 AVCodecContext *enc = ost->st->codec;
1514 AVFormatContext *os = output_files[ost->file_index].ctx;
1516 if (!ost->encoding_needed)
1519 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1521 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1527 av_init_packet(&pkt);
1528 pkt.stream_index= ost->index;
1530 switch (ost->st->codec->codec_type) {
1531 case AVMEDIA_TYPE_AUDIO:
1532 fifo_bytes = av_fifo_size(ost->fifo);
1534 /* encode any samples remaining in fifo */
1535 if (fifo_bytes > 0) {
1536 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1537 int fs_tmp = enc->frame_size;
1539 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1540 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1541 enc->frame_size = fifo_bytes / (osize * enc->channels);
1543 int frame_bytes = enc->frame_size*osize*enc->channels;
1544 if (allocated_audio_buf_size < frame_bytes)
1546 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1549 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1550 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1551 ost->st->time_base.num, enc->sample_rate);
1552 enc->frame_size = fs_tmp;
1555 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1558 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1562 pkt.flags |= AV_PKT_FLAG_KEY;
1564 case AVMEDIA_TYPE_VIDEO:
1565 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1567 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1571 if(enc->coded_frame && enc->coded_frame->key_frame)
1572 pkt.flags |= AV_PKT_FLAG_KEY;
1573 if (ost->logfile && enc->stats_out) {
1574 fprintf(ost->logfile, "%s", enc->stats_out);
1583 pkt.data = bit_buffer;
1585 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1586 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1587 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1592 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1593 static int output_packet(InputStream *ist, int ist_index,
1594 OutputStream *ost_table, int nb_ostreams,
1595 const AVPacket *pkt)
1597 AVFormatContext *os;
1601 void *buffer_to_free = NULL;
1602 static unsigned int samples_size= 0;
1603 AVSubtitle subtitle, *subtitle_to_free;
1604 int64_t pkt_pts = AV_NOPTS_VALUE;
1606 int frame_available;
1611 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1613 if(ist->next_pts == AV_NOPTS_VALUE)
1614 ist->next_pts= ist->pts;
1618 av_init_packet(&avpkt);
1626 if(pkt->dts != AV_NOPTS_VALUE)
1627 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1628 if(pkt->pts != AV_NOPTS_VALUE)
1629 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1631 //while we have more to decode or while the decoder did output something on EOF
1632 while (avpkt.size > 0 || (!pkt && got_output)) {
1633 uint8_t *data_buf, *decoded_data_buf;
1634 int data_size, decoded_data_size;
1635 AVFrame *decoded_frame, *filtered_frame;
1637 ist->pts= ist->next_pts;
1639 if(avpkt.size && avpkt.size != pkt->size)
1640 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1641 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1642 ist->showed_multi_packet_warning=1;
1644 /* decode the packet if needed */
1645 decoded_frame = filtered_frame = NULL;
1646 decoded_data_buf = NULL; /* fail safe */
1647 decoded_data_size= 0;
1648 data_buf = avpkt.data;
1649 data_size = avpkt.size;
1650 subtitle_to_free = NULL;
1651 if (ist->decoding_needed) {
1652 switch(ist->st->codec->codec_type) {
1653 case AVMEDIA_TYPE_AUDIO:{
1654 if(pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1655 samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1657 samples= av_malloc(samples_size);
1659 decoded_data_size= samples_size;
1660 /* XXX: could avoid copy if PCM 16 bits with same
1661 endianness as CPU */
1662 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1669 got_output = decoded_data_size > 0;
1670 /* Some bug in mpeg audio decoder gives */
1671 /* decoded_data_size < 0, it seems they are overflows */
1673 /* no audio frame */
1676 decoded_data_buf = (uint8_t *)samples;
1677 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1678 (ist->st->codec->sample_rate * ist->st->codec->channels);
1680 case AVMEDIA_TYPE_VIDEO:
1681 if (!(decoded_frame = avcodec_alloc_frame()))
1682 return AVERROR(ENOMEM);
1683 avpkt.pts = pkt_pts;
1684 avpkt.dts = ist->pts;
1685 pkt_pts = AV_NOPTS_VALUE;
1687 ret = avcodec_decode_video2(ist->st->codec,
1688 decoded_frame, &got_output, &avpkt);
1689 quality = same_quant ? decoded_frame->quality : 0;
1693 /* no picture yet */
1694 av_freep(&decoded_frame);
1695 goto discard_packet;
1697 ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
1698 if (ist->st->codec->time_base.num != 0) {
1699 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1700 ist->next_pts += ((int64_t)AV_TIME_BASE *
1701 ist->st->codec->time_base.num * ticks) /
1702 ist->st->codec->time_base.den;
1705 buffer_to_free = NULL;
1706 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1708 case AVMEDIA_TYPE_SUBTITLE:
1709 ret = avcodec_decode_subtitle2(ist->st->codec,
1710 &subtitle, &got_output, &avpkt);
1714 goto discard_packet;
1716 subtitle_to_free = &subtitle;
1723 switch(ist->st->codec->codec_type) {
1724 case AVMEDIA_TYPE_AUDIO:
1725 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1726 ist->st->codec->sample_rate;
1728 case AVMEDIA_TYPE_VIDEO:
1729 if (ist->st->codec->time_base.num != 0) {
1730 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1731 ist->next_pts += ((int64_t)AV_TIME_BASE *
1732 ist->st->codec->time_base.num * ticks) /
1733 ist->st->codec->time_base.den;
1741 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1742 for(i=0;i<nb_ostreams;i++) {
1743 OutputFile *of = &output_files[ost_table[i].file_index];
1744 if (of->start_time == 0 || ist->pts >= of->start_time) {
1745 ost = &ost_table[i];
1746 if (ost->input_video_filter && ost->source_index == ist_index) {
1747 if (!decoded_frame->sample_aspect_ratio.num)
1748 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1749 decoded_frame->pts = ist->pts;
1751 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
1757 // preprocess audio (volume)
1758 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1759 if (audio_volume != 256) {
1760 switch (ist->st->codec->sample_fmt) {
1761 case AV_SAMPLE_FMT_U8:
1763 uint8_t *volp = samples;
1764 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1765 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1766 *volp++ = av_clip_uint8(v);
1770 case AV_SAMPLE_FMT_S16:
1772 int16_t *volp = samples;
1773 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1774 int v = ((*volp) * audio_volume + 128) >> 8;
1775 *volp++ = av_clip_int16(v);
1779 case AV_SAMPLE_FMT_S32:
1781 int32_t *volp = samples;
1782 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1783 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1784 *volp++ = av_clipl_int32(v);
1788 case AV_SAMPLE_FMT_FLT:
1790 float *volp = samples;
1791 float scale = audio_volume / 256.f;
1792 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1797 case AV_SAMPLE_FMT_DBL:
1799 double *volp = samples;
1800 double scale = audio_volume / 256.;
1801 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1807 av_log(NULL, AV_LOG_FATAL,
1808 "Audio volume adjustment on sample format %s is not supported.\n",
1809 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1815 /* frame rate emulation */
1816 if (input_files[ist->file_index].rate_emu) {
1817 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1818 int64_t now = av_gettime() - ist->start;
1822 /* if output time reached then transcode raw format,
1823 encode packets and output them */
1824 for (i = 0; i < nb_ostreams; i++) {
1825 OutputFile *of = &output_files[ost_table[i].file_index];
1828 ost = &ost_table[i];
1829 if (ost->source_index != ist_index)
1832 if (of->start_time && ist->pts < of->start_time)
1835 if (of->recording_time != INT64_MAX &&
1836 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1837 (AVRational){1, 1000000}) >= 0) {
1838 ost->is_past_recording_time = 1;
1843 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1844 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1845 while (frame_available) {
1846 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1847 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1848 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1850 if (!filtered_frame && !(filtered_frame = avcodec_alloc_frame())) {
1851 ret = AVERROR(ENOMEM);
1854 *filtered_frame= *decoded_frame; //for me_threshold
1856 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
1857 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1861 filtered_frame = decoded_frame;
1863 os = output_files[ost->file_index].ctx;
1865 /* set the input output pts pairs */
1866 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1868 if (ost->encoding_needed) {
1869 av_assert0(ist->decoding_needed);
1870 switch(ost->st->codec->codec_type) {
1871 case AVMEDIA_TYPE_AUDIO:
1872 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1874 case AVMEDIA_TYPE_VIDEO:
1876 if (ost->picref->video && !ost->frame_aspect_ratio)
1877 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1879 do_video_out(os, ost, ist, filtered_frame, &frame_size,
1880 same_quant ? quality : ost->st->codec->global_quality);
1881 if (vstats_filename && frame_size)
1882 do_video_stats(os, ost, frame_size);
1884 case AVMEDIA_TYPE_SUBTITLE:
1885 do_subtitle_out(os, ost, ist, &subtitle,
1894 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1895 av_init_packet(&opkt);
1897 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1898 #if !CONFIG_AVFILTER
1904 /* no reencoding needed : output the packet directly */
1905 /* force the input stream PTS */
1907 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1908 audio_size += data_size;
1909 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1910 video_size += data_size;
1914 opkt.stream_index= ost->index;
1915 if(pkt->pts != AV_NOPTS_VALUE)
1916 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1918 opkt.pts= AV_NOPTS_VALUE;
1920 if (pkt->dts == AV_NOPTS_VALUE)
1921 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1923 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1924 opkt.dts -= ost_tb_start_time;
1926 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1927 opkt.flags= pkt->flags;
1929 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1930 if( ost->st->codec->codec_id != CODEC_ID_H264
1931 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1932 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1934 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1935 opkt.destruct= av_destruct_packet;
1937 opkt.data = data_buf;
1938 opkt.size = data_size;
1941 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1942 /* store AVPicture in AVPacket, as expected by the output format */
1943 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1944 opkt.data = (uint8_t *)&pict;
1945 opkt.size = sizeof(AVPicture);
1946 opkt.flags |= AV_PKT_FLAG_KEY;
1948 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1949 ost->st->codec->frame_number++;
1950 ost->frame_number++;
1951 av_free_packet(&opkt);
1955 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1956 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1957 avfilter_unref_buffer(ost->picref);
1959 av_freep(&filtered_frame);
1964 av_free(buffer_to_free);
1965 /* XXX: allocate the subtitles in the codec ? */
1966 if (subtitle_to_free) {
1967 avsubtitle_free(subtitle_to_free);
1968 subtitle_to_free = NULL;
1970 av_freep(&decoded_frame);
1979 static void print_sdp(OutputFile *output_files, int n)
1983 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1987 for (i = 0; i < n; i++)
1988 avc[i] = output_files[i].ctx;
1990 av_sdp_create(avc, n, sdp, sizeof(sdp));
1991 printf("SDP:\n%s\n", sdp);
1996 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1997 char *error, int error_len)
1999 InputStream *ist = &input_streams[ist_index];
2000 if (ist->decoding_needed) {
2001 AVCodec *codec = ist->dec;
2003 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
2004 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2005 return AVERROR(EINVAL);
2007 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2008 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
2009 ist->file_index, ist->st->index);
2010 return AVERROR(EINVAL);
2012 assert_codec_experimental(ist->st->codec, 0);
2013 assert_avoptions(ist->opts);
2016 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;
2017 ist->next_pts = AV_NOPTS_VALUE;
2023 static int transcode_init(OutputFile *output_files, int nb_output_files,
2024 InputFile *input_files, int nb_input_files)
2026 int ret = 0, i, j, k;
2027 AVFormatContext *os;
2028 AVCodecContext *codec, *icodec;
2034 /* init framerate emulation */
2035 for (i = 0; i < nb_input_files; i++) {
2036 InputFile *ifile = &input_files[i];
2037 if (ifile->rate_emu)
2038 for (j = 0; j < ifile->nb_streams; j++)
2039 input_streams[j + ifile->ist_index].start = av_gettime();
2042 /* output stream init */
2043 for(i=0;i<nb_output_files;i++) {
2044 os = output_files[i].ctx;
2045 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2046 av_dump_format(os, i, os->filename, 1);
2047 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2048 return AVERROR(EINVAL);
2052 /* for each output stream, we compute the right encoding parameters */
2053 for (i = 0; i < nb_output_streams; i++) {
2054 ost = &output_streams[i];
2055 os = output_files[ost->file_index].ctx;
2056 ist = &input_streams[ost->source_index];
2058 codec = ost->st->codec;
2059 icodec = ist->st->codec;
2061 ost->st->disposition = ist->st->disposition;
2062 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2063 codec->chroma_sample_location = icodec->chroma_sample_location;
2065 if (ost->st->stream_copy) {
2066 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2068 if (extra_size > INT_MAX) {
2069 return AVERROR(EINVAL);
2072 /* if stream_copy is selected, no need to decode or encode */
2073 codec->codec_id = icodec->codec_id;
2074 codec->codec_type = icodec->codec_type;
2076 if(!codec->codec_tag){
2077 if( !os->oformat->codec_tag
2078 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2079 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2080 codec->codec_tag = icodec->codec_tag;
2083 codec->bit_rate = icodec->bit_rate;
2084 codec->rc_max_rate = icodec->rc_max_rate;
2085 codec->rc_buffer_size = icodec->rc_buffer_size;
2086 codec->extradata= av_mallocz(extra_size);
2087 if (!codec->extradata) {
2088 return AVERROR(ENOMEM);
2090 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2091 codec->extradata_size= icodec->extradata_size;
2093 codec->time_base = ist->st->time_base;
2094 if(!strcmp(os->oformat->name, "avi")) {
2095 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2096 codec->time_base = icodec->time_base;
2097 codec->time_base.num *= icodec->ticks_per_frame;
2098 codec->time_base.den *= 2;
2100 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2101 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2102 codec->time_base = icodec->time_base;
2103 codec->time_base.num *= icodec->ticks_per_frame;
2106 av_reduce(&codec->time_base.num, &codec->time_base.den,
2107 codec->time_base.num, codec->time_base.den, INT_MAX);
2109 switch(codec->codec_type) {
2110 case AVMEDIA_TYPE_AUDIO:
2111 if(audio_volume != 256) {
2112 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2115 codec->channel_layout = icodec->channel_layout;
2116 codec->sample_rate = icodec->sample_rate;
2117 codec->channels = icodec->channels;
2118 codec->frame_size = icodec->frame_size;
2119 codec->audio_service_type = icodec->audio_service_type;
2120 codec->block_align= icodec->block_align;
2121 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2122 codec->block_align= 0;
2123 if(codec->codec_id == CODEC_ID_AC3)
2124 codec->block_align= 0;
2126 case AVMEDIA_TYPE_VIDEO:
2127 codec->pix_fmt = icodec->pix_fmt;
2128 codec->width = icodec->width;
2129 codec->height = icodec->height;
2130 codec->has_b_frames = icodec->has_b_frames;
2131 if (!codec->sample_aspect_ratio.num) {
2132 codec->sample_aspect_ratio =
2133 ost->st->sample_aspect_ratio =
2134 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2135 ist->st->codec->sample_aspect_ratio.num ?
2136 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2139 case AVMEDIA_TYPE_SUBTITLE:
2140 codec->width = icodec->width;
2141 codec->height = icodec->height;
2143 case AVMEDIA_TYPE_DATA:
2144 case AVMEDIA_TYPE_ATTACHMENT:
2151 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2152 ist->decoding_needed = 1;
2153 ost->encoding_needed = 1;
2154 switch(codec->codec_type) {
2155 case AVMEDIA_TYPE_AUDIO:
2156 ost->fifo= av_fifo_alloc(1024);
2158 return AVERROR(ENOMEM);
2160 if (!codec->sample_rate) {
2161 codec->sample_rate = icodec->sample_rate;
2163 choose_sample_rate(ost->st, ost->enc);
2164 codec->time_base = (AVRational){1, codec->sample_rate};
2165 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2166 codec->sample_fmt = icodec->sample_fmt;
2167 choose_sample_fmt(ost->st, ost->enc);
2168 if (!codec->channels) {
2169 codec->channels = icodec->channels;
2170 codec->channel_layout = icodec->channel_layout;
2172 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2173 codec->channel_layout = 0;
2174 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2175 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2176 || codec->channel_layout != icodec->channel_layout;
2177 icodec->request_channels = codec->channels;
2178 ost->resample_sample_fmt = icodec->sample_fmt;
2179 ost->resample_sample_rate = icodec->sample_rate;
2180 ost->resample_channels = icodec->channels;
2182 case AVMEDIA_TYPE_VIDEO:
2183 if (codec->pix_fmt == PIX_FMT_NONE)
2184 codec->pix_fmt = icodec->pix_fmt;
2185 choose_pixel_fmt(ost->st, ost->enc);
2187 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2188 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2192 if (!codec->width || !codec->height) {
2193 codec->width = icodec->width;
2194 codec->height = icodec->height;
2197 ost->video_resample = codec->width != icodec->width ||
2198 codec->height != icodec->height ||
2199 codec->pix_fmt != icodec->pix_fmt;
2200 if (ost->video_resample) {
2201 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2204 ost->resample_height = icodec->height;
2205 ost->resample_width = icodec->width;
2206 ost->resample_pix_fmt= icodec->pix_fmt;
2208 if (!ost->frame_rate.num)
2209 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2210 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2211 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2212 ost->frame_rate = ost->enc->supported_framerates[idx];
2214 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2215 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2216 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2217 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2218 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2220 for (j = 0; j < ost->forced_kf_count; j++)
2221 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2226 if (configure_video_filters(ist, ost)) {
2227 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2232 case AVMEDIA_TYPE_SUBTITLE:
2239 if (codec->codec_id != CODEC_ID_H264 &&
2240 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2241 char logfilename[1024];
2244 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2245 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2247 if (codec->flags & CODEC_FLAG_PASS1) {
2248 f = fopen(logfilename, "wb");
2250 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2251 logfilename, strerror(errno));
2257 size_t logbuffer_size;
2258 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2259 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2263 codec->stats_in = logbuffer;
2267 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2268 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2269 int size= codec->width * codec->height;
2270 bit_buffer_size= FFMAX(bit_buffer_size, 7*size + 10000);
2275 bit_buffer = av_malloc(bit_buffer_size);
2277 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2279 return AVERROR(ENOMEM);
2282 /* open each encoder */
2283 for (i = 0; i < nb_output_streams; i++) {
2284 ost = &output_streams[i];
2285 if (ost->encoding_needed) {
2286 AVCodec *codec = ost->enc;
2287 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2289 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2290 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2291 ret = AVERROR(EINVAL);
2294 if (dec->subtitle_header) {
2295 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2296 if (!ost->st->codec->subtitle_header) {
2297 ret = AVERROR(ENOMEM);
2300 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2301 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2303 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2304 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2305 ost->file_index, ost->index);
2306 ret = AVERROR(EINVAL);
2309 assert_codec_experimental(ost->st->codec, 1);
2310 assert_avoptions(ost->opts);
2311 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2312 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2313 " It takes bits/s as argument, not kbits/s\n");
2314 extra_size += ost->st->codec->extradata_size;
2316 if (ost->st->codec->me_threshold)
2317 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2321 /* init input streams */
2322 for (i = 0; i < nb_input_streams; i++)
2323 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2326 /* discard unused programs */
2327 for (i = 0; i < nb_input_files; i++) {
2328 InputFile *ifile = &input_files[i];
2329 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2330 AVProgram *p = ifile->ctx->programs[j];
2331 int discard = AVDISCARD_ALL;
2333 for (k = 0; k < p->nb_stream_indexes; k++)
2334 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2335 discard = AVDISCARD_DEFAULT;
2338 p->discard = discard;
2342 /* open files and write file headers */
2343 for (i = 0; i < nb_output_files; i++) {
2344 os = output_files[i].ctx;
2345 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2346 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2347 ret = AVERROR(EINVAL);
2350 // assert_avoptions(output_files[i].opts);
2351 if (strcmp(os->oformat->name, "rtp")) {
2357 /* dump the file output parameters - cannot be done before in case
2359 for(i=0;i<nb_output_files;i++) {
2360 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2363 /* dump the stream mapping */
2364 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2365 for (i = 0; i < nb_output_streams; i++) {
2366 ost = &output_streams[i];
2367 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d -> #%d.%d",
2368 input_streams[ost->source_index].file_index,
2369 input_streams[ost->source_index].st->index,
2372 if (ost->sync_ist != &input_streams[ost->source_index])
2373 av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
2374 ost->sync_ist->file_index,
2375 ost->sync_ist->st->index);
2376 if (ost->st->stream_copy)
2377 av_log(NULL, AV_LOG_INFO, " (copy)");
2379 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2380 input_streams[ost->source_index].dec->name : "?",
2381 ost->enc ? ost->enc->name : "?");
2382 av_log(NULL, AV_LOG_INFO, "\n");
2386 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2391 print_sdp(output_files, nb_output_files);
2398 * The following code is the main loop of the file converter
2400 static int transcode(OutputFile *output_files, int nb_output_files,
2401 InputFile *input_files, int nb_input_files)
2404 AVFormatContext *is, *os;
2408 int no_packet_count=0;
2409 int64_t timer_start;
2412 if (!(no_packet = av_mallocz(nb_input_files)))
2415 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2420 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2421 avio_set_interrupt_cb(decode_interrupt_cb);
2424 timer_start = av_gettime();
2426 for(; received_sigterm == 0;) {
2427 int file_index, ist_index;
2431 int64_t cur_time= av_gettime();
2433 ipts_min= INT64_MAX;
2435 /* if 'q' pressed, exits */
2437 static int64_t last_time;
2438 if (received_nb_signals)
2440 /* read_key() returns 0 on EOF */
2441 if(cur_time - last_time >= 100000 && !run_as_daemon){
2443 last_time = cur_time;
2448 if (key == '+') av_log_set_level(av_log_get_level()+10);
2449 if (key == '-') av_log_set_level(av_log_get_level()-10);
2450 if (key == 's') qp_hist ^= 1;
2453 do_hex_dump = do_pkt_dump = 0;
2454 } else if(do_pkt_dump){
2458 av_log_set_level(AV_LOG_DEBUG);
2461 if (key == 'c' || key == 'C'){
2462 char buf[4096], target[64], command[256], arg[256] = {0};
2465 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2467 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2472 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2473 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2474 target, time, command, arg);
2475 for (i = 0; i < nb_output_streams; i++) {
2476 ost = &output_streams[i];
2479 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2480 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2481 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2483 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2488 av_log(NULL, AV_LOG_ERROR,
2489 "Parse error, at least 3 arguments were expected, "
2490 "only %d given in string '%s'\n", n, buf);
2494 if (key == 'd' || key == 'D'){
2497 debug = input_streams[0].st->codec->debug<<1;
2498 if(!debug) debug = 1;
2499 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2502 scanf("%d", &debug);
2503 for(i=0;i<nb_input_streams;i++) {
2504 input_streams[i].st->codec->debug = debug;
2506 for(i=0;i<nb_output_streams;i++) {
2507 ost = &output_streams[i];
2508 ost->st->codec->debug = debug;
2510 if(debug) av_log_set_level(AV_LOG_DEBUG);
2511 fprintf(stderr,"debug=%d\n", debug);
2514 fprintf(stderr, "key function\n"
2515 "? show this help\n"
2516 "+ increase verbosity\n"
2517 "- decrease verbosity\n"
2518 "c Send command to filtergraph\n"
2519 "D cycle through available debug modes\n"
2520 "h dump packets/hex press to cycle through the 3 states\n"
2522 "s Show QP histogram\n"
2527 /* select the stream that we must read now by looking at the
2528 smallest output pts */
2530 for (i = 0; i < nb_output_streams; i++) {
2534 ost = &output_streams[i];
2535 of = &output_files[ost->file_index];
2536 os = output_files[ost->file_index].ctx;
2537 ist = &input_streams[ost->source_index];
2538 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2539 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2541 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2543 if (!input_files[ist->file_index].eof_reached){
2544 if(ipts < ipts_min) {
2546 if(input_sync ) file_index = ist->file_index;
2548 if(opts < opts_min) {
2550 if(!input_sync) file_index = ist->file_index;
2553 if (ost->frame_number >= ost->max_frames) {
2555 for (j = 0; j < of->ctx->nb_streams; j++)
2556 output_streams[of->ost_index + j].is_past_recording_time = 1;
2560 /* if none, if is finished */
2561 if (file_index < 0) {
2562 if(no_packet_count){
2564 memset(no_packet, 0, nb_input_files);
2571 /* read a frame from it and output it in the fifo */
2572 is = input_files[file_index].ctx;
2573 ret= av_read_frame(is, &pkt);
2574 if(ret == AVERROR(EAGAIN)){
2575 no_packet[file_index]=1;
2580 input_files[file_index].eof_reached = 1;
2588 memset(no_packet, 0, nb_input_files);
2591 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2592 is->streams[pkt.stream_index]);
2594 /* the following test is needed in case new streams appear
2595 dynamically in stream : we ignore them */
2596 if (pkt.stream_index >= input_files[file_index].nb_streams)
2597 goto discard_packet;
2598 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2599 ist = &input_streams[ist_index];
2601 goto discard_packet;
2603 if (pkt.dts != AV_NOPTS_VALUE)
2604 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2605 if (pkt.pts != AV_NOPTS_VALUE)
2606 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2608 if(pkt.pts != AV_NOPTS_VALUE)
2609 pkt.pts *= ist->ts_scale;
2610 if(pkt.dts != AV_NOPTS_VALUE)
2611 pkt.dts *= ist->ts_scale;
2613 // 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);
2614 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2615 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2616 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2617 int64_t delta= pkt_dts - ist->next_pts;
2618 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2619 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2620 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2621 pkt_dts+1<ist->pts)&& !copy_ts){
2622 input_files[ist->file_index].ts_offset -= delta;
2623 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2624 delta, input_files[ist->file_index].ts_offset);
2625 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2626 if(pkt.pts != AV_NOPTS_VALUE)
2627 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2631 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2632 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2634 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d.%d\n",
2635 ist->file_index, ist->st->index);
2638 av_free_packet(&pkt);
2643 av_free_packet(&pkt);
2645 /* dump report by using the output first video and audio streams */
2646 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
2649 /* at the end of stream, we must flush the decoder buffers */
2650 for (i = 0; i < nb_input_streams; i++) {
2651 ist = &input_streams[i];
2652 if (ist->decoding_needed) {
2653 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2656 flush_encoders(output_streams, nb_output_streams);
2660 /* write the trailer if needed and close file */
2661 for(i=0;i<nb_output_files;i++) {
2662 os = output_files[i].ctx;
2663 av_write_trailer(os);
2666 /* dump report by using the first video and audio streams */
2667 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
2669 /* close each encoder */
2670 for (i = 0; i < nb_output_streams; i++) {
2671 ost = &output_streams[i];
2672 if (ost->encoding_needed) {
2673 av_freep(&ost->st->codec->stats_in);
2674 avcodec_close(ost->st->codec);
2677 avfilter_graph_free(&ost->graph);
2681 /* close each decoder */
2682 for (i = 0; i < nb_input_streams; i++) {
2683 ist = &input_streams[i];
2684 if (ist->decoding_needed) {
2685 avcodec_close(ist->st->codec);
2693 av_freep(&bit_buffer);
2694 av_freep(&no_packet);
2696 if (output_streams) {
2697 for (i = 0; i < nb_output_streams; i++) {
2698 ost = &output_streams[i];
2700 if (ost->st->stream_copy)
2701 av_freep(&ost->st->codec->extradata);
2703 fclose(ost->logfile);
2704 ost->logfile = NULL;
2706 av_fifo_free(ost->fifo); /* works even if fifo is not
2707 initialized but set to zero */
2708 av_freep(&ost->st->codec->subtitle_header);
2709 av_free(ost->resample_frame.data[0]);
2710 av_free(ost->forced_kf_pts);
2711 if (ost->video_resample)
2712 sws_freeContext(ost->img_resample_ctx);
2713 swr_free(&ost->swr);
2714 av_dict_free(&ost->opts);
2721 static int opt_frame_crop(const char *opt, const char *arg)
2723 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2724 return AVERROR(EINVAL);
2727 static int opt_pad(const char *opt, const char *arg)
2729 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2733 static double parse_frame_aspect_ratio(const char *arg)
2740 p = strchr(arg, ':');
2742 x = strtol(arg, &end, 10);
2744 y = strtol(end+1, &end, 10);
2746 ar = (double)x / (double)y;
2748 ar = strtod(arg, NULL);
2751 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2757 static int opt_video_channel(const char *opt, const char *arg)
2759 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2760 return opt_default("channel", arg);
2763 static int opt_video_standard(const char *opt, const char *arg)
2765 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2766 return opt_default("standard", arg);
2769 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2771 audio_codec_name = arg;
2772 return parse_option(o, "codec:a", arg, options);
2775 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2777 video_codec_name = arg;
2778 return parse_option(o, "codec:v", arg, options);
2781 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2783 subtitle_codec_name = arg;
2784 return parse_option(o, "codec:s", arg, options);
2787 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2789 return parse_option(o, "codec:d", arg, options);
2792 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2794 StreamMap *m = NULL;
2795 int i, negative = 0, file_idx;
2796 int sync_file_idx = -1, sync_stream_idx;
2804 map = av_strdup(arg);
2806 /* parse sync stream first, just pick first matching stream */
2807 if (sync = strchr(map, ',')) {
2809 sync_file_idx = strtol(sync + 1, &sync, 0);
2810 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2811 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2816 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2817 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2818 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2819 sync_stream_idx = i;
2822 if (i == input_files[sync_file_idx].nb_streams) {
2823 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2824 "match any streams.\n", arg);
2830 file_idx = strtol(map, &p, 0);
2831 if (file_idx >= nb_input_files || file_idx < 0) {
2832 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2836 /* disable some already defined maps */
2837 for (i = 0; i < o->nb_stream_maps; i++) {
2838 m = &o->stream_maps[i];
2839 if (check_stream_specifier(input_files[m->file_index].ctx,
2840 input_files[m->file_index].ctx->streams[m->stream_index],
2841 *p == ':' ? p + 1 : p) > 0)
2845 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2846 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2847 *p == ':' ? p + 1 : p) <= 0)
2849 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2850 &o->nb_stream_maps, o->nb_stream_maps + 1);
2851 m = &o->stream_maps[o->nb_stream_maps - 1];
2853 m->file_index = file_idx;
2854 m->stream_index = i;
2856 if (sync_file_idx >= 0) {
2857 m->sync_file_index = sync_file_idx;
2858 m->sync_stream_index = sync_stream_idx;
2860 m->sync_file_index = file_idx;
2861 m->sync_stream_index = i;
2866 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2874 static void parse_meta_type(char *arg, char *type, int *index)
2884 if (*(++arg) == ':')
2885 *index = strtol(++arg, NULL, 0);
2888 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2895 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2897 MetadataMap *m, *m1;
2900 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2901 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2903 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2904 m->file = strtol(arg, &p, 0);
2905 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2907 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2908 if (p = strchr(opt, ':'))
2909 parse_meta_type(p + 1, &m1->type, &m1->index);
2913 if (m->type == 'g' || m1->type == 'g')
2914 o->metadata_global_manual = 1;
2915 if (m->type == 's' || m1->type == 's')
2916 o->metadata_streams_manual = 1;
2917 if (m->type == 'c' || m1->type == 'c')
2918 o->metadata_chapters_manual = 1;
2923 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2925 av_log(NULL, AV_LOG_WARNING, "-map_meta_data is deprecated and will be removed soon. "
2926 "Use -map_metadata instead.\n");
2927 return opt_map_metadata(o, opt, arg);
2930 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
2933 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2934 struct tm time = *gmtime((time_t*)&recording_timestamp);
2935 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2936 parse_option(o, "metadata", buf, options);
2938 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2939 "tag instead.\n", opt);
2943 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2945 const char *codec_string = encoder ? "encoder" : "decoder";
2949 return CODEC_ID_NONE;
2951 avcodec_find_encoder_by_name(name) :
2952 avcodec_find_decoder_by_name(name);
2954 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2957 if(codec->type != type) {
2958 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2964 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2966 char *codec_name = NULL;
2968 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2972 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2973 return avcodec_find_encoder(st->codec->codec_id);
2975 } else if (!strcmp(codec_name, "copy"))
2976 st->stream_copy = 1;
2978 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2979 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2980 avcodec_find_decoder_by_name(codec_name);
2987 * Add all the streams from the given input file to the global
2988 * list of input streams.
2990 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2992 int i, rfps, rfps_base;
2993 char *next, *codec_tag = NULL;
2995 for (i = 0; i < ic->nb_streams; i++) {
2996 AVStream *st = ic->streams[i];
2997 AVCodecContext *dec = st->codec;
3001 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3002 ist = &input_streams[nb_input_streams - 1];
3004 ist->file_index = nb_input_files;
3006 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3008 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
3009 ist->ts_scale = scale;
3011 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3013 uint32_t tag = strtol(codec_tag, &next, 0);
3015 tag = AV_RL32(codec_tag);
3016 st->codec->codec_tag = tag;
3019 ist->dec = choose_codec(o, ic, st, dec->codec_type);
3021 ist->dec = avcodec_find_decoder(dec->codec_id);
3023 switch (dec->codec_type) {
3024 case AVMEDIA_TYPE_AUDIO:
3026 ist->dec = avcodec_find_decoder(dec->codec_id);
3027 if(o->audio_disable)
3028 st->discard= AVDISCARD_ALL;
3030 case AVMEDIA_TYPE_VIDEO:
3032 ist->dec = avcodec_find_decoder(dec->codec_id);
3033 rfps = ic->streams[i]->r_frame_rate.num;
3034 rfps_base = ic->streams[i]->r_frame_rate.den;
3036 dec->flags |= CODEC_FLAG_EMU_EDGE;
3039 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3041 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",
3042 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3043 (float)rfps / rfps_base, rfps, rfps_base);
3046 if (o->video_disable)
3047 st->discard= AVDISCARD_ALL;
3048 else if(video_discard)
3049 st->discard= video_discard;
3051 case AVMEDIA_TYPE_DATA:
3053 case AVMEDIA_TYPE_SUBTITLE:
3055 ist->dec = avcodec_find_decoder(dec->codec_id);
3056 if(o->subtitle_disable)
3057 st->discard = AVDISCARD_ALL;
3059 case AVMEDIA_TYPE_ATTACHMENT:
3060 case AVMEDIA_TYPE_UNKNOWN:
3068 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3070 AVFormatContext *ic;
3071 AVInputFormat *file_iformat = NULL;
3075 AVDictionary **opts;
3076 int orig_nb_streams; // number of streams before avformat_find_stream_info
3079 if (!(file_iformat = av_find_input_format(o->format))) {
3080 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3085 if (!strcmp(filename, "-"))
3088 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3089 !strcmp(filename, "/dev/stdin");
3091 /* get default parameters from command line */
3092 ic = avformat_alloc_context();
3094 print_error(filename, AVERROR(ENOMEM));
3097 if (o->nb_audio_sample_rate) {
3098 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3099 av_dict_set(&format_opts, "sample_rate", buf, 0);
3101 if (o->nb_audio_channels) {
3102 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3103 av_dict_set(&format_opts, "channels", buf, 0);
3105 if (o->nb_frame_rates) {
3106 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3108 if (o->nb_frame_sizes) {
3109 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3111 if (o->nb_frame_pix_fmts)
3112 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3114 ic->video_codec_id =
3115 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0);
3116 ic->audio_codec_id =
3117 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0);
3118 ic->subtitle_codec_id=
3119 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0);
3120 ic->flags |= AVFMT_FLAG_NONBLOCK;
3123 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3124 ic->loop_input = loop_input;
3127 /* open the input file with generic libav function */
3128 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3130 print_error(filename, err);
3133 assert_avoptions(format_opts);
3135 /* apply forced codec ids */
3136 for (i = 0; i < ic->nb_streams; i++)
3137 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
3139 /* Set AVCodecContext options for avformat_find_stream_info */
3140 opts = setup_find_stream_info_opts(ic, codec_opts);
3141 orig_nb_streams = ic->nb_streams;
3143 /* If not enough info to get the stream parameters, we decode the
3144 first frames to get it. (used in mpeg case for example) */
3145 ret = avformat_find_stream_info(ic, opts);
3147 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3148 av_close_input_file(ic);
3152 timestamp = o->start_time;
3153 /* add the stream start time */
3154 if (ic->start_time != AV_NOPTS_VALUE)
3155 timestamp += ic->start_time;
3157 /* if seeking requested, we execute it */
3158 if (o->start_time != 0) {
3159 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3161 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3162 filename, (double)timestamp / AV_TIME_BASE);
3166 /* update the current parameters so that they match the one of the input stream */
3167 add_input_streams(o, ic);
3169 /* dump the file content */
3170 av_dump_format(ic, nb_input_files, filename, 0);
3172 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3173 input_files[nb_input_files - 1].ctx = ic;
3174 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3175 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3176 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3177 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3179 for (i = 0; i < orig_nb_streams; i++)
3180 av_dict_free(&opts[i]);
3183 reset_options(o, 1);
3187 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3192 for (p = kf; *p; p++)
3195 ost->forced_kf_count = n;
3196 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3197 if (!ost->forced_kf_pts) {
3198 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3201 for (i = 0; i < n; i++) {
3202 p = i ? strchr(p, ',') + 1 : kf;
3203 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3207 static uint8_t *get_line(AVIOContext *s)
3213 if (avio_open_dyn_buf(&line) < 0) {
3214 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3218 while ((c = avio_r8(s)) && c != '\n')
3221 avio_close_dyn_buf(line, &buf);
3226 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3229 char filename[1000];
3230 const char *base[3] = { getenv("AVCONV_DATADIR"),
3235 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3239 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3240 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3241 ret = avio_open(s, filename, AVIO_FLAG_READ);
3244 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3245 i != 1 ? "" : "/.avconv", preset_name);
3246 ret = avio_open(s, filename, AVIO_FLAG_READ);
3252 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3255 AVStream *st = avformat_new_stream(oc, NULL);
3256 int idx = oc->nb_streams - 1, ret = 0;
3257 int64_t max_frames = INT64_MAX;
3258 char *bsf = NULL, *next, *codec_tag = NULL;
3259 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3261 char *buf = NULL, *arg = NULL, *preset = NULL;
3262 AVIOContext *s = NULL;
3265 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3269 if (oc->nb_streams - 1 < o->nb_streamid_map)
3270 st->id = o->streamid_map[oc->nb_streams - 1];
3272 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3273 nb_output_streams + 1);
3274 ost = &output_streams[nb_output_streams - 1];
3275 ost->file_index = nb_output_files;
3278 st->codec->codec_type = type;
3279 ost->enc = choose_codec(o, oc, st, type);
3281 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3284 avcodec_get_context_defaults3(st->codec, ost->enc);
3285 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3287 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3288 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3291 if (!buf[0] || buf[0] == '#') {
3295 if (!(arg = strchr(buf, '='))) {
3296 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3300 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3302 } while (!s->eof_reached);
3306 av_log(NULL, AV_LOG_FATAL,
3307 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3308 preset, ost->file_index, ost->index);
3312 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3313 ost->max_frames = max_frames;
3315 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3317 if (next = strchr(bsf, ','))
3319 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3320 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3324 bsfc_prev->next = bsfc;
3326 ost->bitstream_filters = bsfc;
3332 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3334 uint32_t tag = strtol(codec_tag, &next, 0);
3336 tag = AV_RL32(codec_tag);
3337 st->codec->codec_tag = tag;
3340 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3341 if (qscale >= 0 || same_quant) {
3342 st->codec->flags |= CODEC_FLAG_QSCALE;
3343 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3346 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3347 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3349 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3353 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3356 const char *p = str;
3363 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3370 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3374 AVCodecContext *video_enc;
3376 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3378 video_enc = st->codec;
3380 if (!st->stream_copy) {
3381 const char *p = NULL;
3382 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3383 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3384 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3385 int i, force_fps = 0, top_field_first = -1;
3387 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3388 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3389 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3393 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3394 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3395 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3399 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3400 if (frame_aspect_ratio)
3401 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3403 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3404 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3405 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3406 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3409 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3412 video_enc->gop_size = 0;
3413 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3415 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3416 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3419 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3421 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3423 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3424 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3427 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3430 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3433 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3435 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3438 /* FIXME realloc failure */
3439 video_enc->rc_override=
3440 av_realloc(video_enc->rc_override,
3441 sizeof(RcOverride)*(i+1));
3442 video_enc->rc_override[i].start_frame= start;
3443 video_enc->rc_override[i].end_frame = end;
3445 video_enc->rc_override[i].qscale= q;
3446 video_enc->rc_override[i].quality_factor= 1.0;
3449 video_enc->rc_override[i].qscale= 0;
3450 video_enc->rc_override[i].quality_factor= -q/100.0;
3455 video_enc->rc_override_count=i;
3456 if (!video_enc->rc_initial_buffer_occupancy)
3457 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3458 video_enc->intra_dc_precision= intra_dc_precision - 8;
3463 video_enc->flags |= CODEC_FLAG_PASS1;
3465 video_enc->flags |= CODEC_FLAG_PASS2;
3469 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3470 if (forced_key_frames)
3471 parse_forced_key_frames(forced_key_frames, ost);
3473 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3474 ost->force_fps = force_fps;
3476 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3477 ost->top_field_first = top_field_first;
3480 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3482 ost->avfilter = av_strdup(filters);
3489 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3493 AVCodecContext *audio_enc;
3495 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3498 audio_enc = st->codec;
3499 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3501 if (!st->stream_copy) {
3502 char *sample_fmt = NULL;
3504 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3506 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3508 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3509 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3513 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3519 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3524 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3526 if (!st->stream_copy) {
3527 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3534 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3536 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3537 ost->st->stream_copy = 1;
3541 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3545 AVCodecContext *subtitle_enc;
3547 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3549 subtitle_enc = st->codec;
3551 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3556 /* arg format is "output-stream-index:streamid-value". */
3557 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3563 av_strlcpy(idx_str, arg, sizeof(idx_str));
3564 p = strchr(idx_str, ':');
3566 av_log(NULL, AV_LOG_FATAL,
3567 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3572 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3573 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3574 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3578 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3580 AVFormatContext *is = ifile->ctx;
3581 AVFormatContext *os = ofile->ctx;
3584 for (i = 0; i < is->nb_chapters; i++) {
3585 AVChapter *in_ch = is->chapters[i], *out_ch;
3586 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3587 AV_TIME_BASE_Q, in_ch->time_base);
3588 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3589 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3592 if (in_ch->end < ts_off)
3594 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3597 out_ch = av_mallocz(sizeof(AVChapter));
3599 return AVERROR(ENOMEM);
3601 out_ch->id = in_ch->id;
3602 out_ch->time_base = in_ch->time_base;
3603 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3604 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3607 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3610 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3612 return AVERROR(ENOMEM);
3613 os->chapters[os->nb_chapters - 1] = out_ch;
3618 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3621 AVFormatContext *ic = NULL;
3623 err = avformat_open_input(&ic, filename, NULL, NULL);
3626 /* copy stream format */
3627 for(i=0;i<ic->nb_streams;i++) {
3632 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3633 ost = new_output_stream(o, s, codec->type);
3636 // FIXME: a more elegant solution is needed
3637 memcpy(st, ic->streams[i], sizeof(AVStream));
3638 st->info = av_malloc(sizeof(*st->info));
3639 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3640 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3642 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3643 choose_sample_fmt(st, codec);
3644 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3645 choose_pixel_fmt(st, codec);
3648 av_close_input_file(ic);
3652 static void opt_output_file(void *optctx, const char *filename)
3654 OptionsContext *o = optctx;
3655 AVFormatContext *oc;
3657 AVOutputFormat *file_oformat;
3661 if (!strcmp(filename, "-"))
3664 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3666 print_error(filename, err);
3669 file_oformat= oc->oformat;
3671 if (!strcmp(file_oformat->name, "ffm") &&
3672 av_strstart(filename, "http:", NULL)) {
3673 /* special case for files sent to ffserver: we get the stream
3674 parameters from ffserver */
3675 int err = read_ffserver_streams(o, oc, filename);
3677 print_error(filename, err);
3680 } else if (!o->nb_stream_maps) {
3681 /* pick the "best" stream of each type */
3682 #define NEW_STREAM(type, index)\
3684 ost = new_ ## type ## _stream(o, oc);\
3685 ost->source_index = index;\
3686 ost->sync_ist = &input_streams[index];\
3687 input_streams[index].discard = 0;\
3690 /* video: highest resolution */
3691 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3692 int area = 0, idx = -1;
3693 for (i = 0; i < nb_input_streams; i++) {
3694 ist = &input_streams[i];
3695 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3696 ist->st->codec->width * ist->st->codec->height > area) {
3697 area = ist->st->codec->width * ist->st->codec->height;
3701 NEW_STREAM(video, idx);
3704 /* audio: most channels */
3705 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3706 int channels = 0, idx = -1;
3707 for (i = 0; i < nb_input_streams; i++) {
3708 ist = &input_streams[i];
3709 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3710 ist->st->codec->channels > channels) {
3711 channels = ist->st->codec->channels;
3715 NEW_STREAM(audio, idx);
3718 /* subtitles: pick first */
3719 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3720 for (i = 0; i < nb_input_streams; i++)
3721 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3722 NEW_STREAM(subtitle, i);
3726 /* do something with data? */
3728 for (i = 0; i < o->nb_stream_maps; i++) {
3729 StreamMap *map = &o->stream_maps[i];
3734 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3735 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
3737 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
3739 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3742 switch (ist->st->codec->codec_type) {
3743 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3744 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3745 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3746 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3747 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3749 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3750 map->file_index, map->stream_index);
3754 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3755 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3756 map->sync_stream_index];
3761 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3762 output_files[nb_output_files - 1].ctx = oc;
3763 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3764 output_files[nb_output_files - 1].recording_time = o->recording_time;
3765 output_files[nb_output_files - 1].start_time = o->start_time;
3766 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3767 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3769 /* check filename in case of an image number is expected */
3770 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3771 if (!av_filename_number_test(oc->filename)) {
3772 print_error(oc->filename, AVERROR(EINVAL));
3777 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3778 /* test if it already exists to avoid loosing precious files */
3779 if (!file_overwrite &&
3780 (strchr(filename, ':') == NULL ||
3781 filename[1] == ':' ||
3782 av_strstart(filename, "file:", NULL))) {
3783 if (avio_check(filename, 0) == 0) {
3785 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3788 if (!read_yesno()) {
3789 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3795 av_log(0, AV_LOG_FATAL,"File '%s' already exists. Exiting.\n", filename);
3802 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3803 print_error(filename, err);
3808 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3809 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3811 if (loop_output >= 0) {
3812 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3813 oc->loop_output = loop_output;
3817 if (o->chapters_input_file >= nb_input_files) {
3818 if (o->chapters_input_file == INT_MAX) {
3819 /* copy chapters from the first input file that has them*/
3820 o->chapters_input_file = -1;
3821 for (i = 0; i < nb_input_files; i++)
3822 if (input_files[i].ctx->nb_chapters) {
3823 o->chapters_input_file = i;
3827 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3828 o->chapters_input_file);
3832 if (o->chapters_input_file >= 0)
3833 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3834 !o->metadata_chapters_manual);
3837 for (i = 0; i < o->nb_meta_data_maps; i++) {
3838 AVFormatContext *files[2];
3839 AVDictionary **meta[2];
3842 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3843 if ((index) < 0 || (index) >= (nb_elems)) {\
3844 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3849 int in_file_index = o->meta_data_maps[i][1].file;
3850 if (in_file_index < 0)
3852 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3855 files[1] = input_files[in_file_index].ctx;
3857 for (j = 0; j < 2; j++) {
3858 MetadataMap *map = &o->meta_data_maps[i][j];
3860 switch (map->type) {
3862 meta[j] = &files[j]->metadata;
3865 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3866 meta[j] = &files[j]->streams[map->index]->metadata;
3869 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3870 meta[j] = &files[j]->chapters[map->index]->metadata;
3873 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3874 meta[j] = &files[j]->programs[map->index]->metadata;
3879 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3882 /* copy global metadata by default */
3883 if (!o->metadata_global_manual && nb_input_files){
3884 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3885 AV_DICT_DONT_OVERWRITE);
3886 if(o->recording_time != INT64_MAX)
3887 av_dict_set(&oc->metadata, "duration", NULL, 0);
3889 if (!o->metadata_streams_manual)
3890 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3891 InputStream *ist = &input_streams[output_streams[i].source_index];
3892 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3895 /* process manually set metadata */
3896 for (i = 0; i < o->nb_metadata; i++) {
3901 val = strchr(o->metadata[i].u.str, '=');
3903 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3904 o->metadata[i].u.str);
3909 parse_meta_type(o->metadata[i].specifier, &type, &index);
3915 if (index < 0 || index >= oc->nb_streams) {
3916 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3919 m = &oc->streams[index]->metadata;
3922 if (index < 0 || index >= oc->nb_chapters) {
3923 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3926 m = &oc->chapters[index]->metadata;
3929 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3933 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3936 reset_options(o, 0);
3939 /* same option as mencoder */
3940 static int opt_pass(const char *opt, const char *arg)
3942 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3946 static int64_t getutime(void)
3949 struct rusage rusage;
3951 getrusage(RUSAGE_SELF, &rusage);
3952 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3953 #elif HAVE_GETPROCESSTIMES
3955 FILETIME c, e, k, u;
3956 proc = GetCurrentProcess();
3957 GetProcessTimes(proc, &c, &e, &k, &u);
3958 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3960 return av_gettime();
3964 static int64_t getmaxrss(void)
3966 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3967 struct rusage rusage;
3968 getrusage(RUSAGE_SELF, &rusage);
3969 return (int64_t)rusage.ru_maxrss * 1024;
3970 #elif HAVE_GETPROCESSMEMORYINFO
3972 PROCESS_MEMORY_COUNTERS memcounters;
3973 proc = GetCurrentProcess();
3974 memcounters.cb = sizeof(memcounters);
3975 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3976 return memcounters.PeakPagefileUsage;
3982 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3984 return parse_option(o, "q:a", arg, options);
3987 static void show_usage(void)
3989 printf("Hyper fast Audio and Video encoder\n");
3990 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3994 static int opt_help(const char *opt, const char *arg)
3996 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
3997 av_log_set_callback(log_callback_help);
3999 show_help_options(options, "Main options:\n",
4000 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4001 show_help_options(options, "\nAdvanced options:\n",
4002 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4004 show_help_options(options, "\nVideo options:\n",
4005 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4007 show_help_options(options, "\nAdvanced Video options:\n",
4008 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4009 OPT_VIDEO | OPT_EXPERT);
4010 show_help_options(options, "\nAudio options:\n",
4011 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4013 show_help_options(options, "\nAdvanced Audio options:\n",
4014 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4015 OPT_AUDIO | OPT_EXPERT);
4016 show_help_options(options, "\nSubtitle options:\n",
4017 OPT_SUBTITLE | OPT_GRAB,
4019 show_help_options(options, "\nAudio/Video grab options:\n",
4023 show_help_children(avcodec_get_class(), flags);
4024 show_help_children(avformat_get_class(), flags);
4025 show_help_children(sws_get_class(), flags);
4030 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4032 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4033 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4035 if(!strncmp(arg, "pal-", 4)) {
4038 } else if(!strncmp(arg, "ntsc-", 5)) {
4041 } else if(!strncmp(arg, "film-", 5)) {
4045 /* Try to determine PAL/NTSC by peeking in the input files */
4046 if(nb_input_files) {
4048 for (j = 0; j < nb_input_files; j++) {
4049 for (i = 0; i < input_files[j].nb_streams; i++) {
4050 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4051 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4053 fr = c->time_base.den * 1000 / c->time_base.num;
4057 } else if((fr == 29970) || (fr == 23976)) {
4066 if (norm != UNKNOWN)
4067 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4070 if(norm == UNKNOWN) {
4071 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4072 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4073 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4077 if(!strcmp(arg, "vcd")) {
4078 opt_video_codec(o, "c:v", "mpeg1video");
4079 opt_audio_codec(o, "c:a", "mp2");
4080 parse_option(o, "f", "vcd", options);
4082 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4083 parse_option(o, "r", frame_rates[norm], options);
4084 opt_default("g", norm == PAL ? "15" : "18");
4086 opt_default("b", "1150000");
4087 opt_default("maxrate", "1150000");
4088 opt_default("minrate", "1150000");
4089 opt_default("bufsize", "327680"); // 40*1024*8;
4091 opt_default("b:a", "224000");
4092 parse_option(o, "ar", "44100", options);
4093 parse_option(o, "ac", "2", options);
4095 opt_default("packetsize", "2324");
4096 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4098 /* We have to offset the PTS, so that it is consistent with the SCR.
4099 SCR starts at 36000, but the first two packs contain only padding
4100 and the first pack from the other stream, respectively, may also have
4101 been written before.
4102 So the real data starts at SCR 36000+3*1200. */
4103 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4104 } else if(!strcmp(arg, "svcd")) {
4106 opt_video_codec(o, "c:v", "mpeg2video");
4107 opt_audio_codec(o, "c:a", "mp2");
4108 parse_option(o, "f", "svcd", options);
4110 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4111 parse_option(o, "r", frame_rates[norm], options);
4112 parse_option(o, "pix_fmt", "yuv420p", options);
4113 opt_default("g", norm == PAL ? "15" : "18");
4115 opt_default("b", "2040000");
4116 opt_default("maxrate", "2516000");
4117 opt_default("minrate", "0"); //1145000;
4118 opt_default("bufsize", "1835008"); //224*1024*8;
4119 opt_default("flags", "+scan_offset");
4122 opt_default("b:a", "224000");
4123 parse_option(o, "ar", "44100", options);
4125 opt_default("packetsize", "2324");
4127 } else if(!strcmp(arg, "dvd")) {
4129 opt_video_codec(o, "c:v", "mpeg2video");
4130 opt_audio_codec(o, "c:a", "ac3");
4131 parse_option(o, "f", "dvd", options);
4133 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4134 parse_option(o, "r", frame_rates[norm], options);
4135 parse_option(o, "pix_fmt", "yuv420p", options);
4136 opt_default("g", norm == PAL ? "15" : "18");
4138 opt_default("b", "6000000");
4139 opt_default("maxrate", "9000000");
4140 opt_default("minrate", "0"); //1500000;
4141 opt_default("bufsize", "1835008"); //224*1024*8;
4143 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4144 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4146 opt_default("b:a", "448000");
4147 parse_option(o, "ar", "48000", options);
4149 } else if(!strncmp(arg, "dv", 2)) {
4151 parse_option(o, "f", "dv", options);
4153 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4154 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4155 norm == PAL ? "yuv420p" : "yuv411p", options);
4156 parse_option(o, "r", frame_rates[norm], options);
4158 parse_option(o, "ar", "48000", options);
4159 parse_option(o, "ac", "2", options);
4162 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4163 return AVERROR(EINVAL);
4168 static int opt_vstats_file(const char *opt, const char *arg)
4170 av_free (vstats_filename);
4171 vstats_filename=av_strdup (arg);
4175 static int opt_vstats(const char *opt, const char *arg)
4178 time_t today2 = time(NULL);
4179 struct tm *today = localtime(&today2);
4181 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4183 return opt_vstats_file(opt, filename);
4186 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4188 return parse_option(o, "frames:v", arg, options);
4191 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4193 return parse_option(o, "frames:a", arg, options);
4196 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4198 return parse_option(o, "frames:d", arg, options);
4201 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4204 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4205 const char *codec_name = *opt == 'v' ? video_codec_name :
4206 *opt == 'a' ? audio_codec_name :
4207 subtitle_codec_name;
4209 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4210 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4211 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4213 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4218 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4219 if(line[0] == '#' && !e)
4221 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4223 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4226 if(!strcmp(tmp, "acodec")){
4227 opt_audio_codec(o, tmp, tmp2);
4228 }else if(!strcmp(tmp, "vcodec")){
4229 opt_video_codec(o, tmp, tmp2);
4230 }else if(!strcmp(tmp, "scodec")){
4231 opt_subtitle_codec(o, tmp, tmp2);
4232 }else if(!strcmp(tmp, "dcodec")){
4233 opt_data_codec(o, tmp, tmp2);
4234 }else if(opt_default(tmp, tmp2) < 0){
4235 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4245 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4249 static int opt_passlogfile(const char *opt, const char *arg)
4251 pass_logfilename_prefix = arg;
4252 #if CONFIG_LIBX264_ENCODER
4253 return opt_default("passlogfile", arg);
4259 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4261 char *s= av_malloc(strlen(opt)+2);
4262 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4263 return parse_option(o, s, arg, options);
4266 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4268 if(!strcmp(opt, "b")){
4269 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4270 return parse_option(o, av_strdup("b:v"), arg, options);
4272 return opt_default(opt, arg);
4275 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4277 return parse_option(o, "filter:v", arg, options);
4280 #define OFFSET(x) offsetof(OptionsContext, x)
4281 static const OptionDef options[] = {
4283 #include "cmdutils_common_opts.h"
4284 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4285 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4286 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4287 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4288 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4289 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4290 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4291 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4292 "outfile[,metadata]:infile[,metadata]" },
4293 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4294 "outfile[,metadata]:infile[,metadata]" },
4295 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4296 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4297 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4298 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4299 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4300 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4301 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4302 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4303 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4304 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4305 "add timings for benchmarking" },
4306 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4307 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4308 "dump each input packet" },
4309 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4310 "when dumping packets, also dump the payload" },
4311 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4312 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4313 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4314 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4315 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4316 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4317 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4318 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4319 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4320 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4321 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4322 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4323 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4324 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4325 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4326 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4327 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4329 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4331 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4334 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4335 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4336 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4337 { "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" },
4338 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4339 { "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" },
4340 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4341 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4342 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4343 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4344 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4345 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4346 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4347 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4348 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4349 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4350 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4351 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4352 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4353 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4354 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4355 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4356 "use same quantizer as source (implies VBR)" },
4357 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4358 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4359 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4360 "deinterlace pictures" },
4361 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4362 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4364 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4366 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4367 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4368 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4369 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4370 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4371 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4372 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4373 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4374 { "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" },
4375 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4378 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4379 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4380 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4381 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4382 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4383 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4384 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4385 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4386 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4388 /* subtitle options */
4389 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4390 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4391 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4394 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4395 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4396 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4399 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4400 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4402 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4403 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4404 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4406 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4407 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4408 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4409 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4410 /* data codec support */
4411 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4413 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4417 int main(int argc, char **argv)
4419 OptionsContext o = { 0 };
4422 reset_options(&o, 0);
4424 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4425 parse_loglevel(argc, argv, options);
4427 if(argc>1 && !strcmp(argv[1], "-d")){
4429 av_log_set_callback(log_callback_null);
4434 avcodec_register_all();
4436 avdevice_register_all();
4439 avfilter_register_all();
4444 if(isatty(STDIN_FILENO))
4445 avio_set_interrupt_cb(decode_interrupt_cb);
4453 parse_options(&o, argc, argv, options, opt_output_file);
4455 if(nb_output_files <= 0 && nb_input_files == 0) {
4457 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4461 /* file converter / grab */
4462 if (nb_output_files <= 0) {
4463 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4467 if (nb_input_files == 0) {
4468 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4473 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4475 ti = getutime() - ti;
4477 int maxrss = getmaxrss() / 1024;
4478 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);