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 float rematrix_volume;
238 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
241 struct SwrContext *swr;
244 AVFilterContext *output_video_filter;
245 AVFilterContext *input_video_filter;
246 AVFilterBufferRef *picref;
248 AVFilterGraph *graph;
253 int is_past_recording_time;
260 /* init terminal so that we can grab keys */
261 static struct termios oldtty;
264 typedef struct OutputFile {
265 AVFormatContext *ctx;
267 int ost_index; /* index of the first stream in output_streams */
268 int64_t recording_time; /* desired length of the resulting file in microseconds */
269 int64_t start_time; /* start time in microseconds */
270 uint64_t limit_filesize;
273 static InputStream *input_streams = NULL;
274 static int nb_input_streams = 0;
275 static InputFile *input_files = NULL;
276 static int nb_input_files = 0;
278 static OutputStream *output_streams = NULL;
279 static int nb_output_streams = 0;
280 static OutputFile *output_files = NULL;
281 static int nb_output_files = 0;
283 typedef struct OptionsContext {
284 /* input/output options */
288 SpecifierOpt *codec_names;
290 SpecifierOpt *audio_channels;
291 int nb_audio_channels;
292 SpecifierOpt *audio_sample_rate;
293 int nb_audio_sample_rate;
294 SpecifierOpt *rematrix_volume;
295 int nb_rematrix_volume;
296 SpecifierOpt *frame_rates;
298 SpecifierOpt *frame_sizes;
300 SpecifierOpt *frame_pix_fmts;
301 int nb_frame_pix_fmts;
304 int64_t input_ts_offset;
307 SpecifierOpt *ts_scale;
311 StreamMap *stream_maps;
313 /* first item specifies output metadata, second is input */
314 MetadataMap (*meta_data_maps)[2];
315 int nb_meta_data_maps;
316 int metadata_global_manual;
317 int metadata_streams_manual;
318 int metadata_chapters_manual;
320 int chapters_input_file;
322 int64_t recording_time;
323 uint64_t limit_filesize;
329 int subtitle_disable;
332 /* indexed by output file stream index */
336 SpecifierOpt *metadata;
338 SpecifierOpt *max_frames;
340 SpecifierOpt *bitstream_filters;
341 int nb_bitstream_filters;
342 SpecifierOpt *codec_tags;
344 SpecifierOpt *sample_fmts;
346 SpecifierOpt *qscale;
348 SpecifierOpt *forced_key_frames;
349 int nb_forced_key_frames;
350 SpecifierOpt *force_fps;
352 SpecifierOpt *frame_aspect_ratios;
353 int nb_frame_aspect_ratios;
354 SpecifierOpt *rc_overrides;
356 SpecifierOpt *intra_matrices;
357 int nb_intra_matrices;
358 SpecifierOpt *inter_matrices;
359 int nb_inter_matrices;
360 SpecifierOpt *top_field_first;
361 int nb_top_field_first;
362 SpecifierOpt *presets;
365 SpecifierOpt *filters;
370 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
373 for (i = 0; i < o->nb_ ## name; i++) {\
374 char *spec = o->name[i].specifier;\
375 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
376 outvar = o->name[i].u.type;\
382 static void reset_options(OptionsContext *o, int is_input)
384 const OptionDef *po = options;
385 OptionsContext bak= *o;
387 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
389 void *dst = (uint8_t*)o + po->u.off;
391 if (po->flags & OPT_SPEC) {
392 SpecifierOpt **so = dst;
393 int i, *count = (int*)(so + 1);
394 for (i = 0; i < *count; i++) {
395 av_freep(&(*so)[i].specifier);
396 if (po->flags & OPT_STRING)
397 av_freep(&(*so)[i].u.str);
401 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
406 av_freep(&o->stream_maps);
407 av_freep(&o->meta_data_maps);
408 av_freep(&o->streamid_map);
410 memset(o, 0, sizeof(*o));
412 if(is_input) o->recording_time = bak.recording_time;
413 else o->recording_time = INT64_MAX;
414 o->mux_max_delay = 0.7;
415 o->limit_filesize = UINT64_MAX;
416 o->chapters_input_file = INT_MAX;
424 static int configure_video_filters(InputStream *ist, OutputStream *ost)
426 AVFilterContext *last_filter, *filter;
427 /** filter graph containing all filters including input & output */
428 AVCodecContext *codec = ost->st->codec;
429 AVCodecContext *icodec = ist->st->codec;
430 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
431 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
432 AVRational sample_aspect_ratio;
436 ost->graph = avfilter_graph_alloc();
438 if (ist->st->sample_aspect_ratio.num){
439 sample_aspect_ratio = ist->st->sample_aspect_ratio;
441 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
443 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
444 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
445 sample_aspect_ratio.num, sample_aspect_ratio.den);
447 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
448 "src", args, NULL, ost->graph);
451 #if FF_API_OLD_VSINK_API
452 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
453 "out", NULL, pix_fmts, ost->graph);
455 buffersink_params->pixel_fmts = pix_fmts;
456 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
457 "out", NULL, buffersink_params, ost->graph);
459 av_freep(&buffersink_params);
462 last_filter = ost->input_video_filter;
464 if (codec->width != icodec->width || codec->height != icodec->height) {
465 snprintf(args, 255, "%d:%d:flags=0x%X",
468 (unsigned)ost->sws_flags);
469 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
470 NULL, args, NULL, ost->graph)) < 0)
472 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
474 last_filter = filter;
477 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
478 ost->graph->scale_sws_opts = av_strdup(args);
481 AVFilterInOut *outputs = avfilter_inout_alloc();
482 AVFilterInOut *inputs = avfilter_inout_alloc();
484 outputs->name = av_strdup("in");
485 outputs->filter_ctx = last_filter;
486 outputs->pad_idx = 0;
487 outputs->next = NULL;
489 inputs->name = av_strdup("out");
490 inputs->filter_ctx = ost->output_video_filter;
494 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
496 av_freep(&ost->avfilter);
498 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
502 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
505 codec->width = ost->output_video_filter->inputs[0]->w;
506 codec->height = ost->output_video_filter->inputs[0]->h;
507 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
508 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
509 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
510 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
514 #endif /* CONFIG_AVFILTER */
516 static void term_exit(void)
518 av_log(NULL, AV_LOG_QUIET, "%s", "");
521 tcsetattr (0, TCSANOW, &oldtty);
525 static volatile int received_sigterm = 0;
527 static void sigterm_handler(int sig)
529 received_sigterm = sig;
530 received_nb_signals++;
534 static void term_init(void)
544 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
545 |INLCR|IGNCR|ICRNL|IXON);
546 tty.c_oflag |= OPOST;
547 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
548 tty.c_cflag &= ~(CSIZE|PARENB);
553 tcsetattr (0, TCSANOW, &tty);
554 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
558 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
559 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
561 signal(SIGXCPU, sigterm_handler);
565 /* read a key without blocking */
566 static int read_key(void)
578 n = select(1, &rfds, NULL, NULL, &tv);
587 # if HAVE_PEEKNAMEDPIPE
589 static HANDLE input_handle;
592 input_handle = GetStdHandle(STD_INPUT_HANDLE);
593 is_pipe = !GetConsoleMode(input_handle, &dw);
596 if (stdin->_cnt > 0) {
601 /* When running under a GUI, you will end here. */
602 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
619 static int decode_interrupt_cb(void)
621 return received_nb_signals > 1;
624 void exit_program(int ret)
629 for(i=0;i<nb_output_files;i++) {
630 AVFormatContext *s = output_files[i].ctx;
631 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
633 avformat_free_context(s);
634 av_dict_free(&output_files[i].opts);
636 for(i=0;i<nb_input_files;i++) {
637 av_close_input_file(input_files[i].ctx);
639 for (i = 0; i < nb_input_streams; i++)
640 av_dict_free(&input_streams[i].opts);
644 av_free(vstats_filename);
646 av_freep(&input_streams);
647 av_freep(&input_files);
648 av_freep(&output_streams);
649 av_freep(&output_files);
654 allocated_audio_buf_size= allocated_audio_out_size= 0;
661 av_freep(&input_tmp);
663 if (received_sigterm) {
664 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
665 (int) received_sigterm);
669 exit(ret); /* not all OS-es handle main() return value */
672 static void assert_avoptions(AVDictionary *m)
674 AVDictionaryEntry *t;
675 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
676 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
681 static void assert_codec_experimental(AVCodecContext *c, int encoder)
683 const char *codec_string = encoder ? "encoder" : "decoder";
685 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
686 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
687 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
688 "results.\nAdd '-strict experimental' if you want to use it.\n",
689 codec_string, c->codec->name);
690 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
691 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
692 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
693 codec_string, codec->name);
698 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
700 if(codec && codec->sample_fmts){
701 const enum AVSampleFormat *p= codec->sample_fmts;
703 if(*p == st->codec->sample_fmt)
707 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
708 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
709 if(av_get_sample_fmt_name(st->codec->sample_fmt))
710 av_log(NULL, AV_LOG_WARNING,
711 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
712 av_get_sample_fmt_name(st->codec->sample_fmt),
714 av_get_sample_fmt_name(codec->sample_fmts[0]));
715 st->codec->sample_fmt = codec->sample_fmts[0];
720 static void choose_sample_rate(AVStream *st, AVCodec *codec)
722 if(codec && codec->supported_samplerates){
723 const int *p= codec->supported_samplerates;
725 int best_dist=INT_MAX;
727 int dist= abs(st->codec->sample_rate - *p);
728 if(dist < best_dist){
734 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
736 st->codec->sample_rate= best;
740 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
742 if(codec && codec->pix_fmts){
743 const enum PixelFormat *p= codec->pix_fmts;
744 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
745 if(st->codec->codec_id==CODEC_ID_MJPEG){
746 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
747 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
748 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};
752 if(*p == st->codec->pix_fmt)
756 if(st->codec->pix_fmt != PIX_FMT_NONE)
757 av_log(NULL, AV_LOG_WARNING,
758 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
759 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
761 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
762 st->codec->pix_fmt = codec->pix_fmts[0];
767 static double get_sync_ipts(const OutputStream *ost)
769 const InputStream *ist = ost->sync_ist;
770 OutputFile *of = &output_files[ost->file_index];
771 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
774 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
779 AVPacket new_pkt= *pkt;
780 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
781 &new_pkt.data, &new_pkt.size,
782 pkt->data, pkt->size,
783 pkt->flags & AV_PKT_FLAG_KEY);
786 new_pkt.destruct= av_destruct_packet;
788 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
789 bsfc->filter->name, pkt->stream_index,
790 avctx->codec ? avctx->codec->name : "copy");
800 ret= av_interleaved_write_frame(s, pkt);
802 print_error("av_interleaved_write_frame()", ret);
807 static void do_audio_out(AVFormatContext *s,
810 unsigned char *buf, int size)
813 int64_t audio_out_size, audio_buf_size;
814 int64_t allocated_for_size= size;
816 int size_out, frame_bytes, ret, resample_changed;
817 AVCodecContext *enc= ost->st->codec;
818 AVCodecContext *dec= ist->st->codec;
819 int osize = av_get_bytes_per_sample(enc->sample_fmt);
820 int isize = av_get_bytes_per_sample(dec->sample_fmt);
821 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
824 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
825 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
826 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
827 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
828 audio_buf_size*= osize*enc->channels;
830 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
831 if(coded_bps > 8*osize)
832 audio_out_size= audio_out_size * coded_bps / (8*osize);
833 audio_out_size += FF_MIN_BUFFER_SIZE;
835 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
836 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
840 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
841 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
842 if (!audio_buf || !audio_out){
843 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
847 if (enc->channels != dec->channels
848 || enc->sample_fmt != dec->sample_fmt)
849 ost->audio_resample = 1;
851 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
852 ost->resample_channels != dec->channels ||
853 ost->resample_sample_rate != dec->sample_rate;
855 if ((ost->audio_resample && !ost->swr) || resample_changed) {
856 if (resample_changed) {
857 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",
858 ist->file_index, ist->st->index,
859 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
860 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
861 ost->resample_sample_fmt = dec->sample_fmt;
862 ost->resample_channels = dec->channels;
863 ost->resample_sample_rate = dec->sample_rate;
866 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
867 if (audio_sync_method <= 1 &&
868 ost->resample_sample_fmt == enc->sample_fmt &&
869 ost->resample_channels == enc->channels &&
870 ost->resample_sample_rate == enc->sample_rate) {
872 ost->audio_resample = 0;
874 ost->swr = swr_alloc2(ost->swr,
875 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
876 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
878 av_set_double(ost->swr, "rmvol", ost->rematrix_volume);
879 av_set_int(ost->swr, "ich", dec->channels);
880 av_set_int(ost->swr, "och", enc->channels);
881 if(audio_sync_method>1) av_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE);
882 if(ost->swr && swr_init(ost->swr) < 0){
883 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
888 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
889 dec->channels, dec->sample_rate,
890 enc->channels, enc->sample_rate);
896 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
898 if(audio_sync_method){
899 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
900 - av_fifo_size(ost->fifo)/(enc->channels * 2);
901 double idelta= delta*dec->sample_rate / enc->sample_rate;
902 int byte_delta= ((int)idelta)*2*dec->channels;
904 //FIXME resample delay
905 if(fabs(delta) > 50){
906 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
908 byte_delta= FFMAX(byte_delta, -size);
911 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
916 input_tmp= av_realloc(input_tmp, byte_delta + size);
918 if(byte_delta > allocated_for_size - size){
919 allocated_for_size= byte_delta + (int64_t)size;
924 memset(input_tmp, 0, byte_delta);
925 memcpy(input_tmp + byte_delta, buf, size);
928 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
930 }else if(audio_sync_method>1){
931 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
932 av_assert0(ost->audio_resample);
933 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
934 delta, comp, enc->sample_rate);
935 // 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));
936 swr_compensate(ost->swr, comp, enc->sample_rate);
940 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
941 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
943 if (ost->audio_resample) {
945 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
946 (const uint8_t*[]){buf }, size / (dec->channels * isize));
947 size_out = size_out * enc->channels * osize;
953 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
955 /* now encode as many frames as possible */
956 if (enc->frame_size > 1) {
957 /* output resampled raw samples */
958 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
959 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
962 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
964 frame_bytes = enc->frame_size * osize * enc->channels;
966 while (av_fifo_size(ost->fifo) >= frame_bytes) {
968 av_init_packet(&pkt);
970 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
972 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
974 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
977 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
981 pkt.stream_index= ost->index;
984 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
985 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
986 pkt.flags |= AV_PKT_FLAG_KEY;
987 write_frame(s, &pkt, enc, ost->bitstream_filters);
989 ost->sync_opts += enc->frame_size;
993 av_init_packet(&pkt);
995 ost->sync_opts += size_out / (osize * enc->channels);
997 /* output a pcm frame */
998 /* determine the size of the coded buffer */
1001 size_out = size_out*coded_bps/8;
1003 if(size_out > audio_out_size){
1004 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1008 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1009 ret = avcodec_encode_audio(enc, audio_out, size_out,
1012 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1016 pkt.stream_index= ost->index;
1017 pkt.data= audio_out;
1019 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1020 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1021 pkt.flags |= AV_PKT_FLAG_KEY;
1022 write_frame(s, &pkt, enc, ost->bitstream_filters);
1026 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1028 AVCodecContext *dec;
1029 AVPicture *picture2;
1030 AVPicture picture_tmp;
1033 dec = ist->st->codec;
1035 /* deinterlace : must be done before any resize */
1036 if (do_deinterlace) {
1039 /* create temporary picture */
1040 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1041 buf = av_malloc(size);
1045 picture2 = &picture_tmp;
1046 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1048 if(avpicture_deinterlace(picture2, picture,
1049 dec->pix_fmt, dec->width, dec->height) < 0) {
1050 /* if error, do not deinterlace */
1051 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1060 if (picture != picture2)
1061 *picture = *picture2;
1065 static void do_subtitle_out(AVFormatContext *s,
1071 static uint8_t *subtitle_out = NULL;
1072 int subtitle_out_max_size = 1024 * 1024;
1073 int subtitle_out_size, nb, i;
1074 AVCodecContext *enc;
1077 if (pts == AV_NOPTS_VALUE) {
1078 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1084 enc = ost->st->codec;
1086 if (!subtitle_out) {
1087 subtitle_out = av_malloc(subtitle_out_max_size);
1090 /* Note: DVB subtitle need one packet to draw them and one other
1091 packet to clear them */
1092 /* XXX: signal it in the codec context ? */
1093 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1098 for(i = 0; i < nb; i++) {
1099 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1100 // start_display_time is required to be 0
1101 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1102 sub->end_display_time -= sub->start_display_time;
1103 sub->start_display_time = 0;
1104 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1105 subtitle_out_max_size, sub);
1106 if (subtitle_out_size < 0) {
1107 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1111 av_init_packet(&pkt);
1112 pkt.stream_index = ost->index;
1113 pkt.data = subtitle_out;
1114 pkt.size = subtitle_out_size;
1115 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1116 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1117 /* XXX: the pts correction is handled here. Maybe handling
1118 it in the codec would be better */
1120 pkt.pts += 90 * sub->start_display_time;
1122 pkt.pts += 90 * sub->end_display_time;
1124 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1128 static int bit_buffer_size= 1024*256;
1129 static uint8_t *bit_buffer= NULL;
1131 static void do_video_resample(OutputStream *ost,
1133 AVFrame *in_picture,
1134 AVFrame **out_picture)
1137 *out_picture = in_picture;
1139 AVCodecContext *dec = ist->st->codec;
1140 AVCodecContext *enc = ost->st->codec;
1141 int resample_changed = ost->resample_width != dec->width ||
1142 ost->resample_height != dec->height ||
1143 ost->resample_pix_fmt != dec->pix_fmt;
1145 *out_picture = in_picture;
1146 if (resample_changed) {
1147 av_log(NULL, AV_LOG_INFO,
1148 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1149 ist->file_index, ist->st->index,
1150 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1151 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1152 ost->resample_width = dec->width;
1153 ost->resample_height = dec->height;
1154 ost->resample_pix_fmt = dec->pix_fmt;
1157 ost->video_resample = dec->width != enc->width ||
1158 dec->height != enc->height ||
1159 dec->pix_fmt != enc->pix_fmt;
1161 if (ost->video_resample) {
1162 *out_picture = &ost->resample_frame;
1163 if (!ost->img_resample_ctx || resample_changed) {
1164 /* initialize the destination picture */
1165 if (!ost->resample_frame.data[0]) {
1166 avcodec_get_frame_defaults(&ost->resample_frame);
1167 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1168 enc->width, enc->height)) {
1169 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1173 /* initialize a new scaler context */
1174 sws_freeContext(ost->img_resample_ctx);
1175 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1176 enc->width, enc->height, enc->pix_fmt,
1177 ost->sws_flags, NULL, NULL, NULL);
1178 if (ost->img_resample_ctx == NULL) {
1179 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1183 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1184 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1190 static void do_video_out(AVFormatContext *s,
1193 AVFrame *in_picture,
1194 int *frame_size, float quality)
1196 int nb_frames, i, ret, format_video_sync;
1197 AVFrame *final_picture;
1198 AVCodecContext *enc;
1200 double duration = 0;
1202 enc = ost->st->codec;
1204 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1205 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1206 if(ist->st->avg_frame_rate.num)
1207 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1209 duration /= av_q2d(enc->time_base);
1212 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1214 /* by default, we output a single frame */
1219 format_video_sync = video_sync_method;
1220 if (format_video_sync < 0)
1221 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1223 if (format_video_sync) {
1224 double vdelta = sync_ipts - ost->sync_opts + duration;
1225 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1228 else if (format_video_sync == 2) {
1231 }else if(vdelta>0.6)
1232 ost->sync_opts= lrintf(sync_ipts);
1233 }else if (vdelta > 1.1)
1234 nb_frames = lrintf(vdelta);
1235 //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);
1236 if (nb_frames == 0){
1238 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1239 }else if (nb_frames > 1) {
1240 nb_frames_dup += nb_frames - 1;
1241 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1244 ost->sync_opts= lrintf(sync_ipts);
1246 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1250 do_video_resample(ost, ist, in_picture, &final_picture);
1252 /* duplicates frame if needed */
1253 for(i=0;i<nb_frames;i++) {
1255 av_init_packet(&pkt);
1256 pkt.stream_index= ost->index;
1258 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1259 /* raw pictures are written as AVPicture structure to
1260 avoid any copies. We support temporarily the older
1262 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1263 enc->coded_frame->top_field_first = in_picture->top_field_first;
1264 pkt.data= (uint8_t *)final_picture;
1265 pkt.size= sizeof(AVPicture);
1266 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1267 pkt.flags |= AV_PKT_FLAG_KEY;
1269 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1271 AVFrame big_picture;
1273 big_picture= *final_picture;
1274 /* better than nothing: use input picture interlaced
1276 big_picture.interlaced_frame = in_picture->interlaced_frame;
1277 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1278 if (ost->top_field_first == -1)
1279 big_picture.top_field_first = in_picture->top_field_first;
1281 big_picture.top_field_first = !!ost->top_field_first;
1284 /* handles same_quant here. This is not correct because it may
1285 not be a global option */
1286 big_picture.quality = quality;
1287 if (!enc->me_threshold)
1288 big_picture.pict_type = 0;
1289 // big_picture.pts = AV_NOPTS_VALUE;
1290 big_picture.pts= ost->sync_opts;
1291 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1292 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1293 if (ost->forced_kf_index < ost->forced_kf_count &&
1294 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1295 big_picture.pict_type = AV_PICTURE_TYPE_I;
1296 ost->forced_kf_index++;
1298 ret = avcodec_encode_video(enc,
1299 bit_buffer, bit_buffer_size,
1302 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1307 pkt.data= bit_buffer;
1309 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1310 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1311 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1312 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1313 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1315 if(enc->coded_frame->key_frame)
1316 pkt.flags |= AV_PKT_FLAG_KEY;
1317 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1320 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1321 // enc->frame_number-1, ret, enc->pict_type);
1322 /* if two pass, output log */
1323 if (ost->logfile && enc->stats_out) {
1324 fprintf(ost->logfile, "%s", enc->stats_out);
1329 ost->frame_number++;
1333 static double psnr(double d)
1335 return -10.0*log(d)/log(10.0);
1338 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1341 AVCodecContext *enc;
1343 double ti1, bitrate, avg_bitrate;
1345 /* this is executed just the first time do_video_stats is called */
1347 vstats_file = fopen(vstats_filename, "w");
1354 enc = ost->st->codec;
1355 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1356 frame_number = ost->frame_number;
1357 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1358 if (enc->flags&CODEC_FLAG_PSNR)
1359 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1361 fprintf(vstats_file,"f_size= %6d ", frame_size);
1362 /* compute pts value */
1363 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1367 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1368 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1369 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1370 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1371 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1375 static void print_report(OutputFile *output_files,
1376 OutputStream *ost_table, int nb_ostreams,
1377 int is_last_report, int64_t timer_start, int64_t cur_time)
1381 AVFormatContext *oc;
1383 AVCodecContext *enc;
1384 int frame_number, vid, i;
1386 int64_t pts = INT64_MAX;
1387 static int64_t last_time = -1;
1388 static int qp_histogram[52];
1389 int hours, mins, secs, us;
1391 if (!print_stats && !is_last_report)
1394 if (!is_last_report) {
1395 if (last_time == -1) {
1396 last_time = cur_time;
1399 if ((cur_time - last_time) < 500000)
1401 last_time = cur_time;
1405 oc = output_files[0].ctx;
1407 total_size = avio_size(oc->pb);
1408 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1409 total_size= avio_tell(oc->pb);
1413 for(i=0;i<nb_ostreams;i++) {
1415 ost = &ost_table[i];
1416 enc = ost->st->codec;
1417 if (!ost->stream_copy && enc->coded_frame)
1418 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1419 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1420 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1422 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1423 float t = (cur_time-timer_start) / 1000000.0;
1425 frame_number = ost->frame_number;
1426 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1427 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1429 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1433 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1436 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1438 if (enc->flags&CODEC_FLAG_PSNR){
1440 double error, error_sum=0;
1441 double scale, scale_sum=0;
1442 char type[3]= {'Y','U','V'};
1443 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1446 error= enc->error[j];
1447 scale= enc->width*enc->height*255.0*255.0*frame_number;
1449 error= enc->coded_frame->error[j];
1450 scale= enc->width*enc->height*255.0*255.0;
1455 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1457 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1461 /* compute min output value */
1462 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1463 ost->st->time_base, AV_TIME_BASE_Q));
1466 secs = pts / AV_TIME_BASE;
1467 us = pts % AV_TIME_BASE;
1473 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1475 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1476 "size=%8.0fkB time=", total_size / 1024.0);
1477 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1478 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1479 (100 * us) / AV_TIME_BASE);
1480 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1481 "bitrate=%6.1fkbits/s", bitrate);
1483 if (nb_frames_dup || nb_frames_drop)
1484 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1485 nb_frames_dup, nb_frames_drop);
1487 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1491 if (is_last_report) {
1492 int64_t raw= audio_size + video_size + extra_size;
1493 av_log(NULL, AV_LOG_INFO, "\n");
1494 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1498 100.0*(total_size - raw)/raw
1503 static void generate_silence(uint8_t *buf, enum AVSampleFormat sample_fmt, size_t size)
1505 int fill_char = 0x00;
1506 if (sample_fmt == AV_SAMPLE_FMT_U8)
1508 memset(buf, fill_char, size);
1511 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1515 for (i = 0; i < nb_ostreams; i++) {
1516 OutputStream *ost = &ost_table[i];
1517 AVCodecContext *enc = ost->st->codec;
1518 AVFormatContext *os = output_files[ost->file_index].ctx;
1520 if (!ost->encoding_needed)
1523 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1525 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1531 av_init_packet(&pkt);
1532 pkt.stream_index= ost->index;
1534 switch (ost->st->codec->codec_type) {
1535 case AVMEDIA_TYPE_AUDIO:
1536 fifo_bytes = av_fifo_size(ost->fifo);
1538 /* encode any samples remaining in fifo */
1539 if (fifo_bytes > 0) {
1540 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1541 int fs_tmp = enc->frame_size;
1543 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1544 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1545 enc->frame_size = fifo_bytes / (osize * enc->channels);
1547 int frame_bytes = enc->frame_size*osize*enc->channels;
1548 if (allocated_audio_buf_size < frame_bytes)
1550 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1553 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1554 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1555 ost->st->time_base.num, enc->sample_rate);
1556 enc->frame_size = fs_tmp;
1559 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1562 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1566 pkt.flags |= AV_PKT_FLAG_KEY;
1568 case AVMEDIA_TYPE_VIDEO:
1569 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1571 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1575 if(enc->coded_frame && enc->coded_frame->key_frame)
1576 pkt.flags |= AV_PKT_FLAG_KEY;
1577 if (ost->logfile && enc->stats_out) {
1578 fprintf(ost->logfile, "%s", enc->stats_out);
1587 pkt.data = bit_buffer;
1589 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1590 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1591 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1596 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1597 static int output_packet(InputStream *ist, int ist_index,
1598 OutputStream *ost_table, int nb_ostreams,
1599 const AVPacket *pkt)
1601 AVFormatContext *os;
1605 void *buffer_to_free = NULL;
1606 static unsigned int samples_size= 0;
1607 AVSubtitle subtitle, *subtitle_to_free;
1608 int64_t pkt_pts = AV_NOPTS_VALUE;
1610 int frame_available;
1615 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1617 if(ist->next_pts == AV_NOPTS_VALUE)
1618 ist->next_pts= ist->pts;
1622 av_init_packet(&avpkt);
1630 if(pkt->dts != AV_NOPTS_VALUE)
1631 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1632 if(pkt->pts != AV_NOPTS_VALUE)
1633 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1635 //while we have more to decode or while the decoder did output something on EOF
1636 while (avpkt.size > 0 || (!pkt && got_output)) {
1637 uint8_t *data_buf, *decoded_data_buf;
1638 int data_size, decoded_data_size;
1639 AVFrame *decoded_frame, *filtered_frame;
1641 ist->pts= ist->next_pts;
1643 if(avpkt.size && avpkt.size != pkt->size)
1644 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1645 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1646 ist->showed_multi_packet_warning=1;
1648 /* decode the packet if needed */
1649 decoded_frame = filtered_frame = NULL;
1650 decoded_data_buf = NULL; /* fail safe */
1651 decoded_data_size= 0;
1652 data_buf = avpkt.data;
1653 data_size = avpkt.size;
1654 subtitle_to_free = NULL;
1655 if (ist->decoding_needed) {
1656 switch(ist->st->codec->codec_type) {
1657 case AVMEDIA_TYPE_AUDIO:{
1658 if(pkt && samples_size < FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1659 samples_size = FFMAX(pkt->size * bps, AVCODEC_MAX_AUDIO_FRAME_SIZE);
1661 samples= av_malloc(samples_size);
1663 decoded_data_size= samples_size;
1664 /* XXX: could avoid copy if PCM 16 bits with same
1665 endianness as CPU */
1666 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1673 got_output = decoded_data_size > 0;
1674 /* Some bug in mpeg audio decoder gives */
1675 /* decoded_data_size < 0, it seems they are overflows */
1677 /* no audio frame */
1680 decoded_data_buf = (uint8_t *)samples;
1681 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1682 (ist->st->codec->sample_rate * ist->st->codec->channels);
1684 case AVMEDIA_TYPE_VIDEO:
1685 if (!(decoded_frame = avcodec_alloc_frame()))
1686 return AVERROR(ENOMEM);
1687 avpkt.pts = pkt_pts;
1688 avpkt.dts = ist->pts;
1689 pkt_pts = AV_NOPTS_VALUE;
1691 ret = avcodec_decode_video2(ist->st->codec,
1692 decoded_frame, &got_output, &avpkt);
1693 quality = same_quant ? decoded_frame->quality : 0;
1697 /* no picture yet */
1698 av_freep(&decoded_frame);
1699 goto discard_packet;
1701 ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
1702 if (ist->st->codec->time_base.num != 0) {
1703 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1704 ist->next_pts += ((int64_t)AV_TIME_BASE *
1705 ist->st->codec->time_base.num * ticks) /
1706 ist->st->codec->time_base.den;
1709 buffer_to_free = NULL;
1710 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1712 case AVMEDIA_TYPE_SUBTITLE:
1713 ret = avcodec_decode_subtitle2(ist->st->codec,
1714 &subtitle, &got_output, &avpkt);
1718 goto discard_packet;
1720 subtitle_to_free = &subtitle;
1727 switch(ist->st->codec->codec_type) {
1728 case AVMEDIA_TYPE_AUDIO:
1729 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1730 ist->st->codec->sample_rate;
1732 case AVMEDIA_TYPE_VIDEO:
1733 if (ist->st->codec->time_base.num != 0) {
1734 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1735 ist->next_pts += ((int64_t)AV_TIME_BASE *
1736 ist->st->codec->time_base.num * ticks) /
1737 ist->st->codec->time_base.den;
1745 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1746 for(i=0;i<nb_ostreams;i++) {
1747 OutputFile *of = &output_files[ost_table[i].file_index];
1748 if (of->start_time == 0 || ist->pts >= of->start_time) {
1749 ost = &ost_table[i];
1750 if (ost->input_video_filter && ost->source_index == ist_index) {
1751 if (!decoded_frame->sample_aspect_ratio.num)
1752 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1753 decoded_frame->pts = ist->pts;
1755 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
1761 // preprocess audio (volume)
1762 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1763 if (audio_volume != 256) {
1764 switch (ist->st->codec->sample_fmt) {
1765 case AV_SAMPLE_FMT_U8:
1767 uint8_t *volp = samples;
1768 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1769 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1770 *volp++ = av_clip_uint8(v);
1774 case AV_SAMPLE_FMT_S16:
1776 int16_t *volp = samples;
1777 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1778 int v = ((*volp) * audio_volume + 128) >> 8;
1779 *volp++ = av_clip_int16(v);
1783 case AV_SAMPLE_FMT_S32:
1785 int32_t *volp = samples;
1786 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1787 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1788 *volp++ = av_clipl_int32(v);
1792 case AV_SAMPLE_FMT_FLT:
1794 float *volp = samples;
1795 float scale = audio_volume / 256.f;
1796 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1801 case AV_SAMPLE_FMT_DBL:
1803 double *volp = samples;
1804 double scale = audio_volume / 256.;
1805 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1811 av_log(NULL, AV_LOG_FATAL,
1812 "Audio volume adjustment on sample format %s is not supported.\n",
1813 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1819 /* frame rate emulation */
1820 if (input_files[ist->file_index].rate_emu) {
1821 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1822 int64_t now = av_gettime() - ist->start;
1826 /* if output time reached then transcode raw format,
1827 encode packets and output them */
1828 for (i = 0; i < nb_ostreams; i++) {
1829 OutputFile *of = &output_files[ost_table[i].file_index];
1832 ost = &ost_table[i];
1833 if (ost->source_index != ist_index)
1836 if (of->start_time && ist->pts < of->start_time)
1839 if (of->recording_time != INT64_MAX &&
1840 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1841 (AVRational){1, 1000000}) >= 0) {
1842 ost->is_past_recording_time = 1;
1847 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1848 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1849 while (frame_available) {
1850 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1851 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1852 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1854 if (!filtered_frame && !(filtered_frame = avcodec_alloc_frame())) {
1855 ret = AVERROR(ENOMEM);
1858 *filtered_frame= *decoded_frame; //for me_threshold
1860 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
1861 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1865 filtered_frame = decoded_frame;
1867 os = output_files[ost->file_index].ctx;
1869 /* set the input output pts pairs */
1870 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1872 if (ost->encoding_needed) {
1873 av_assert0(ist->decoding_needed);
1874 switch(ost->st->codec->codec_type) {
1875 case AVMEDIA_TYPE_AUDIO:
1876 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1878 case AVMEDIA_TYPE_VIDEO:
1880 if (ost->picref->video && !ost->frame_aspect_ratio)
1881 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1883 do_video_out(os, ost, ist, filtered_frame, &frame_size,
1884 same_quant ? quality : ost->st->codec->global_quality);
1885 if (vstats_filename && frame_size)
1886 do_video_stats(os, ost, frame_size);
1888 case AVMEDIA_TYPE_SUBTITLE:
1889 do_subtitle_out(os, ost, ist, &subtitle,
1898 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1899 av_init_packet(&opkt);
1901 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1902 #if !CONFIG_AVFILTER
1908 /* no reencoding needed : output the packet directly */
1909 /* force the input stream PTS */
1911 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1912 audio_size += data_size;
1913 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1914 video_size += data_size;
1918 opkt.stream_index= ost->index;
1919 if(pkt->pts != AV_NOPTS_VALUE)
1920 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1922 opkt.pts= AV_NOPTS_VALUE;
1924 if (pkt->dts == AV_NOPTS_VALUE)
1925 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1927 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1928 opkt.dts -= ost_tb_start_time;
1930 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1931 opkt.flags= pkt->flags;
1933 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1934 if( ost->st->codec->codec_id != CODEC_ID_H264
1935 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1936 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1938 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1939 opkt.destruct= av_destruct_packet;
1941 opkt.data = data_buf;
1942 opkt.size = data_size;
1945 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1946 /* store AVPicture in AVPacket, as expected by the output format */
1947 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1948 opkt.data = (uint8_t *)&pict;
1949 opkt.size = sizeof(AVPicture);
1950 opkt.flags |= AV_PKT_FLAG_KEY;
1952 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1953 ost->st->codec->frame_number++;
1954 ost->frame_number++;
1955 av_free_packet(&opkt);
1959 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1960 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1961 avfilter_unref_buffer(ost->picref);
1963 av_freep(&filtered_frame);
1968 av_free(buffer_to_free);
1969 /* XXX: allocate the subtitles in the codec ? */
1970 if (subtitle_to_free) {
1971 avsubtitle_free(subtitle_to_free);
1972 subtitle_to_free = NULL;
1974 av_freep(&decoded_frame);
1983 static void print_sdp(OutputFile *output_files, int n)
1987 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1991 for (i = 0; i < n; i++)
1992 avc[i] = output_files[i].ctx;
1994 av_sdp_create(avc, n, sdp, sizeof(sdp));
1995 printf("SDP:\n%s\n", sdp);
2000 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2001 char *error, int error_len)
2003 InputStream *ist = &input_streams[ist_index];
2004 if (ist->decoding_needed) {
2005 AVCodec *codec = ist->dec;
2007 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d.%d",
2008 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2009 return AVERROR(EINVAL);
2011 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2012 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
2013 ist->file_index, ist->st->index);
2014 return AVERROR(EINVAL);
2016 assert_codec_experimental(ist->st->codec, 0);
2017 assert_avoptions(ist->opts);
2020 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;
2021 ist->next_pts = AV_NOPTS_VALUE;
2027 static int transcode_init(OutputFile *output_files, int nb_output_files,
2028 InputFile *input_files, int nb_input_files)
2030 int ret = 0, i, j, k;
2031 AVFormatContext *os;
2032 AVCodecContext *codec, *icodec;
2038 /* init framerate emulation */
2039 for (i = 0; i < nb_input_files; i++) {
2040 InputFile *ifile = &input_files[i];
2041 if (ifile->rate_emu)
2042 for (j = 0; j < ifile->nb_streams; j++)
2043 input_streams[j + ifile->ist_index].start = av_gettime();
2046 /* output stream init */
2047 for(i=0;i<nb_output_files;i++) {
2048 os = output_files[i].ctx;
2049 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
2050 av_dump_format(os, i, os->filename, 1);
2051 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2052 return AVERROR(EINVAL);
2056 /* for each output stream, we compute the right encoding parameters */
2057 for (i = 0; i < nb_output_streams; i++) {
2058 ost = &output_streams[i];
2059 os = output_files[ost->file_index].ctx;
2060 ist = &input_streams[ost->source_index];
2062 codec = ost->st->codec;
2063 icodec = ist->st->codec;
2065 ost->st->disposition = ist->st->disposition;
2066 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
2067 codec->chroma_sample_location = icodec->chroma_sample_location;
2069 if (ost->stream_copy) {
2070 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2072 if (extra_size > INT_MAX) {
2073 return AVERROR(EINVAL);
2076 /* if stream_copy is selected, no need to decode or encode */
2077 codec->codec_id = icodec->codec_id;
2078 codec->codec_type = icodec->codec_type;
2080 if(!codec->codec_tag){
2081 if( !os->oformat->codec_tag
2082 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
2083 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
2084 codec->codec_tag = icodec->codec_tag;
2087 codec->bit_rate = icodec->bit_rate;
2088 codec->rc_max_rate = icodec->rc_max_rate;
2089 codec->rc_buffer_size = icodec->rc_buffer_size;
2090 codec->extradata= av_mallocz(extra_size);
2091 if (!codec->extradata) {
2092 return AVERROR(ENOMEM);
2094 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2095 codec->extradata_size= icodec->extradata_size;
2097 codec->time_base = ist->st->time_base;
2098 if(!strcmp(os->oformat->name, "avi")) {
2099 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){
2100 codec->time_base = icodec->time_base;
2101 codec->time_base.num *= icodec->ticks_per_frame;
2102 codec->time_base.den *= 2;
2104 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2105 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){
2106 codec->time_base = icodec->time_base;
2107 codec->time_base.num *= icodec->ticks_per_frame;
2110 av_reduce(&codec->time_base.num, &codec->time_base.den,
2111 codec->time_base.num, codec->time_base.den, INT_MAX);
2113 switch(codec->codec_type) {
2114 case AVMEDIA_TYPE_AUDIO:
2115 if(audio_volume != 256) {
2116 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2119 codec->channel_layout = icodec->channel_layout;
2120 codec->sample_rate = icodec->sample_rate;
2121 codec->channels = icodec->channels;
2122 codec->frame_size = icodec->frame_size;
2123 codec->audio_service_type = icodec->audio_service_type;
2124 codec->block_align= icodec->block_align;
2125 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2126 codec->block_align= 0;
2127 if(codec->codec_id == CODEC_ID_AC3)
2128 codec->block_align= 0;
2130 case AVMEDIA_TYPE_VIDEO:
2131 codec->pix_fmt = icodec->pix_fmt;
2132 codec->width = icodec->width;
2133 codec->height = icodec->height;
2134 codec->has_b_frames = icodec->has_b_frames;
2135 if (!codec->sample_aspect_ratio.num) {
2136 codec->sample_aspect_ratio =
2137 ost->st->sample_aspect_ratio =
2138 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2139 ist->st->codec->sample_aspect_ratio.num ?
2140 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2143 case AVMEDIA_TYPE_SUBTITLE:
2144 codec->width = icodec->width;
2145 codec->height = icodec->height;
2147 case AVMEDIA_TYPE_DATA:
2148 case AVMEDIA_TYPE_ATTACHMENT:
2155 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2156 ist->decoding_needed = 1;
2157 ost->encoding_needed = 1;
2158 switch(codec->codec_type) {
2159 case AVMEDIA_TYPE_AUDIO:
2160 ost->fifo= av_fifo_alloc(1024);
2162 return AVERROR(ENOMEM);
2164 if (!codec->sample_rate)
2165 codec->sample_rate = icodec->sample_rate;
2166 choose_sample_rate(ost->st, ost->enc);
2167 codec->time_base = (AVRational){1, codec->sample_rate};
2168 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2169 codec->sample_fmt = icodec->sample_fmt;
2170 choose_sample_fmt(ost->st, ost->enc);
2171 if (!codec->channels) {
2172 codec->channels = icodec->channels;
2173 codec->channel_layout = icodec->channel_layout;
2175 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2176 codec->channel_layout = 0;
2177 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2178 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2179 || codec->channel_layout != icodec->channel_layout;
2180 icodec->request_channels = codec->channels;
2181 ost->resample_sample_fmt = icodec->sample_fmt;
2182 ost->resample_sample_rate = icodec->sample_rate;
2183 ost->resample_channels = icodec->channels;
2185 case AVMEDIA_TYPE_VIDEO:
2186 if (codec->pix_fmt == PIX_FMT_NONE)
2187 codec->pix_fmt = icodec->pix_fmt;
2188 choose_pixel_fmt(ost->st, ost->enc);
2190 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2191 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2195 if (!codec->width || !codec->height) {
2196 codec->width = icodec->width;
2197 codec->height = icodec->height;
2200 ost->video_resample = codec->width != icodec->width ||
2201 codec->height != icodec->height ||
2202 codec->pix_fmt != icodec->pix_fmt;
2203 if (ost->video_resample) {
2204 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2207 ost->resample_height = icodec->height;
2208 ost->resample_width = icodec->width;
2209 ost->resample_pix_fmt= icodec->pix_fmt;
2211 if (!ost->frame_rate.num)
2212 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2213 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2214 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2215 ost->frame_rate = ost->enc->supported_framerates[idx];
2217 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2218 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2219 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2220 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2221 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2223 for (j = 0; j < ost->forced_kf_count; j++)
2224 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2229 if (configure_video_filters(ist, ost)) {
2230 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2235 case AVMEDIA_TYPE_SUBTITLE:
2242 if (codec->codec_id != CODEC_ID_H264 &&
2243 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2244 char logfilename[1024];
2247 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2248 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2250 if (codec->flags & CODEC_FLAG_PASS2) {
2252 size_t logbuffer_size;
2253 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2254 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2258 codec->stats_in = logbuffer;
2260 if (codec->flags & CODEC_FLAG_PASS1) {
2261 f = fopen(logfilename, "wb");
2263 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2264 logfilename, strerror(errno));
2271 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2272 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2273 int size= codec->width * codec->height;
2274 bit_buffer_size= FFMAX(bit_buffer_size, 7*size + 10000);
2279 bit_buffer = av_malloc(bit_buffer_size);
2281 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2283 return AVERROR(ENOMEM);
2286 /* open each encoder */
2287 for (i = 0; i < nb_output_streams; i++) {
2288 ost = &output_streams[i];
2289 if (ost->encoding_needed) {
2290 AVCodec *codec = ost->enc;
2291 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2293 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2294 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2295 ret = AVERROR(EINVAL);
2298 if (dec->subtitle_header) {
2299 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2300 if (!ost->st->codec->subtitle_header) {
2301 ret = AVERROR(ENOMEM);
2304 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2305 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2307 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2308 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2309 ost->file_index, ost->index);
2310 ret = AVERROR(EINVAL);
2313 assert_codec_experimental(ost->st->codec, 1);
2314 assert_avoptions(ost->opts);
2315 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2316 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2317 " It takes bits/s as argument, not kbits/s\n");
2318 extra_size += ost->st->codec->extradata_size;
2320 if (ost->st->codec->me_threshold)
2321 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2325 /* init input streams */
2326 for (i = 0; i < nb_input_streams; i++)
2327 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2330 /* discard unused programs */
2331 for (i = 0; i < nb_input_files; i++) {
2332 InputFile *ifile = &input_files[i];
2333 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2334 AVProgram *p = ifile->ctx->programs[j];
2335 int discard = AVDISCARD_ALL;
2337 for (k = 0; k < p->nb_stream_indexes; k++)
2338 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2339 discard = AVDISCARD_DEFAULT;
2342 p->discard = discard;
2346 /* open files and write file headers */
2347 for (i = 0; i < nb_output_files; i++) {
2348 os = output_files[i].ctx;
2349 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2350 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2351 ret = AVERROR(EINVAL);
2354 // assert_avoptions(output_files[i].opts);
2355 if (strcmp(os->oformat->name, "rtp")) {
2361 /* dump the file output parameters - cannot be done before in case
2363 for(i=0;i<nb_output_files;i++) {
2364 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2367 /* dump the stream mapping */
2368 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2369 for (i = 0; i < nb_output_streams; i++) {
2370 ost = &output_streams[i];
2371 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d -> #%d.%d",
2372 input_streams[ost->source_index].file_index,
2373 input_streams[ost->source_index].st->index,
2376 if (ost->sync_ist != &input_streams[ost->source_index])
2377 av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
2378 ost->sync_ist->file_index,
2379 ost->sync_ist->st->index);
2380 if (ost->stream_copy)
2381 av_log(NULL, AV_LOG_INFO, " (copy)");
2383 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2384 input_streams[ost->source_index].dec->name : "?",
2385 ost->enc ? ost->enc->name : "?");
2386 av_log(NULL, AV_LOG_INFO, "\n");
2390 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2395 print_sdp(output_files, nb_output_files);
2402 * The following code is the main loop of the file converter
2404 static int transcode(OutputFile *output_files, int nb_output_files,
2405 InputFile *input_files, int nb_input_files)
2408 AVFormatContext *is, *os;
2412 int no_packet_count=0;
2413 int64_t timer_start;
2416 if (!(no_packet = av_mallocz(nb_input_files)))
2419 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2424 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2425 avio_set_interrupt_cb(decode_interrupt_cb);
2428 timer_start = av_gettime();
2430 for(; received_sigterm == 0;) {
2431 int file_index, ist_index;
2435 int64_t cur_time= av_gettime();
2437 ipts_min= INT64_MAX;
2439 /* if 'q' pressed, exits */
2441 static int64_t last_time;
2442 if (received_nb_signals)
2444 /* read_key() returns 0 on EOF */
2445 if(cur_time - last_time >= 100000 && !run_as_daemon){
2447 last_time = cur_time;
2452 if (key == '+') av_log_set_level(av_log_get_level()+10);
2453 if (key == '-') av_log_set_level(av_log_get_level()-10);
2454 if (key == 's') qp_hist ^= 1;
2457 do_hex_dump = do_pkt_dump = 0;
2458 } else if(do_pkt_dump){
2462 av_log_set_level(AV_LOG_DEBUG);
2465 if (key == 'c' || key == 'C'){
2466 char buf[4096], target[64], command[256], arg[256] = {0};
2469 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2471 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2476 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2477 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2478 target, time, command, arg);
2479 for (i = 0; i < nb_output_streams; i++) {
2480 ost = &output_streams[i];
2483 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2484 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2485 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2487 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2492 av_log(NULL, AV_LOG_ERROR,
2493 "Parse error, at least 3 arguments were expected, "
2494 "only %d given in string '%s'\n", n, buf);
2498 if (key == 'd' || key == 'D'){
2501 debug = input_streams[0].st->codec->debug<<1;
2502 if(!debug) debug = 1;
2503 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2506 scanf("%d", &debug);
2507 for(i=0;i<nb_input_streams;i++) {
2508 input_streams[i].st->codec->debug = debug;
2510 for(i=0;i<nb_output_streams;i++) {
2511 ost = &output_streams[i];
2512 ost->st->codec->debug = debug;
2514 if(debug) av_log_set_level(AV_LOG_DEBUG);
2515 fprintf(stderr,"debug=%d\n", debug);
2518 fprintf(stderr, "key function\n"
2519 "? show this help\n"
2520 "+ increase verbosity\n"
2521 "- decrease verbosity\n"
2522 "c Send command to filtergraph\n"
2523 "D cycle through available debug modes\n"
2524 "h dump packets/hex press to cycle through the 3 states\n"
2526 "s Show QP histogram\n"
2531 /* select the stream that we must read now by looking at the
2532 smallest output pts */
2534 for (i = 0; i < nb_output_streams; i++) {
2538 ost = &output_streams[i];
2539 of = &output_files[ost->file_index];
2540 os = output_files[ost->file_index].ctx;
2541 ist = &input_streams[ost->source_index];
2542 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2543 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2545 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2547 if (!input_files[ist->file_index].eof_reached){
2548 if(ipts < ipts_min) {
2550 if(input_sync ) file_index = ist->file_index;
2552 if(opts < opts_min) {
2554 if(!input_sync) file_index = ist->file_index;
2557 if (ost->frame_number >= ost->max_frames) {
2559 for (j = 0; j < of->ctx->nb_streams; j++)
2560 output_streams[of->ost_index + j].is_past_recording_time = 1;
2564 /* if none, if is finished */
2565 if (file_index < 0) {
2566 if(no_packet_count){
2568 memset(no_packet, 0, nb_input_files);
2575 /* read a frame from it and output it in the fifo */
2576 is = input_files[file_index].ctx;
2577 ret= av_read_frame(is, &pkt);
2578 if(ret == AVERROR(EAGAIN)){
2579 no_packet[file_index]=1;
2584 input_files[file_index].eof_reached = 1;
2592 memset(no_packet, 0, nb_input_files);
2595 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2596 is->streams[pkt.stream_index]);
2598 /* the following test is needed in case new streams appear
2599 dynamically in stream : we ignore them */
2600 if (pkt.stream_index >= input_files[file_index].nb_streams)
2601 goto discard_packet;
2602 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2603 ist = &input_streams[ist_index];
2605 goto discard_packet;
2607 if (pkt.dts != AV_NOPTS_VALUE)
2608 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2609 if (pkt.pts != AV_NOPTS_VALUE)
2610 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2612 if(pkt.pts != AV_NOPTS_VALUE)
2613 pkt.pts *= ist->ts_scale;
2614 if(pkt.dts != AV_NOPTS_VALUE)
2615 pkt.dts *= ist->ts_scale;
2617 // 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);
2618 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2619 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2620 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2621 int64_t delta= pkt_dts - ist->next_pts;
2622 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2623 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2624 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2625 pkt_dts+1<ist->pts)&& !copy_ts){
2626 input_files[ist->file_index].ts_offset -= delta;
2627 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2628 delta, input_files[ist->file_index].ts_offset);
2629 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2630 if(pkt.pts != AV_NOPTS_VALUE)
2631 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2635 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2636 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2638 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d.%d\n",
2639 ist->file_index, ist->st->index);
2642 av_free_packet(&pkt);
2647 av_free_packet(&pkt);
2649 /* dump report by using the output first video and audio streams */
2650 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
2653 /* at the end of stream, we must flush the decoder buffers */
2654 for (i = 0; i < nb_input_streams; i++) {
2655 ist = &input_streams[i];
2656 if (ist->decoding_needed) {
2657 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2660 flush_encoders(output_streams, nb_output_streams);
2664 /* write the trailer if needed and close file */
2665 for(i=0;i<nb_output_files;i++) {
2666 os = output_files[i].ctx;
2667 av_write_trailer(os);
2670 /* dump report by using the first video and audio streams */
2671 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
2673 /* close each encoder */
2674 for (i = 0; i < nb_output_streams; i++) {
2675 ost = &output_streams[i];
2676 if (ost->encoding_needed) {
2677 av_freep(&ost->st->codec->stats_in);
2678 avcodec_close(ost->st->codec);
2681 avfilter_graph_free(&ost->graph);
2685 /* close each decoder */
2686 for (i = 0; i < nb_input_streams; i++) {
2687 ist = &input_streams[i];
2688 if (ist->decoding_needed) {
2689 avcodec_close(ist->st->codec);
2697 av_freep(&bit_buffer);
2698 av_freep(&no_packet);
2700 if (output_streams) {
2701 for (i = 0; i < nb_output_streams; i++) {
2702 ost = &output_streams[i];
2704 if (ost->stream_copy)
2705 av_freep(&ost->st->codec->extradata);
2707 fclose(ost->logfile);
2708 ost->logfile = NULL;
2710 av_fifo_free(ost->fifo); /* works even if fifo is not
2711 initialized but set to zero */
2712 av_freep(&ost->st->codec->subtitle_header);
2713 av_free(ost->resample_frame.data[0]);
2714 av_free(ost->forced_kf_pts);
2715 if (ost->video_resample)
2716 sws_freeContext(ost->img_resample_ctx);
2717 swr_free(&ost->swr);
2718 av_dict_free(&ost->opts);
2725 static int opt_frame_crop(const char *opt, const char *arg)
2727 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
2728 return AVERROR(EINVAL);
2731 static int opt_pad(const char *opt, const char *arg)
2733 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
2737 static double parse_frame_aspect_ratio(const char *arg)
2744 p = strchr(arg, ':');
2746 x = strtol(arg, &end, 10);
2748 y = strtol(end+1, &end, 10);
2750 ar = (double)x / (double)y;
2752 ar = strtod(arg, NULL);
2755 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2761 static int opt_video_channel(const char *opt, const char *arg)
2763 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2764 return opt_default("channel", arg);
2767 static int opt_video_standard(const char *opt, const char *arg)
2769 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2770 return opt_default("standard", arg);
2773 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2775 audio_codec_name = arg;
2776 return parse_option(o, "codec:a", arg, options);
2779 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2781 video_codec_name = arg;
2782 return parse_option(o, "codec:v", arg, options);
2785 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2787 subtitle_codec_name = arg;
2788 return parse_option(o, "codec:s", arg, options);
2791 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2793 return parse_option(o, "codec:d", arg, options);
2796 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2798 StreamMap *m = NULL;
2799 int i, negative = 0, file_idx;
2800 int sync_file_idx = -1, sync_stream_idx;
2808 map = av_strdup(arg);
2810 /* parse sync stream first, just pick first matching stream */
2811 if (sync = strchr(map, ',')) {
2813 sync_file_idx = strtol(sync + 1, &sync, 0);
2814 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2815 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2820 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2821 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2822 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2823 sync_stream_idx = i;
2826 if (i == input_files[sync_file_idx].nb_streams) {
2827 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2828 "match any streams.\n", arg);
2834 file_idx = strtol(map, &p, 0);
2835 if (file_idx >= nb_input_files || file_idx < 0) {
2836 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2840 /* disable some already defined maps */
2841 for (i = 0; i < o->nb_stream_maps; i++) {
2842 m = &o->stream_maps[i];
2843 if (check_stream_specifier(input_files[m->file_index].ctx,
2844 input_files[m->file_index].ctx->streams[m->stream_index],
2845 *p == ':' ? p + 1 : p) > 0)
2849 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2850 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2851 *p == ':' ? p + 1 : p) <= 0)
2853 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2854 &o->nb_stream_maps, o->nb_stream_maps + 1);
2855 m = &o->stream_maps[o->nb_stream_maps - 1];
2857 m->file_index = file_idx;
2858 m->stream_index = i;
2860 if (sync_file_idx >= 0) {
2861 m->sync_file_index = sync_file_idx;
2862 m->sync_stream_index = sync_stream_idx;
2864 m->sync_file_index = file_idx;
2865 m->sync_stream_index = i;
2870 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2878 static void parse_meta_type(char *arg, char *type, int *index)
2888 if (*(++arg) == ':')
2889 *index = strtol(++arg, NULL, 0);
2892 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2899 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2901 MetadataMap *m, *m1;
2904 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2905 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2907 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2908 m->file = strtol(arg, &p, 0);
2909 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2911 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2912 if (p = strchr(opt, ':'))
2913 parse_meta_type(p + 1, &m1->type, &m1->index);
2917 if (m->type == 'g' || m1->type == 'g')
2918 o->metadata_global_manual = 1;
2919 if (m->type == 's' || m1->type == 's')
2920 o->metadata_streams_manual = 1;
2921 if (m->type == 'c' || m1->type == 'c')
2922 o->metadata_chapters_manual = 1;
2927 static int opt_map_meta_data(OptionsContext *o, const char *opt, const char *arg)
2929 av_log(NULL, AV_LOG_WARNING, "-map_meta_data is deprecated and will be removed soon. "
2930 "Use -map_metadata instead.\n");
2931 return opt_map_metadata(o, opt, arg);
2934 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
2937 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2938 struct tm time = *gmtime((time_t*)&recording_timestamp);
2939 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2940 parse_option(o, "metadata", buf, options);
2942 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2943 "tag instead.\n", opt);
2947 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2949 const char *codec_string = encoder ? "encoder" : "decoder";
2953 avcodec_find_encoder_by_name(name) :
2954 avcodec_find_decoder_by_name(name);
2956 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2959 if(codec->type != type) {
2960 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2966 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
2968 char *codec_name = NULL;
2970 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2972 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
2973 st->codec->codec_id = codec->id;
2976 return avcodec_find_decoder(st->codec->codec_id);
2980 * Add all the streams from the given input file to the global
2981 * list of input streams.
2983 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2985 int i, rfps, rfps_base;
2986 char *next, *codec_tag = NULL;
2988 for (i = 0; i < ic->nb_streams; i++) {
2989 AVStream *st = ic->streams[i];
2990 AVCodecContext *dec = st->codec;
2994 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2995 ist = &input_streams[nb_input_streams - 1];
2997 ist->file_index = nb_input_files;
2999 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3001 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
3002 ist->ts_scale = scale;
3004 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3006 uint32_t tag = strtol(codec_tag, &next, 0);
3008 tag = AV_RL32(codec_tag);
3009 st->codec->codec_tag = tag;
3012 ist->dec = choose_decoder(o, ic, st);
3014 switch (dec->codec_type) {
3015 case AVMEDIA_TYPE_AUDIO:
3017 ist->dec = avcodec_find_decoder(dec->codec_id);
3018 if(o->audio_disable)
3019 st->discard= AVDISCARD_ALL;
3021 case AVMEDIA_TYPE_VIDEO:
3023 ist->dec = avcodec_find_decoder(dec->codec_id);
3024 rfps = ic->streams[i]->r_frame_rate.num;
3025 rfps_base = ic->streams[i]->r_frame_rate.den;
3027 dec->flags |= CODEC_FLAG_EMU_EDGE;
3030 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3032 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",
3033 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3034 (float)rfps / rfps_base, rfps, rfps_base);
3037 if (o->video_disable)
3038 st->discard= AVDISCARD_ALL;
3039 else if(video_discard)
3040 st->discard= video_discard;
3042 case AVMEDIA_TYPE_DATA:
3044 case AVMEDIA_TYPE_SUBTITLE:
3046 ist->dec = avcodec_find_decoder(dec->codec_id);
3047 if(o->subtitle_disable)
3048 st->discard = AVDISCARD_ALL;
3050 case AVMEDIA_TYPE_ATTACHMENT:
3051 case AVMEDIA_TYPE_UNKNOWN:
3059 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3061 AVFormatContext *ic;
3062 AVInputFormat *file_iformat = NULL;
3066 AVDictionary **opts;
3067 int orig_nb_streams; // number of streams before avformat_find_stream_info
3070 if (!(file_iformat = av_find_input_format(o->format))) {
3071 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3076 if (!strcmp(filename, "-"))
3079 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3080 !strcmp(filename, "/dev/stdin");
3082 /* get default parameters from command line */
3083 ic = avformat_alloc_context();
3085 print_error(filename, AVERROR(ENOMEM));
3088 if (o->nb_audio_sample_rate) {
3089 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3090 av_dict_set(&format_opts, "sample_rate", buf, 0);
3092 if (o->nb_audio_channels) {
3093 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3094 av_dict_set(&format_opts, "channels", buf, 0);
3096 if (o->nb_frame_rates) {
3097 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3099 if (o->nb_frame_sizes) {
3100 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3102 if (o->nb_frame_pix_fmts)
3103 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3105 ic->video_codec_id = video_codec_name ?
3106 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3107 ic->audio_codec_id = audio_codec_name ?
3108 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3109 ic->subtitle_codec_id= subtitle_codec_name ?
3110 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3111 ic->flags |= AVFMT_FLAG_NONBLOCK;
3114 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3115 ic->loop_input = loop_input;
3118 /* open the input file with generic libav function */
3119 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3121 print_error(filename, err);
3124 assert_avoptions(format_opts);
3126 /* apply forced codec ids */
3127 for (i = 0; i < ic->nb_streams; i++)
3128 choose_decoder(o, ic, ic->streams[i]);
3130 /* Set AVCodecContext options for avformat_find_stream_info */
3131 opts = setup_find_stream_info_opts(ic, codec_opts);
3132 orig_nb_streams = ic->nb_streams;
3134 /* If not enough info to get the stream parameters, we decode the
3135 first frames to get it. (used in mpeg case for example) */
3136 ret = avformat_find_stream_info(ic, opts);
3138 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3139 av_close_input_file(ic);
3143 timestamp = o->start_time;
3144 /* add the stream start time */
3145 if (ic->start_time != AV_NOPTS_VALUE)
3146 timestamp += ic->start_time;
3148 /* if seeking requested, we execute it */
3149 if (o->start_time != 0) {
3150 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3152 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3153 filename, (double)timestamp / AV_TIME_BASE);
3157 /* update the current parameters so that they match the one of the input stream */
3158 add_input_streams(o, ic);
3160 /* dump the file content */
3161 av_dump_format(ic, nb_input_files, filename, 0);
3163 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3164 input_files[nb_input_files - 1].ctx = ic;
3165 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3166 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3167 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3168 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3170 for (i = 0; i < orig_nb_streams; i++)
3171 av_dict_free(&opts[i]);
3174 reset_options(o, 1);
3178 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3183 for (p = kf; *p; p++)
3186 ost->forced_kf_count = n;
3187 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3188 if (!ost->forced_kf_pts) {
3189 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3192 for (i = 0; i < n; i++) {
3193 p = i ? strchr(p, ',') + 1 : kf;
3194 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3198 static uint8_t *get_line(AVIOContext *s)
3204 if (avio_open_dyn_buf(&line) < 0) {
3205 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3209 while ((c = avio_r8(s)) && c != '\n')
3212 avio_close_dyn_buf(line, &buf);
3217 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3220 char filename[1000];
3221 const char *base[3] = { getenv("AVCONV_DATADIR"),
3226 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3230 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3231 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3232 ret = avio_open(s, filename, AVIO_FLAG_READ);
3235 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3236 i != 1 ? "" : "/.avconv", preset_name);
3237 ret = avio_open(s, filename, AVIO_FLAG_READ);
3243 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3245 char *codec_name = NULL;
3247 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3249 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3250 NULL, ost->st->codec->codec_type);
3251 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3252 } else if (!strcmp(codec_name, "copy"))
3253 ost->stream_copy = 1;
3255 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3256 ost->st->codec->codec_id = ost->enc->id;
3260 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3263 AVStream *st = avformat_new_stream(oc, NULL);
3264 int idx = oc->nb_streams - 1, ret = 0;
3265 int64_t max_frames = INT64_MAX;
3266 char *bsf = NULL, *next, *codec_tag = NULL;
3267 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3269 char *buf = NULL, *arg = NULL, *preset = NULL;
3270 AVIOContext *s = NULL;
3273 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3277 if (oc->nb_streams - 1 < o->nb_streamid_map)
3278 st->id = o->streamid_map[oc->nb_streams - 1];
3280 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3281 nb_output_streams + 1);
3282 ost = &output_streams[nb_output_streams - 1];
3283 ost->file_index = nb_output_files;
3286 st->codec->codec_type = type;
3287 choose_encoder(o, oc, ost);
3289 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3292 avcodec_get_context_defaults3(st->codec, ost->enc);
3293 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3295 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3296 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3299 if (!buf[0] || buf[0] == '#') {
3303 if (!(arg = strchr(buf, '='))) {
3304 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3308 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3310 } while (!s->eof_reached);
3314 av_log(NULL, AV_LOG_FATAL,
3315 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3316 preset, ost->file_index, ost->index);
3320 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
3321 ost->max_frames = max_frames;
3323 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3325 if (next = strchr(bsf, ','))
3327 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3328 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3332 bsfc_prev->next = bsfc;
3334 ost->bitstream_filters = bsfc;
3340 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3342 uint32_t tag = strtol(codec_tag, &next, 0);
3344 tag = AV_RL32(codec_tag);
3345 st->codec->codec_tag = tag;
3348 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3349 if (qscale >= 0 || same_quant) {
3350 st->codec->flags |= CODEC_FLAG_QSCALE;
3351 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3354 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3355 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3357 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3361 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3364 const char *p = str;
3371 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3378 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3382 AVCodecContext *video_enc;
3384 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3386 video_enc = st->codec;
3388 if (!ost->stream_copy) {
3389 const char *p = NULL;
3390 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3391 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3392 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3393 int i, force_fps = 0, top_field_first = -1;
3395 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3396 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3397 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3401 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3402 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3403 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3407 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3408 if (frame_aspect_ratio)
3409 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3411 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3412 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3413 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3414 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3417 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3420 video_enc->gop_size = 0;
3421 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3423 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3424 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3427 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3429 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3431 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3432 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3435 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3438 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3441 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3443 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3446 /* FIXME realloc failure */
3447 video_enc->rc_override=
3448 av_realloc(video_enc->rc_override,
3449 sizeof(RcOverride)*(i+1));
3450 video_enc->rc_override[i].start_frame= start;
3451 video_enc->rc_override[i].end_frame = end;
3453 video_enc->rc_override[i].qscale= q;
3454 video_enc->rc_override[i].quality_factor= 1.0;
3457 video_enc->rc_override[i].qscale= 0;
3458 video_enc->rc_override[i].quality_factor= -q/100.0;
3463 video_enc->rc_override_count=i;
3464 if (!video_enc->rc_initial_buffer_occupancy)
3465 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3466 video_enc->intra_dc_precision= intra_dc_precision - 8;
3471 video_enc->flags |= CODEC_FLAG_PASS1;
3474 video_enc->flags |= CODEC_FLAG_PASS2;
3478 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3479 if (forced_key_frames)
3480 parse_forced_key_frames(forced_key_frames, ost);
3482 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3483 ost->force_fps = force_fps;
3485 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3486 ost->top_field_first = top_field_first;
3489 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3491 ost->avfilter = av_strdup(filters);
3498 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3502 AVCodecContext *audio_enc;
3504 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3507 audio_enc = st->codec;
3508 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3510 if (!ost->stream_copy) {
3511 char *sample_fmt = NULL;
3513 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3515 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3517 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3518 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3522 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3524 ost->rematrix_volume=1.0;
3525 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
3531 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3535 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3536 if (!ost->stream_copy) {
3537 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3544 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3546 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3547 ost->stream_copy = 1;
3551 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3555 AVCodecContext *subtitle_enc;
3557 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3559 subtitle_enc = st->codec;
3561 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3566 /* arg format is "output-stream-index:streamid-value". */
3567 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3573 av_strlcpy(idx_str, arg, sizeof(idx_str));
3574 p = strchr(idx_str, ':');
3576 av_log(NULL, AV_LOG_FATAL,
3577 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3582 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3583 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3584 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3588 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3590 AVFormatContext *is = ifile->ctx;
3591 AVFormatContext *os = ofile->ctx;
3594 for (i = 0; i < is->nb_chapters; i++) {
3595 AVChapter *in_ch = is->chapters[i], *out_ch;
3596 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3597 AV_TIME_BASE_Q, in_ch->time_base);
3598 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3599 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3602 if (in_ch->end < ts_off)
3604 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3607 out_ch = av_mallocz(sizeof(AVChapter));
3609 return AVERROR(ENOMEM);
3611 out_ch->id = in_ch->id;
3612 out_ch->time_base = in_ch->time_base;
3613 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3614 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3617 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3620 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
3622 return AVERROR(ENOMEM);
3623 os->chapters[os->nb_chapters - 1] = out_ch;
3628 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3631 AVFormatContext *ic = NULL;
3633 err = avformat_open_input(&ic, filename, NULL, NULL);
3636 /* copy stream format */
3637 for(i=0;i<ic->nb_streams;i++) {
3641 AVCodecContext *avctx;
3643 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3644 ost = new_output_stream(o, s, codec->type);
3648 // FIXME: a more elegant solution is needed
3649 memcpy(st, ic->streams[i], sizeof(AVStream));
3650 st->info = av_malloc(sizeof(*st->info));
3651 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3653 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3655 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
3656 choose_sample_fmt(st, codec);
3657 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
3658 choose_pixel_fmt(st, codec);
3661 av_close_input_file(ic);
3665 static void opt_output_file(void *optctx, const char *filename)
3667 OptionsContext *o = optctx;
3668 AVFormatContext *oc;
3670 AVOutputFormat *file_oformat;
3674 if (!strcmp(filename, "-"))
3677 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3679 print_error(filename, err);
3682 file_oformat= oc->oformat;
3684 if (!strcmp(file_oformat->name, "ffm") &&
3685 av_strstart(filename, "http:", NULL)) {
3687 /* special case for files sent to ffserver: we get the stream
3688 parameters from ffserver */
3689 int err = read_ffserver_streams(o, oc, filename);
3691 print_error(filename, err);
3694 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
3695 ost = &output_streams[j];
3696 for (i = 0; i < nb_input_streams; i++) {
3697 ist = &input_streams[i];
3698 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
3700 ost->source_index= i;
3706 } else if (!o->nb_stream_maps) {
3707 /* pick the "best" stream of each type */
3708 #define NEW_STREAM(type, index)\
3710 ost = new_ ## type ## _stream(o, oc);\
3711 ost->source_index = index;\
3712 ost->sync_ist = &input_streams[index];\
3713 input_streams[index].discard = 0;\
3716 /* video: highest resolution */
3717 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3718 int area = 0, idx = -1;
3719 for (i = 0; i < nb_input_streams; i++) {
3720 ist = &input_streams[i];
3721 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3722 ist->st->codec->width * ist->st->codec->height > area) {
3723 area = ist->st->codec->width * ist->st->codec->height;
3727 NEW_STREAM(video, idx);
3730 /* audio: most channels */
3731 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3732 int channels = 0, idx = -1;
3733 for (i = 0; i < nb_input_streams; i++) {
3734 ist = &input_streams[i];
3735 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3736 ist->st->codec->channels > channels) {
3737 channels = ist->st->codec->channels;
3741 NEW_STREAM(audio, idx);
3744 /* subtitles: pick first */
3745 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
3746 for (i = 0; i < nb_input_streams; i++)
3747 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3748 NEW_STREAM(subtitle, i);
3752 /* do something with data? */
3754 for (i = 0; i < o->nb_stream_maps; i++) {
3755 StreamMap *map = &o->stream_maps[i];
3760 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3761 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
3763 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
3765 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
3768 switch (ist->st->codec->codec_type) {
3769 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3770 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3771 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3772 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3773 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3775 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3776 map->file_index, map->stream_index);
3780 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3781 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3782 map->sync_stream_index];
3787 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3788 output_files[nb_output_files - 1].ctx = oc;
3789 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3790 output_files[nb_output_files - 1].recording_time = o->recording_time;
3791 output_files[nb_output_files - 1].start_time = o->start_time;
3792 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3793 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3795 /* check filename in case of an image number is expected */
3796 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3797 if (!av_filename_number_test(oc->filename)) {
3798 print_error(oc->filename, AVERROR(EINVAL));
3803 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3804 /* test if it already exists to avoid loosing precious files */
3805 if (!file_overwrite &&
3806 (strchr(filename, ':') == NULL ||
3807 filename[1] == ':' ||
3808 av_strstart(filename, "file:", NULL))) {
3809 if (avio_check(filename, 0) == 0) {
3811 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3814 if (!read_yesno()) {
3815 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3821 av_log(0, AV_LOG_FATAL,"File '%s' already exists. Exiting.\n", filename);
3828 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3829 print_error(filename, err);
3834 if (o->mux_preload) {
3836 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3837 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3839 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3841 if (loop_output >= 0) {
3842 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3843 oc->loop_output = loop_output;
3847 if (o->chapters_input_file >= nb_input_files) {
3848 if (o->chapters_input_file == INT_MAX) {
3849 /* copy chapters from the first input file that has them*/
3850 o->chapters_input_file = -1;
3851 for (i = 0; i < nb_input_files; i++)
3852 if (input_files[i].ctx->nb_chapters) {
3853 o->chapters_input_file = i;
3857 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3858 o->chapters_input_file);
3862 if (o->chapters_input_file >= 0)
3863 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3864 !o->metadata_chapters_manual);
3867 for (i = 0; i < o->nb_meta_data_maps; i++) {
3868 AVFormatContext *files[2];
3869 AVDictionary **meta[2];
3872 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3873 if ((index) < 0 || (index) >= (nb_elems)) {\
3874 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3879 int in_file_index = o->meta_data_maps[i][1].file;
3880 if (in_file_index < 0)
3882 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3885 files[1] = input_files[in_file_index].ctx;
3887 for (j = 0; j < 2; j++) {
3888 MetadataMap *map = &o->meta_data_maps[i][j];
3890 switch (map->type) {
3892 meta[j] = &files[j]->metadata;
3895 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3896 meta[j] = &files[j]->streams[map->index]->metadata;
3899 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3900 meta[j] = &files[j]->chapters[map->index]->metadata;
3903 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3904 meta[j] = &files[j]->programs[map->index]->metadata;
3911 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3914 /* copy global metadata by default */
3915 if (!o->metadata_global_manual && nb_input_files){
3916 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3917 AV_DICT_DONT_OVERWRITE);
3918 if(o->recording_time != INT64_MAX)
3919 av_dict_set(&oc->metadata, "duration", NULL, 0);
3921 if (!o->metadata_streams_manual)
3922 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3923 InputStream *ist = &input_streams[output_streams[i].source_index];
3924 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3927 /* process manually set metadata */
3928 for (i = 0; i < o->nb_metadata; i++) {
3933 val = strchr(o->metadata[i].u.str, '=');
3935 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3936 o->metadata[i].u.str);
3941 parse_meta_type(o->metadata[i].specifier, &type, &index);
3947 if (index < 0 || index >= oc->nb_streams) {
3948 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3951 m = &oc->streams[index]->metadata;
3954 if (index < 0 || index >= oc->nb_chapters) {
3955 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3958 m = &oc->chapters[index]->metadata;
3961 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3965 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3968 reset_options(o, 0);
3971 /* same option as mencoder */
3972 static int opt_pass(const char *opt, const char *arg)
3974 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
3978 static int64_t getutime(void)
3981 struct rusage rusage;
3983 getrusage(RUSAGE_SELF, &rusage);
3984 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3985 #elif HAVE_GETPROCESSTIMES
3987 FILETIME c, e, k, u;
3988 proc = GetCurrentProcess();
3989 GetProcessTimes(proc, &c, &e, &k, &u);
3990 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3992 return av_gettime();
3996 static int64_t getmaxrss(void)
3998 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3999 struct rusage rusage;
4000 getrusage(RUSAGE_SELF, &rusage);
4001 return (int64_t)rusage.ru_maxrss * 1024;
4002 #elif HAVE_GETPROCESSMEMORYINFO
4004 PROCESS_MEMORY_COUNTERS memcounters;
4005 proc = GetCurrentProcess();
4006 memcounters.cb = sizeof(memcounters);
4007 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4008 return memcounters.PeakPagefileUsage;
4014 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4016 return parse_option(o, "q:a", arg, options);
4019 static void show_usage(void)
4021 printf("Hyper fast Audio and Video encoder\n");
4022 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4026 static int opt_help(const char *opt, const char *arg)
4028 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4029 av_log_set_callback(log_callback_help);
4031 show_help_options(options, "Main options:\n",
4032 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4033 show_help_options(options, "\nAdvanced options:\n",
4034 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4036 show_help_options(options, "\nVideo options:\n",
4037 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4039 show_help_options(options, "\nAdvanced Video options:\n",
4040 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4041 OPT_VIDEO | OPT_EXPERT);
4042 show_help_options(options, "\nAudio options:\n",
4043 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4045 show_help_options(options, "\nAdvanced Audio options:\n",
4046 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4047 OPT_AUDIO | OPT_EXPERT);
4048 show_help_options(options, "\nSubtitle options:\n",
4049 OPT_SUBTITLE | OPT_GRAB,
4051 show_help_options(options, "\nAudio/Video grab options:\n",
4055 show_help_children(avcodec_get_class(), flags);
4056 show_help_children(avformat_get_class(), flags);
4057 show_help_children(sws_get_class(), flags);
4062 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4064 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4065 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4067 if(!strncmp(arg, "pal-", 4)) {
4070 } else if(!strncmp(arg, "ntsc-", 5)) {
4073 } else if(!strncmp(arg, "film-", 5)) {
4077 /* Try to determine PAL/NTSC by peeking in the input files */
4078 if(nb_input_files) {
4080 for (j = 0; j < nb_input_files; j++) {
4081 for (i = 0; i < input_files[j].nb_streams; i++) {
4082 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4083 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4085 fr = c->time_base.den * 1000 / c->time_base.num;
4089 } else if((fr == 29970) || (fr == 23976)) {
4098 if (norm != UNKNOWN)
4099 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4102 if(norm == UNKNOWN) {
4103 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4104 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4105 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4109 if(!strcmp(arg, "vcd")) {
4110 opt_video_codec(o, "c:v", "mpeg1video");
4111 opt_audio_codec(o, "c:a", "mp2");
4112 parse_option(o, "f", "vcd", options);
4114 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4115 parse_option(o, "r", frame_rates[norm], options);
4116 opt_default("g", norm == PAL ? "15" : "18");
4118 opt_default("b", "1150000");
4119 opt_default("maxrate", "1150000");
4120 opt_default("minrate", "1150000");
4121 opt_default("bufsize", "327680"); // 40*1024*8;
4123 opt_default("b:a", "224000");
4124 parse_option(o, "ar", "44100", options);
4125 parse_option(o, "ac", "2", options);
4127 opt_default("packetsize", "2324");
4128 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4130 /* We have to offset the PTS, so that it is consistent with the SCR.
4131 SCR starts at 36000, but the first two packs contain only padding
4132 and the first pack from the other stream, respectively, may also have
4133 been written before.
4134 So the real data starts at SCR 36000+3*1200. */
4135 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
4136 } else if(!strcmp(arg, "svcd")) {
4138 opt_video_codec(o, "c:v", "mpeg2video");
4139 opt_audio_codec(o, "c:a", "mp2");
4140 parse_option(o, "f", "svcd", options);
4142 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4143 parse_option(o, "r", frame_rates[norm], options);
4144 parse_option(o, "pix_fmt", "yuv420p", options);
4145 opt_default("g", norm == PAL ? "15" : "18");
4147 opt_default("b", "2040000");
4148 opt_default("maxrate", "2516000");
4149 opt_default("minrate", "0"); //1145000;
4150 opt_default("bufsize", "1835008"); //224*1024*8;
4151 opt_default("flags", "+scan_offset");
4154 opt_default("b:a", "224000");
4155 parse_option(o, "ar", "44100", options);
4157 opt_default("packetsize", "2324");
4159 } else if(!strcmp(arg, "dvd")) {
4161 opt_video_codec(o, "c:v", "mpeg2video");
4162 opt_audio_codec(o, "c:a", "ac3");
4163 parse_option(o, "f", "dvd", options);
4165 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4166 parse_option(o, "r", frame_rates[norm], options);
4167 parse_option(o, "pix_fmt", "yuv420p", options);
4168 opt_default("g", norm == PAL ? "15" : "18");
4170 opt_default("b", "6000000");
4171 opt_default("maxrate", "9000000");
4172 opt_default("minrate", "0"); //1500000;
4173 opt_default("bufsize", "1835008"); //224*1024*8;
4175 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4176 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4178 opt_default("b:a", "448000");
4179 parse_option(o, "ar", "48000", options);
4181 } else if(!strncmp(arg, "dv", 2)) {
4183 parse_option(o, "f", "dv", options);
4185 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4186 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4187 norm == PAL ? "yuv420p" : "yuv411p", options);
4188 parse_option(o, "r", frame_rates[norm], options);
4190 parse_option(o, "ar", "48000", options);
4191 parse_option(o, "ac", "2", options);
4194 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4195 return AVERROR(EINVAL);
4200 static int opt_vstats_file(const char *opt, const char *arg)
4202 av_free (vstats_filename);
4203 vstats_filename=av_strdup (arg);
4207 static int opt_vstats(const char *opt, const char *arg)
4210 time_t today2 = time(NULL);
4211 struct tm *today = localtime(&today2);
4213 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4215 return opt_vstats_file(opt, filename);
4218 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4220 return parse_option(o, "frames:v", arg, options);
4223 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4225 return parse_option(o, "frames:a", arg, options);
4228 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4230 return parse_option(o, "frames:d", arg, options);
4233 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4236 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4237 const char *codec_name = *opt == 'v' ? video_codec_name :
4238 *opt == 'a' ? audio_codec_name :
4239 subtitle_codec_name;
4241 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4242 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4243 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4245 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4250 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4251 if(line[0] == '#' && !e)
4253 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4255 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4258 if(!strcmp(tmp, "acodec")){
4259 opt_audio_codec(o, tmp, tmp2);
4260 }else if(!strcmp(tmp, "vcodec")){
4261 opt_video_codec(o, tmp, tmp2);
4262 }else if(!strcmp(tmp, "scodec")){
4263 opt_subtitle_codec(o, tmp, tmp2);
4264 }else if(!strcmp(tmp, "dcodec")){
4265 opt_data_codec(o, tmp, tmp2);
4266 }else if(opt_default(tmp, tmp2) < 0){
4267 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4277 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4281 static int opt_passlogfile(const char *opt, const char *arg)
4283 pass_logfilename_prefix = arg;
4284 #if CONFIG_LIBX264_ENCODER
4285 return opt_default("passlogfile", arg);
4291 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4293 char *s= av_malloc(strlen(opt)+2);
4294 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4295 return parse_option(o, s, arg, options);
4298 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4300 if(!strcmp(opt, "b")){
4301 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4302 return parse_option(o, av_strdup("b:v"), arg, options);
4304 return opt_default(opt, arg);
4307 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4309 return parse_option(o, "filter:v", arg, options);
4312 #define OFFSET(x) offsetof(OptionsContext, x)
4313 static const OptionDef options[] = {
4315 #include "cmdutils_common_opts.h"
4316 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4317 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4318 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4319 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4320 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4321 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4322 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4323 { "map_meta_data", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4324 "outfile[,metadata]:infile[,metadata]" },
4325 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4326 "outfile[,metadata]:infile[,metadata]" },
4327 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4328 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4329 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4330 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4331 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4332 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4333 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4334 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4335 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4336 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4337 "add timings for benchmarking" },
4338 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4339 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4340 "dump each input packet" },
4341 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4342 "when dumping packets, also dump the payload" },
4343 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4344 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4345 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4346 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4347 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4348 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4349 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4350 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4351 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4352 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4353 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4354 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4355 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4356 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4357 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4358 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4359 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4361 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4363 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4366 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4367 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4368 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4369 { "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" },
4370 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4371 { "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" },
4372 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4373 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4374 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4375 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4376 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4377 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4378 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4379 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4380 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4381 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4382 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4383 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4384 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4385 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4386 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4387 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4388 "use same quantizer as source (implies VBR)" },
4389 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4390 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4391 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4392 "deinterlace pictures" },
4393 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4394 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4396 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4398 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4399 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4400 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4401 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4402 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4403 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4404 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4405 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4406 { "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" },
4407 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4410 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4411 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4412 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4413 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4414 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4415 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4416 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4417 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4418 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4419 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4421 /* subtitle options */
4422 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4423 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4424 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4427 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4428 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4429 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4432 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4433 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4435 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4436 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
4437 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
4439 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
4440 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
4441 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
4442 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
4443 /* data codec support */
4444 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4446 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4450 int main(int argc, char **argv)
4452 OptionsContext o = { 0 };
4455 reset_options(&o, 0);
4457 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4458 parse_loglevel(argc, argv, options);
4460 if(argc>1 && !strcmp(argv[1], "-d")){
4462 av_log_set_callback(log_callback_null);
4467 avcodec_register_all();
4469 avdevice_register_all();
4472 avfilter_register_all();
4477 if(isatty(STDIN_FILENO))
4478 avio_set_interrupt_cb(decode_interrupt_cb);
4486 parse_options(&o, argc, argv, options, opt_output_file);
4488 if(nb_output_files <= 0 && nb_input_files == 0) {
4490 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4494 /* file converter / grab */
4495 if (nb_output_files <= 0) {
4496 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4500 if (nb_input_files == 0) {
4501 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4506 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4508 ti = getutime() - ti;
4510 int maxrss = getmaxrss() / 1024;
4511 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);