2 * Copyright (c) 2000-2003 Fabrice Bellard
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * multimedia converter based on the FFmpeg libraries
35 #include "libavformat/avformat.h"
36 #include "libavdevice/avdevice.h"
37 #include "libswscale/swscale.h"
38 #include "libswresample/swresample.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/audioconvert.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/samplefmt.h"
43 #include "libavutil/colorspace.h"
44 #include "libavutil/fifo.h"
45 #include "libavutil/intreadwrite.h"
46 #include "libavutil/dict.h"
47 #include "libavutil/mathematics.h"
48 #include "libavutil/pixdesc.h"
49 #include "libavutil/avstring.h"
50 #include "libavutil/libm.h"
51 #include "libavutil/imgutils.h"
52 #include "libavutil/timestamp.h"
53 #include "libavutil/bprint.h"
54 #include "libavformat/os_support.h"
56 #include "libavformat/ffm.h" // not public API
58 # include "libavfilter/avcodec.h"
59 # include "libavfilter/avfilter.h"
60 # include "libavfilter/avfiltergraph.h"
61 # include "libavfilter/buffersrc.h"
62 # include "libavfilter/buffersink.h"
64 #if HAVE_SYS_RESOURCE_H
65 #include <sys/types.h>
67 #include <sys/resource.h>
68 #elif HAVE_GETPROCESSTIMES
71 #if HAVE_GETPROCESSMEMORYINFO
77 #include <sys/select.h>
82 #include <sys/ioctl.h>
92 #include "libavutil/avassert.h"
95 #define VSYNC_PASSTHROUGH 0
98 #define VSYNC_DROP 0xff
102 const char program_name[] = "ffmpeg";
103 const int program_birth_year = 2000;
105 /* select an input stream for an output stream */
106 typedef struct StreamMap {
107 int disabled; /** 1 is this mapping is disabled by a negative map */
111 int sync_stream_index;
112 char *linklabel; /** name of an output link, for mapping lavfi outputs */
116 int file_idx, stream_idx, channel_idx; // input
117 int ofile_idx, ostream_idx; // output
120 static const OptionDef options[];
122 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
124 static int frame_bits_per_raw_sample = 0;
125 static int video_discard = 0;
126 static int same_quant = 0;
127 static int do_deinterlace = 0;
128 static int intra_dc_precision = 8;
129 static int qp_hist = 0;
130 static int intra_only = 0;
131 static const char *video_codec_name = NULL;
132 static const char *audio_codec_name = NULL;
133 static const char *subtitle_codec_name = NULL;
135 static int file_overwrite = 0;
136 static int no_file_overwrite = 0;
137 static int do_benchmark = 0;
138 static int do_benchmark_all = 0;
139 static int do_hex_dump = 0;
140 static int do_pkt_dump = 0;
141 static int do_psnr = 0;
142 static int do_pass = 0;
143 static const char *pass_logfilename_prefix;
144 static int video_sync_method = VSYNC_AUTO;
145 static int audio_sync_method = 0;
146 static float audio_drift_threshold = 0.1;
147 static int copy_ts = 0;
148 static int copy_tb = -1;
149 static int opt_shortest = 0;
150 static char *vstats_filename;
151 static FILE *vstats_file;
153 static int audio_volume = 256;
155 static int exit_on_error = 0;
156 static int using_stdin = 0;
157 static int run_as_daemon = 0;
158 static volatile int received_nb_signals = 0;
159 static int64_t video_size = 0;
160 static int64_t audio_size = 0;
161 static int64_t extra_size = 0;
162 static int nb_frames_dup = 0;
163 static int nb_frames_drop = 0;
164 static int input_sync;
166 static float dts_delta_threshold = 10;
167 static float dts_error_threshold = 3600*30;
169 static int print_stats = 1;
170 static int debug_ts = 0;
171 static int current_time;
173 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
175 typedef struct InputFilter {
176 AVFilterContext *filter;
177 struct InputStream *ist;
178 struct FilterGraph *graph;
181 typedef struct OutputFilter {
182 AVFilterContext *filter;
183 struct OutputStream *ost;
184 struct FilterGraph *graph;
186 /* temporary storage until stream maps are processed */
187 AVFilterInOut *out_tmp;
190 typedef struct FilterGraph {
192 const char *graph_desc;
194 AVFilterGraph *graph;
196 InputFilter **inputs;
198 OutputFilter **outputs;
202 typedef struct FrameBuffer {
208 enum PixelFormat pix_fmt;
211 struct InputStream *ist;
212 struct FrameBuffer *next;
215 typedef struct InputStream {
218 int discard; /* true if stream data should be discarded */
219 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
221 AVFrame *decoded_frame;
223 int64_t start; /* time when read started */
224 /* predicted dts of the next packet read for this stream or (when there are
225 * several frames in a packet) of the next frame in current packet */
227 /* dts of the last packet read for this stream */
230 int64_t next_pts; /* synthetic pts for the next decode frame */
231 int64_t pts; /* current pts of the decoded frame */
233 int is_start; /* is 1 at the start and after a discontinuity */
235 int showed_multi_packet_warning;
240 int resample_pix_fmt;
242 int resample_sample_fmt;
243 int resample_sample_rate;
244 int resample_channels;
245 uint64_t resample_channel_layout;
247 /* a pool of free buffers for decoded data */
248 FrameBuffer *buffer_pool;
251 /* decoded data from this stream goes into all those filters
252 * currently video and audio only */
253 InputFilter **filters;
257 typedef struct InputFile {
258 AVFormatContext *ctx;
259 int eof_reached; /* true if eof reached */
260 int ist_index; /* index of first stream in input_streams */
261 int buffer_size; /* current total buffer size */
263 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
264 from ctx.nb_streams if new streams appear during av_read_frame() */
268 typedef struct OutputStream {
269 int file_index; /* file index */
270 int index; /* stream index in the output file */
271 int source_index; /* InputStream index */
272 AVStream *st; /* stream in the output file */
273 int encoding_needed; /* true if encoding needed for this stream */
275 /* input pts and corresponding output pts
277 struct InputStream *sync_ist; /* input stream to sync against */
278 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
279 /* pts of the first frame encoded for this stream, used for limiting
282 AVBitStreamFilterContext *bitstream_filters;
285 AVFrame *filtered_frame;
288 AVRational frame_rate;
292 float frame_aspect_ratio;
295 /* forced key frames */
296 int64_t *forced_kf_pts;
301 int audio_channels_map[SWR_CH_MAX]; /* list of the channels id to pick from the source stream */
302 int audio_channels_mapped; /* number of channels in audio_channels_map */
306 OutputFilter *filter;
310 int64_t swr_dither_method;
311 double swr_dither_scale;
313 int is_past_recording_time;
315 const char *attachment_filename;
316 int copy_initial_nonkeyframes;
324 /* init terminal so that we can grab keys */
325 static struct termios oldtty;
326 static int restore_tty;
329 typedef struct OutputFile {
330 AVFormatContext *ctx;
332 int ost_index; /* index of the first stream in output_streams */
333 int64_t recording_time; /* desired length of the resulting file in microseconds */
334 int64_t start_time; /* start time in microseconds */
335 uint64_t limit_filesize; /* filesize limit expressed in bytes */
338 static InputStream **input_streams = NULL;
339 static int nb_input_streams = 0;
340 static InputFile **input_files = NULL;
341 static int nb_input_files = 0;
343 static OutputStream **output_streams = NULL;
344 static int nb_output_streams = 0;
345 static OutputFile **output_files = NULL;
346 static int nb_output_files = 0;
348 static FilterGraph **filtergraphs;
351 typedef struct OptionsContext {
352 /* input/output options */
356 SpecifierOpt *codec_names;
358 SpecifierOpt *audio_channels;
359 int nb_audio_channels;
360 SpecifierOpt *audio_sample_rate;
361 int nb_audio_sample_rate;
362 SpecifierOpt *frame_rates;
364 SpecifierOpt *frame_sizes;
366 SpecifierOpt *frame_pix_fmts;
367 int nb_frame_pix_fmts;
370 int64_t input_ts_offset;
373 SpecifierOpt *ts_scale;
375 SpecifierOpt *dump_attachment;
376 int nb_dump_attachment;
379 StreamMap *stream_maps;
381 AudioChannelMap *audio_channel_maps; /* one info entry per -map_channel */
382 int nb_audio_channel_maps; /* number of (valid) -map_channel settings */
383 int metadata_global_manual;
384 int metadata_streams_manual;
385 int metadata_chapters_manual;
386 const char **attachments;
389 int chapters_input_file;
391 int64_t recording_time;
392 uint64_t limit_filesize;
398 int subtitle_disable;
401 /* indexed by output file stream index */
405 SpecifierOpt *metadata;
407 SpecifierOpt *max_frames;
409 SpecifierOpt *bitstream_filters;
410 int nb_bitstream_filters;
411 SpecifierOpt *codec_tags;
413 SpecifierOpt *sample_fmts;
415 SpecifierOpt *qscale;
417 SpecifierOpt *forced_key_frames;
418 int nb_forced_key_frames;
419 SpecifierOpt *force_fps;
421 SpecifierOpt *frame_aspect_ratios;
422 int nb_frame_aspect_ratios;
423 SpecifierOpt *rc_overrides;
425 SpecifierOpt *intra_matrices;
426 int nb_intra_matrices;
427 SpecifierOpt *inter_matrices;
428 int nb_inter_matrices;
429 SpecifierOpt *top_field_first;
430 int nb_top_field_first;
431 SpecifierOpt *metadata_map;
433 SpecifierOpt *presets;
435 SpecifierOpt *copy_initial_nonkeyframes;
436 int nb_copy_initial_nonkeyframes;
437 SpecifierOpt *filters;
441 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
444 for (i = 0; i < o->nb_ ## name; i++) {\
445 char *spec = o->name[i].specifier;\
446 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
447 outvar = o->name[i].u.type;\
453 static int64_t getutime(void)
456 struct rusage rusage;
458 getrusage(RUSAGE_SELF, &rusage);
459 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
460 #elif HAVE_GETPROCESSTIMES
463 proc = GetCurrentProcess();
464 GetProcessTimes(proc, &c, &e, &k, &u);
465 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
471 static void update_benchmark(const char *fmt, ...)
473 if (do_benchmark_all) {
474 int64_t t = getutime();
480 vsnprintf(buf, sizeof(buf), fmt, va);
482 printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
488 static void reset_options(OptionsContext *o, int is_input)
490 const OptionDef *po = options;
491 OptionsContext bak= *o;
494 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
496 void *dst = (uint8_t*)o + po->u.off;
498 if (po->flags & OPT_SPEC) {
499 SpecifierOpt **so = dst;
500 int i, *count = (int*)(so + 1);
501 for (i = 0; i < *count; i++) {
502 av_freep(&(*so)[i].specifier);
503 if (po->flags & OPT_STRING)
504 av_freep(&(*so)[i].u.str);
508 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
513 for (i = 0; i < o->nb_stream_maps; i++)
514 av_freep(&o->stream_maps[i].linklabel);
515 av_freep(&o->stream_maps);
516 av_freep(&o->audio_channel_maps);
517 av_freep(&o->streamid_map);
519 memset(o, 0, sizeof(*o));
521 if(is_input) o->recording_time = bak.recording_time;
522 else o->recording_time = INT64_MAX;
523 o->mux_max_delay = 0.7;
524 o->limit_filesize = UINT64_MAX;
525 o->chapters_input_file = INT_MAX;
531 static int alloc_buffer(InputStream *ist, AVCodecContext *s, FrameBuffer **pbuf)
533 FrameBuffer *buf = av_mallocz(sizeof(*buf));
535 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
536 int h_chroma_shift, v_chroma_shift;
537 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
538 int w = s->width, h = s->height;
541 return AVERROR(ENOMEM);
543 avcodec_align_dimensions(s, &w, &h);
545 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
550 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
551 s->pix_fmt, 32)) < 0) {
555 /* XXX this shouldn't be needed, but some tests break without this line
556 * those decoders are buggy and need to be fixed.
557 * the following tests fail:
558 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
560 memset(buf->base[0], 128, ret);
562 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
563 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
564 const int h_shift = i==0 ? 0 : h_chroma_shift;
565 const int v_shift = i==0 ? 0 : v_chroma_shift;
566 if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1] || !buf->base[i])
567 buf->data[i] = buf->base[i];
569 buf->data[i] = buf->base[i] +
570 FFALIGN((buf->linesize[i]*edge >> v_shift) +
571 (pixel_size*edge >> h_shift), 32);
575 buf->pix_fmt = s->pix_fmt;
582 static void free_buffer_pool(InputStream *ist)
584 FrameBuffer *buf = ist->buffer_pool;
586 ist->buffer_pool = buf->next;
587 av_freep(&buf->base[0]);
589 buf = ist->buffer_pool;
593 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
595 av_assert0(buf->refcount > 0);
597 if (!buf->refcount) {
599 for(tmp= ist->buffer_pool; tmp; tmp= tmp->next)
600 av_assert1(tmp != buf);
601 buf->next = ist->buffer_pool;
602 ist->buffer_pool = buf;
606 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
608 InputStream *ist = s->opaque;
612 if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0)
615 if (!ist->buffer_pool && (ret = alloc_buffer(ist, s, &ist->buffer_pool)) < 0)
618 buf = ist->buffer_pool;
619 ist->buffer_pool = buf->next;
621 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
622 av_freep(&buf->base[0]);
624 if ((ret = alloc_buffer(ist, s, &buf)) < 0)
627 av_assert0(!buf->refcount);
631 frame->type = FF_BUFFER_TYPE_USER;
632 frame->extended_data = frame->data;
633 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
634 frame->width = buf->w;
635 frame->height = buf->h;
636 frame->format = buf->pix_fmt;
637 frame->sample_aspect_ratio = s->sample_aspect_ratio;
639 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
640 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
641 frame->data[i] = buf->data[i];
642 frame->linesize[i] = buf->linesize[i];
648 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
650 InputStream *ist = s->opaque;
651 FrameBuffer *buf = frame->opaque;
654 if(frame->type!=FF_BUFFER_TYPE_USER)
655 return avcodec_default_release_buffer(s, frame);
657 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
658 frame->data[i] = NULL;
660 unref_buffer(ist, buf);
663 static void filter_release_buffer(AVFilterBuffer *fb)
665 FrameBuffer *buf = fb->priv;
667 unref_buffer(buf->ist, buf);
670 static enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target)
672 if (codec && codec->pix_fmts) {
673 const enum PixelFormat *p = codec->pix_fmts;
674 int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0;
675 enum PixelFormat best= PIX_FMT_NONE;
676 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
677 if (st->codec->codec_id == CODEC_ID_MJPEG) {
678 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
679 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
680 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
681 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
684 for (; *p != PIX_FMT_NONE; p++) {
685 best= avcodec_find_best_pix_fmt2(best, *p, target, has_alpha, NULL);
689 if (*p == PIX_FMT_NONE) {
690 if (target != PIX_FMT_NONE)
691 av_log(NULL, AV_LOG_WARNING,
692 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
693 av_pix_fmt_descriptors[target].name,
695 av_pix_fmt_descriptors[best].name);
702 static char *choose_pix_fmts(OutputStream *ost)
704 if (ost->keep_pix_fmt) {
706 avfilter_graph_set_auto_convert(ost->filter->graph->graph,
707 AVFILTER_AUTO_CONVERT_NONE);
708 if (ost->st->codec->pix_fmt == PIX_FMT_NONE)
710 return av_strdup(av_get_pix_fmt_name(ost->st->codec->pix_fmt));
712 if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
713 return av_strdup(av_get_pix_fmt_name(choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt)));
714 } else if (ost->enc->pix_fmts) {
715 const enum PixelFormat *p;
716 AVIOContext *s = NULL;
720 if (avio_open_dyn_buf(&s) < 0)
723 p = ost->enc->pix_fmts;
724 if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
725 if (ost->st->codec->codec_id == CODEC_ID_MJPEG) {
726 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
727 } else if (ost->st->codec->codec_id == CODEC_ID_LJPEG) {
728 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
729 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
733 for (; *p != PIX_FMT_NONE; p++) {
734 const char *name = av_get_pix_fmt_name(*p);
735 avio_printf(s, "%s:", name);
737 len = avio_close_dyn_buf(s, &ret);
745 * Define a function for building a string containing a list of
748 #define DEF_CHOOSE_FORMAT(type, var, supported_list, none, get_name, separator) \
749 static char *choose_ ## var ## s(OutputStream *ost) \
751 if (ost->st->codec->var != none) { \
752 get_name(ost->st->codec->var); \
753 return av_strdup(name); \
754 } else if (ost->enc->supported_list) { \
756 AVIOContext *s = NULL; \
760 if (avio_open_dyn_buf(&s) < 0) \
763 for (p = ost->enc->supported_list; *p != none; p++) { \
765 avio_printf(s, "%s" separator, name); \
767 len = avio_close_dyn_buf(s, &ret); \
774 #define GET_PIX_FMT_NAME(pix_fmt)\
775 const char *name = av_get_pix_fmt_name(pix_fmt);
777 // DEF_CHOOSE_FORMAT(enum PixelFormat, pix_fmt, pix_fmts, PIX_FMT_NONE,
778 // GET_PIX_FMT_NAME, ":")
780 #define GET_SAMPLE_FMT_NAME(sample_fmt)\
781 const char *name = av_get_sample_fmt_name(sample_fmt)
783 DEF_CHOOSE_FORMAT(enum AVSampleFormat, sample_fmt, sample_fmts,
784 AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME, ",")
786 #define GET_SAMPLE_RATE_NAME(rate)\
788 snprintf(name, sizeof(name), "%d", rate);
790 DEF_CHOOSE_FORMAT(int, sample_rate, supported_samplerates, 0,
791 GET_SAMPLE_RATE_NAME, ",")
793 #define GET_CH_LAYOUT_NAME(ch_layout)\
795 snprintf(name, sizeof(name), "0x%"PRIx64, ch_layout);
797 DEF_CHOOSE_FORMAT(uint64_t, channel_layout, channel_layouts, 0,
798 GET_CH_LAYOUT_NAME, ",")
800 static int configure_audio_filters(FilterGraph *fg, AVFilterContext **in_filter,
801 AVFilterContext **out_filter)
803 InputStream *ist = fg->inputs[0]->ist;
804 OutputStream *ost = fg->outputs[0]->ost;
805 AVCodecContext *codec = ost->st->codec;
806 AVCodecContext *icodec = ist->st->codec;
807 char *sample_fmts, *sample_rates, *channel_layouts;
811 avfilter_graph_free(&fg->graph);
812 if (!(fg->graph = avfilter_graph_alloc()))
813 return AVERROR(ENOMEM);
815 snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:"
816 "channel_layout=0x%"PRIx64, ist->st->time_base.num,
817 ist->st->time_base.den, icodec->sample_rate,
818 av_get_sample_fmt_name(icodec->sample_fmt), icodec->channel_layout);
819 ret = avfilter_graph_create_filter(&fg->inputs[0]->filter,
820 avfilter_get_by_name("abuffer"),
821 "src", args, NULL, fg->graph);
825 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter,
826 avfilter_get_by_name("abuffersink_old"),
827 "out", NULL, NULL, fg->graph);
831 *in_filter = fg->inputs[0]->filter;
832 *out_filter = fg->outputs[0]->filter;
834 if (codec->channels && !codec->channel_layout)
835 codec->channel_layout = av_get_default_channel_layout(codec->channels);
837 sample_fmts = choose_sample_fmts(ost);
838 sample_rates = choose_sample_rates(ost);
839 channel_layouts = choose_channel_layouts(ost);
840 if (sample_fmts || sample_rates || channel_layouts) {
841 AVFilterContext *format;
846 len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:",
849 len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:",
852 len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:",
856 av_freep(&sample_fmts);
857 av_freep(&sample_rates);
858 av_freep(&channel_layouts);
860 ret = avfilter_graph_create_filter(&format,
861 avfilter_get_by_name("aformat"),
862 "aformat", args, NULL, fg->graph);
866 ret = avfilter_link(format, 0, fg->outputs[0]->filter, 0);
870 *out_filter = format;
873 if (audio_sync_method > 0) {
874 AVFilterContext *aswr;
875 char args[256] = {0};
877 av_strlcatf(args, sizeof(args), "min_comp=0.001:min_hard_comp=%f", audio_drift_threshold);
879 if (audio_sync_method > 1)
880 av_strlcatf(args, sizeof(args), ":max_soft_comp=%f", audio_sync_method/(double)icodec->sample_rate);
882 av_log(NULL, AV_LOG_INFO, "-async %d is forwarded to lavfi similarly to -af aresample=%s\n", audio_sync_method, args);
884 ret = avfilter_graph_create_filter(&aswr, avfilter_get_by_name("aresample"),
885 "aresample", args, NULL, fg->graph);
889 ret = avfilter_link(*in_filter, 0, aswr, 0);
896 #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \
897 AVFilterContext *filt_ctx; \
899 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
900 "similarly to -af " filter_name "=%s.\n", arg); \
902 ret = avfilter_graph_create_filter(&filt_ctx, \
903 avfilter_get_by_name(filter_name), \
904 filter_name, arg, NULL, fg->graph); \
908 ret = avfilter_link(*in_filter, 0, filt_ctx, 0); \
912 *in_filter = filt_ctx; \
915 if (ost->audio_channels_mapped) {
919 av_bprint_init(&pan_buf, 256, 8192);
920 av_bprintf(&pan_buf, "0x%"PRIx64,
921 av_get_default_channel_layout(ost->audio_channels_mapped));
922 for (i = 0; i < ost->audio_channels_mapped; i++)
923 if (ost->audio_channels_map[i] != -1)
924 av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
926 AUTO_INSERT_FILTER("-map_channel", "pan", pan_buf.str);
927 av_bprint_finalize(&pan_buf, NULL);
930 if (audio_volume != 256) {
933 snprintf(args, sizeof(args), "%lf", audio_volume / 256.);
934 AUTO_INSERT_FILTER("-vol", "volume", args);
940 static int configure_video_filters(FilterGraph *fg, AVFilterContext **in_filter,
941 AVFilterContext **out_filter)
943 InputStream *ist = fg->inputs[0]->ist;
944 OutputStream *ost = fg->outputs[0]->ost;
945 AVFilterContext *filter;
946 AVCodecContext *codec = ost->st->codec;
947 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
949 AVRational sample_aspect_ratio;
953 if (ist->st->sample_aspect_ratio.num) {
954 sample_aspect_ratio = ist->st->sample_aspect_ratio;
956 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
958 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,
959 ist->st->codec->height, ist->st->codec->pix_fmt,
960 ist->st->time_base.num, ist->st->time_base.den,
961 sample_aspect_ratio.num, sample_aspect_ratio.den,
962 SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
964 ret = avfilter_graph_create_filter(&fg->inputs[0]->filter,
965 avfilter_get_by_name("buffer"),
966 "src", args, NULL, fg->graph);
970 #if FF_API_OLD_VSINK_API
971 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter,
972 avfilter_get_by_name("buffersink"),
973 "out", NULL, NULL, fg->graph);
975 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter,
976 avfilter_get_by_name("buffersink"),
977 "out", NULL, buffersink_params, fg->graph);
979 av_freep(&buffersink_params);
983 *in_filter = fg->inputs[0]->filter;
984 *out_filter = fg->outputs[0]->filter;
986 if (codec->width || codec->height) {
987 snprintf(args, 255, "%d:%d:flags=0x%X",
990 (unsigned)ost->sws_flags);
991 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
992 NULL, args, NULL, fg->graph)) < 0)
994 if ((ret = avfilter_link(*in_filter, 0, filter, 0)) < 0)
999 if ((pix_fmts = choose_pix_fmts(ost))) {
1000 if ((ret = avfilter_graph_create_filter(&filter,
1001 avfilter_get_by_name("format"),
1002 "format", pix_fmts, NULL,
1005 if ((ret = avfilter_link(filter, 0, *out_filter, 0)) < 0)
1008 *out_filter = filter;
1009 av_freep(&pix_fmts);
1012 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
1013 fg->graph->scale_sws_opts = av_strdup(args);
1018 static int configure_simple_filtergraph(FilterGraph *fg)
1020 OutputStream *ost = fg->outputs[0]->ost;
1021 AVFilterContext *in_filter, *out_filter;
1024 avfilter_graph_free(&fg->graph);
1025 fg->graph = avfilter_graph_alloc();
1027 return AVERROR(ENOMEM);
1029 switch (ost->st->codec->codec_type) {
1030 case AVMEDIA_TYPE_VIDEO:
1031 ret = configure_video_filters(fg, &in_filter, &out_filter);
1033 case AVMEDIA_TYPE_AUDIO:
1034 ret = configure_audio_filters(fg, &in_filter, &out_filter);
1036 default: av_assert0(0);
1041 if (ost->avfilter) {
1042 AVFilterInOut *outputs = avfilter_inout_alloc();
1043 AVFilterInOut *inputs = avfilter_inout_alloc();
1045 outputs->name = av_strdup("in");
1046 outputs->filter_ctx = in_filter;
1047 outputs->pad_idx = 0;
1048 outputs->next = NULL;
1050 inputs->name = av_strdup("out");
1051 inputs->filter_ctx = out_filter;
1052 inputs->pad_idx = 0;
1053 inputs->next = NULL;
1055 if ((ret = avfilter_graph_parse(fg->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
1057 av_freep(&ost->avfilter);
1059 if ((ret = avfilter_link(in_filter, 0, out_filter, 0)) < 0)
1063 if (ost->keep_pix_fmt)
1064 avfilter_graph_set_auto_convert(fg->graph,
1065 AVFILTER_AUTO_CONVERT_NONE);
1067 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1070 ost->filter = fg->outputs[0];
1075 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
1077 FilterGraph *fg = av_mallocz(sizeof(*fg));
1081 fg->index = nb_filtergraphs;
1083 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
1084 fg->nb_outputs + 1);
1085 if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
1087 fg->outputs[0]->ost = ost;
1088 fg->outputs[0]->graph = fg;
1090 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
1092 if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
1094 fg->inputs[0]->ist = ist;
1095 fg->inputs[0]->graph = fg;
1097 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
1098 &ist->nb_filters, ist->nb_filters + 1);
1099 ist->filters[ist->nb_filters - 1] = fg->inputs[0];
1101 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1102 &nb_filtergraphs, nb_filtergraphs + 1);
1103 filtergraphs[nb_filtergraphs - 1] = fg;
1108 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
1110 InputStream *ist = NULL;
1111 enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
1114 // TODO: support other filter types
1115 if (type != AVMEDIA_TYPE_VIDEO && type != AVMEDIA_TYPE_AUDIO) {
1116 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters supported "
1123 AVStream *st = NULL;
1125 int file_idx = strtol(in->name, &p, 0);
1127 if (file_idx < 0 || file_idx >= nb_input_files) {
1128 av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n",
1129 file_idx, fg->graph_desc);
1132 s = input_files[file_idx]->ctx;
1134 for (i = 0; i < s->nb_streams; i++) {
1135 if (s->streams[i]->codec->codec_type != type)
1137 if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
1143 av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
1144 "matches no streams.\n", p, fg->graph_desc);
1147 ist = input_streams[input_files[file_idx]->ist_index + st->index];
1149 /* find the first unused stream of corresponding type */
1150 for (i = 0; i < nb_input_streams; i++) {
1151 ist = input_streams[i];
1152 if (ist->st->codec->codec_type == type && ist->discard)
1155 if (i == nb_input_streams) {
1156 av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
1157 "unlabeled input pad %d on filter %s", in->pad_idx,
1158 in->filter_ctx->name);
1163 ist->decoding_needed = 1;
1164 ist->st->discard = AVDISCARD_NONE;
1166 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
1167 &fg->nb_inputs, fg->nb_inputs + 1);
1168 if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
1170 fg->inputs[fg->nb_inputs - 1]->ist = ist;
1171 fg->inputs[fg->nb_inputs - 1]->graph = fg;
1173 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
1174 &ist->nb_filters, ist->nb_filters + 1);
1175 ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
1178 static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
1181 AVCodecContext *codec = ofilter->ost->st->codec;
1182 AVFilterContext *last_filter = out->filter_ctx;
1183 int pad_idx = out->pad_idx;
1185 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
1187 #if FF_API_OLD_VSINK_API
1188 ret = avfilter_graph_create_filter(&ofilter->filter,
1189 avfilter_get_by_name("buffersink"),
1190 "out", NULL, NULL, fg->graph);
1192 ret = avfilter_graph_create_filter(&ofilter->filter,
1193 avfilter_get_by_name("buffersink"),
1194 "out", NULL, buffersink_params, fg->graph);
1196 av_freep(&buffersink_params);
1201 if (codec->width || codec->height) {
1203 AVFilterContext *filter;
1205 snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
1208 (unsigned)ofilter->ost->sws_flags);
1209 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
1210 NULL, args, NULL, fg->graph)) < 0)
1212 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
1215 last_filter = filter;
1219 if ((pix_fmts = choose_pix_fmts(ofilter->ost))) {
1220 AVFilterContext *filter;
1221 if ((ret = avfilter_graph_create_filter(&filter,
1222 avfilter_get_by_name("format"),
1223 "format", pix_fmts, NULL,
1226 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
1229 last_filter = filter;
1231 av_freep(&pix_fmts);
1234 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
1240 static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
1242 OutputStream *ost = ofilter->ost;
1243 AVCodecContext *codec = ost->st->codec;
1244 AVFilterContext *last_filter = out->filter_ctx;
1245 int pad_idx = out->pad_idx;
1246 char *sample_fmts, *sample_rates, *channel_layouts;
1249 ret = avfilter_graph_create_filter(&ofilter->filter,
1250 avfilter_get_by_name("abuffersink"),
1251 "out", NULL, NULL, fg->graph);
1255 if (codec->channels && !codec->channel_layout)
1256 codec->channel_layout = av_get_default_channel_layout(codec->channels);
1258 sample_fmts = choose_sample_fmts(ost);
1259 sample_rates = choose_sample_rates(ost);
1260 channel_layouts = choose_channel_layouts(ost);
1261 if (sample_fmts || sample_rates || channel_layouts) {
1262 AVFilterContext *format;
1267 len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:",
1270 len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:",
1272 if (channel_layouts)
1273 len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:",
1277 av_freep(&sample_fmts);
1278 av_freep(&sample_rates);
1279 av_freep(&channel_layouts);
1281 ret = avfilter_graph_create_filter(&format,
1282 avfilter_get_by_name("aformat"),
1283 "aformat", args, NULL, fg->graph);
1287 ret = avfilter_link(last_filter, pad_idx, format, 0);
1291 last_filter = format;
1295 if (audio_sync_method > 0) {
1296 AVFilterContext *async;
1300 av_log(NULL, AV_LOG_WARNING, "-async has been deprecated. Used the "
1301 "asyncts audio filter instead.\n");
1303 if (audio_sync_method > 1)
1304 len += snprintf(args + len, sizeof(args) - len, "compensate=1:"
1305 "max_comp=%d:", audio_sync_method);
1306 snprintf(args + len, sizeof(args) - len, "min_delta=%f",
1307 audio_drift_threshold);
1309 ret = avfilter_graph_create_filter(&async,
1310 avfilter_get_by_name("asyncts"),
1311 "async", args, NULL, fg->graph);
1315 ret = avfilter_link(last_filter, pad_idx, async, 0);
1319 last_filter = async;
1323 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
1329 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
1331 switch (out->filter_ctx->output_pads[out->pad_idx].type) {
1332 case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, ofilter, out);
1333 case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, ofilter, out);
1334 default: av_assert0(0);
1338 static int configure_complex_filter(FilterGraph *fg)
1340 AVFilterInOut *inputs, *outputs, *cur;
1341 int ret, i, init = !fg->graph;
1343 avfilter_graph_free(&fg->graph);
1344 if (!(fg->graph = avfilter_graph_alloc()))
1345 return AVERROR(ENOMEM);
1347 if ((ret = avfilter_graph_parse2(fg->graph, fg->graph_desc, &inputs, &outputs)) < 0)
1350 for (cur = inputs; init && cur; cur = cur->next)
1351 init_input_filter(fg, cur);
1353 for (cur = inputs, i = 0; cur; cur = cur->next, i++) {
1354 InputFilter *ifilter = fg->inputs[i];
1355 InputStream *ist = ifilter->ist;
1360 switch (cur->filter_ctx->input_pads[cur->pad_idx].type) {
1361 case AVMEDIA_TYPE_VIDEO:
1362 sar = ist->st->sample_aspect_ratio.num ?
1363 ist->st->sample_aspect_ratio :
1364 ist->st->codec->sample_aspect_ratio;
1365 snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
1366 ist->st->codec->height, ist->st->codec->pix_fmt,
1367 ist->st->time_base.num, ist->st->time_base.den,
1369 filter = avfilter_get_by_name("buffer");
1371 case AVMEDIA_TYPE_AUDIO:
1372 snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:"
1373 "sample_fmt=%s:channel_layout=0x%"PRIx64,
1374 ist->st->time_base.num, ist->st->time_base.den,
1375 ist->st->codec->sample_rate,
1376 av_get_sample_fmt_name(ist->st->codec->sample_fmt),
1377 ist->st->codec->channel_layout);
1378 filter = avfilter_get_by_name("abuffer");
1384 if ((ret = avfilter_graph_create_filter(&ifilter->filter,
1386 args, NULL, fg->graph)) < 0)
1388 if ((ret = avfilter_link(ifilter->filter, 0,
1389 cur->filter_ctx, cur->pad_idx)) < 0)
1392 avfilter_inout_free(&inputs);
1395 /* we already know the mappings between lavfi outputs and output streams,
1396 * so we can finish the setup */
1397 for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1398 configure_output_filter(fg, fg->outputs[i], cur);
1399 avfilter_inout_free(&outputs);
1401 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1404 /* wait until output mappings are processed */
1405 for (cur = outputs; cur;) {
1406 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1407 &fg->nb_outputs, fg->nb_outputs + 1);
1408 if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1410 fg->outputs[fg->nb_outputs - 1]->graph = fg;
1411 fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1413 fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1420 static int configure_complex_filters(void)
1424 for (i = 0; i < nb_filtergraphs; i++)
1425 if (!filtergraphs[i]->graph &&
1426 (ret = configure_complex_filter(filtergraphs[i])) < 0)
1431 static int configure_filtergraph(FilterGraph *fg)
1433 return fg->graph_desc ? configure_complex_filter(fg) :
1434 configure_simple_filtergraph(fg);
1437 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1440 for (i = 0; i < fg->nb_inputs; i++)
1441 if (fg->inputs[i]->ist == ist)
1446 static void term_exit(void)
1448 av_log(NULL, AV_LOG_QUIET, "%s", "");
1451 tcsetattr (0, TCSANOW, &oldtty);
1455 static volatile int received_sigterm = 0;
1457 static void sigterm_handler(int sig)
1459 received_sigterm = sig;
1460 received_nb_signals++;
1462 if(received_nb_signals > 3)
1466 static void term_init(void)
1472 if (tcgetattr (0, &tty) == 0) {
1477 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1478 |INLCR|IGNCR|ICRNL|IXON);
1479 tty.c_oflag |= OPOST;
1480 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1481 tty.c_cflag &= ~(CSIZE|PARENB);
1484 tty.c_cc[VTIME] = 0;
1486 tcsetattr (0, TCSANOW, &tty);
1488 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
1491 avformat_network_deinit();
1493 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
1494 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
1496 signal(SIGXCPU, sigterm_handler);
1500 /* read a key without blocking */
1501 static int read_key(void)
1513 n = select(1, &rfds, NULL, NULL, &tv);
1515 n = read(0, &ch, 1);
1522 # if HAVE_PEEKNAMEDPIPE
1524 static HANDLE input_handle;
1527 input_handle = GetStdHandle(STD_INPUT_HANDLE);
1528 is_pipe = !GetConsoleMode(input_handle, &dw);
1531 if (stdin->_cnt > 0) {
1536 /* When running under a GUI, you will end here. */
1537 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
1554 static int decode_interrupt_cb(void *ctx)
1556 return received_nb_signals > 1;
1559 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1561 void av_noreturn exit_program(int ret)
1565 for (i = 0; i < nb_filtergraphs; i++) {
1566 avfilter_graph_free(&filtergraphs[i]->graph);
1567 for (j = 0; j < filtergraphs[i]->nb_inputs; j++)
1568 av_freep(&filtergraphs[i]->inputs[j]);
1569 av_freep(&filtergraphs[i]->inputs);
1570 for (j = 0; j < filtergraphs[i]->nb_outputs; j++)
1571 av_freep(&filtergraphs[i]->outputs[j]);
1572 av_freep(&filtergraphs[i]->outputs);
1573 av_freep(&filtergraphs[i]);
1575 av_freep(&filtergraphs);
1578 for (i = 0; i < nb_output_files; i++) {
1579 AVFormatContext *s = output_files[i]->ctx;
1580 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1582 avformat_free_context(s);
1583 av_dict_free(&output_files[i]->opts);
1584 av_freep(&output_files[i]);
1586 for (i = 0; i < nb_output_streams; i++) {
1587 AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1589 AVBitStreamFilterContext *next = bsfc->next;
1590 av_bitstream_filter_close(bsfc);
1593 output_streams[i]->bitstream_filters = NULL;
1595 av_freep(&output_streams[i]->filtered_frame);
1596 av_freep(&output_streams[i]);
1598 for (i = 0; i < nb_input_files; i++) {
1599 avformat_close_input(&input_files[i]->ctx);
1600 av_freep(&input_files[i]);
1602 for (i = 0; i < nb_input_streams; i++) {
1603 av_freep(&input_streams[i]->decoded_frame);
1604 av_dict_free(&input_streams[i]->opts);
1605 free_buffer_pool(input_streams[i]);
1606 av_freep(&input_streams[i]->filters);
1607 av_freep(&input_streams[i]);
1611 fclose(vstats_file);
1612 av_free(vstats_filename);
1614 av_freep(&input_streams);
1615 av_freep(&input_files);
1616 av_freep(&output_streams);
1617 av_freep(&output_files);
1622 avformat_network_deinit();
1624 if (received_sigterm) {
1625 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1626 (int) received_sigterm);
1633 static void assert_avoptions(AVDictionary *m)
1635 AVDictionaryEntry *t;
1636 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1637 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1642 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1644 const char *codec_string = encoder ? "encoder" : "decoder";
1646 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1647 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1648 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1649 "results.\nAdd '-strict experimental' if you want to use it.\n",
1650 codec_string, c->codec->name);
1651 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1652 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1653 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1654 codec_string, codec->name);
1659 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
1661 if (codec && codec->sample_fmts) {
1662 const enum AVSampleFormat *p = codec->sample_fmts;
1663 for (; *p != -1; p++) {
1664 if (*p == st->codec->sample_fmt)
1668 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
1669 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
1670 if(av_get_sample_fmt_name(st->codec->sample_fmt))
1671 av_log(NULL, AV_LOG_WARNING,
1672 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
1673 av_get_sample_fmt_name(st->codec->sample_fmt),
1675 av_get_sample_fmt_name(codec->sample_fmts[0]));
1676 st->codec->sample_fmt = codec->sample_fmts[0];
1682 get_sync_ipts(const OutputStream *ost, int64_t pts)
1684 OutputFile *of = output_files[ost->file_index];
1685 return (double)(pts - of->start_time) / AV_TIME_BASE;
1688 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1690 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1691 AVCodecContext *avctx = ost->st->codec;
1694 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1695 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1696 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1698 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
1699 int64_t max = ost->st->cur_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
1700 if (ost->st->cur_dts && ost->st->cur_dts != AV_NOPTS_VALUE && max > pkt->dts) {
1701 av_log(s, max - pkt->dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG, "Audio timestamp %"PRId64" < %"PRId64" invalid, cliping\n", pkt->dts, max);
1702 pkt->pts = pkt->dts = max;
1707 * Audio encoders may split the packets -- #frames in != #packets out.
1708 * But there is no reordering, so we can limit the number of output packets
1709 * by simply dropping them here.
1710 * Counting encoded video frames needs to be done separately because of
1711 * reordering, see do_video_out()
1713 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1714 if (ost->frame_number >= ost->max_frames) {
1715 av_free_packet(pkt);
1718 ost->frame_number++;
1722 AVPacket new_pkt = *pkt;
1723 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1724 &new_pkt.data, &new_pkt.size,
1725 pkt->data, pkt->size,
1726 pkt->flags & AV_PKT_FLAG_KEY);
1728 av_free_packet(pkt);
1729 new_pkt.destruct = av_destruct_packet;
1731 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1732 bsfc->filter->name, pkt->stream_index,
1733 avctx->codec ? avctx->codec->name : "copy");
1743 pkt->stream_index = ost->index;
1744 ret = av_interleaved_write_frame(s, pkt);
1746 print_error("av_interleaved_write_frame()", ret);
1751 static int check_recording_time(OutputStream *ost)
1753 OutputFile *of = output_files[ost->file_index];
1755 if (of->recording_time != INT64_MAX &&
1756 av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
1757 AV_TIME_BASE_Q) >= 0) {
1758 ost->is_past_recording_time = 1;
1764 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1767 AVCodecContext *enc = ost->st->codec;
1771 av_init_packet(&pkt);
1775 if (!check_recording_time(ost))
1778 if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
1779 frame->pts = ost->sync_opts;
1780 ost->sync_opts = frame->pts + frame->nb_samples;
1782 av_assert0(pkt.size || !pkt.data);
1783 update_benchmark(NULL);
1784 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1785 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1788 update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
1791 if (pkt.pts != AV_NOPTS_VALUE)
1792 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1793 if (pkt.dts != AV_NOPTS_VALUE)
1794 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1795 if (pkt.duration > 0)
1796 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1799 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1800 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1801 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1802 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1805 write_frame(s, &pkt, ost);
1807 audio_size += pkt.size;
1808 av_free_packet(&pkt);
1812 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1814 AVCodecContext *dec;
1815 AVPicture *picture2;
1816 AVPicture picture_tmp;
1819 dec = ist->st->codec;
1821 /* deinterlace : must be done before any resize */
1822 if (do_deinterlace) {
1825 /* create temporary picture */
1826 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1827 buf = av_malloc(size);
1831 picture2 = &picture_tmp;
1832 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1834 if (avpicture_deinterlace(picture2, picture,
1835 dec->pix_fmt, dec->width, dec->height) < 0) {
1836 /* if error, do not deinterlace */
1837 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1846 if (picture != picture2)
1847 *picture = *picture2;
1851 static void do_subtitle_out(AVFormatContext *s,
1857 static uint8_t *subtitle_out = NULL;
1858 int subtitle_out_max_size = 1024 * 1024;
1859 int subtitle_out_size, nb, i;
1860 AVCodecContext *enc;
1863 if (pts == AV_NOPTS_VALUE) {
1864 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1870 enc = ost->st->codec;
1872 if (!subtitle_out) {
1873 subtitle_out = av_malloc(subtitle_out_max_size);
1876 /* Note: DVB subtitle need one packet to draw them and one other
1877 packet to clear them */
1878 /* XXX: signal it in the codec context ? */
1879 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1884 for (i = 0; i < nb; i++) {
1885 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1887 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1888 // start_display_time is required to be 0
1889 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1890 sub->end_display_time -= sub->start_display_time;
1891 sub->start_display_time = 0;
1892 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1893 subtitle_out_max_size, sub);
1894 if (subtitle_out_size < 0) {
1895 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1899 av_init_packet(&pkt);
1900 pkt.data = subtitle_out;
1901 pkt.size = subtitle_out_size;
1902 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1903 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1904 /* XXX: the pts correction is handled here. Maybe handling
1905 it in the codec would be better */
1907 pkt.pts += 90 * sub->start_display_time;
1909 pkt.pts += 90 * sub->end_display_time;
1911 write_frame(s, &pkt, ost);
1915 static double psnr(double d)
1917 return -10.0 * log(d) / log(10.0);
1920 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1923 AVCodecContext *enc;
1925 double ti1, bitrate, avg_bitrate;
1927 /* this is executed just the first time do_video_stats is called */
1929 vstats_file = fopen(vstats_filename, "w");
1936 enc = ost->st->codec;
1937 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1938 frame_number = ost->frame_number;
1939 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1940 if (enc->flags&CODEC_FLAG_PSNR)
1941 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1943 fprintf(vstats_file,"f_size= %6d ", frame_size);
1944 /* compute pts value */
1945 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1949 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1950 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1951 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1952 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1953 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1958 static void do_video_out(AVFormatContext *s, OutputStream *ost,
1959 AVFrame *in_picture, float quality)
1961 int nb_frames, i, ret, format_video_sync;
1962 AVCodecContext *enc;
1963 double sync_ipts, delta;
1964 double duration = 0;
1966 InputStream *ist = NULL;
1968 if (ost->source_index >= 0)
1969 ist = input_streams[ost->source_index];
1971 enc = ost->st->codec;
1973 if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1974 duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));
1976 sync_ipts = get_sync_ipts(ost, in_picture->pts) / av_q2d(enc->time_base);
1977 delta = sync_ipts - ost->sync_opts + duration;
1979 /* by default, we output a single frame */
1982 format_video_sync = video_sync_method;
1983 if (format_video_sync == VSYNC_AUTO)
1984 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1986 switch (format_video_sync) {
1988 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1991 else if (delta > 1.1)
1992 nb_frames = lrintf(delta);
1997 else if (delta > 0.6)
1998 ost->sync_opts = lrint(sync_ipts);
2001 case VSYNC_PASSTHROUGH:
2002 ost->sync_opts = lrint(sync_ipts);
2008 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
2009 if (nb_frames == 0) {
2011 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
2013 } else if (nb_frames > 1) {
2014 nb_frames_dup += nb_frames - 1;
2015 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
2018 /* duplicates frame if needed */
2019 for (i = 0; i < nb_frames; i++) {
2021 av_init_packet(&pkt);
2025 if (s->oformat->flags & AVFMT_RAWPICTURE &&
2026 enc->codec->id == CODEC_ID_RAWVIDEO) {
2027 /* raw pictures are written as AVPicture structure to
2028 avoid any copies. We support temporarily the older
2030 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
2031 enc->coded_frame->top_field_first = in_picture->top_field_first;
2032 pkt.data = (uint8_t *)in_picture;
2033 pkt.size = sizeof(AVPicture);
2034 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
2035 pkt.flags |= AV_PKT_FLAG_KEY;
2037 write_frame(s, &pkt, ost);
2040 AVFrame big_picture;
2042 big_picture = *in_picture;
2043 /* better than nothing: use input picture interlaced
2045 big_picture.interlaced_frame = in_picture->interlaced_frame;
2046 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
2047 if (ost->top_field_first == -1)
2048 big_picture.top_field_first = in_picture->top_field_first;
2050 big_picture.top_field_first = !!ost->top_field_first;
2053 /* handles same_quant here. This is not correct because it may
2054 not be a global option */
2055 big_picture.quality = quality;
2056 if (!enc->me_threshold)
2057 big_picture.pict_type = 0;
2058 big_picture.pts = ost->sync_opts;
2059 if (ost->forced_kf_index < ost->forced_kf_count &&
2060 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
2061 big_picture.pict_type = AV_PICTURE_TYPE_I;
2062 ost->forced_kf_index++;
2064 update_benchmark(NULL);
2065 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
2066 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
2068 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
2073 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
2074 pkt.pts = ost->sync_opts;
2076 if (pkt.pts != AV_NOPTS_VALUE)
2077 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2078 if (pkt.dts != AV_NOPTS_VALUE)
2079 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2082 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
2083 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
2084 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
2085 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
2088 write_frame(s, &pkt, ost);
2089 frame_size = pkt.size;
2090 video_size += pkt.size;
2091 av_free_packet(&pkt);
2093 /* if two pass, output log */
2094 if (ost->logfile && enc->stats_out) {
2095 fprintf(ost->logfile, "%s", enc->stats_out);
2101 * For video, number of frames in == number of packets out.
2102 * But there may be reordering, so we can't throw away frames on encoder
2103 * flush, we need to limit them here, before they go into encoder.
2105 ost->frame_number++;
2107 if (vstats_filename && frame_size)
2108 do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
2111 /* check for new output on any of the filtergraphs */
2112 static int poll_filters(void)
2114 AVFilterBufferRef *picref;
2115 AVFrame *filtered_frame = NULL;
2116 int i, ret, ret_all;
2117 unsigned nb_success, nb_eof;
2121 /* Reap all buffers present in the buffer sinks */
2122 for (i = 0; i < nb_output_streams; i++) {
2123 OutputStream *ost = output_streams[i];
2124 OutputFile *of = output_files[ost->file_index];
2127 if (!ost->filter || ost->is_past_recording_time)
2130 if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
2131 return AVERROR(ENOMEM);
2133 avcodec_get_frame_defaults(ost->filtered_frame);
2134 filtered_frame = ost->filtered_frame;
2137 AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base;
2138 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2139 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
2140 ret = av_buffersink_read_samples(ost->filter->filter, &picref,
2141 ost->st->codec->frame_size);
2144 ret = av_buffersink_read(ost->filter->filter, &picref);
2146 ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
2147 AV_BUFFERSINK_FLAG_NO_REQUEST);
2150 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
2152 av_strerror(ret, buf, sizeof(buf));
2153 av_log(NULL, AV_LOG_WARNING,
2154 "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
2158 frame_pts = AV_NOPTS_VALUE;
2159 if (ost->enc->type == AVMEDIA_TYPE_VIDEO)
2160 filtered_frame->pts = frame_pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2161 else if (picref->pts != AV_NOPTS_VALUE)
2162 filtered_frame->pts = frame_pts = av_rescale_q(picref->pts,
2163 ost->filter->filter->inputs[0]->time_base,
2164 ost->st->codec->time_base) -
2165 av_rescale_q(of->start_time,
2167 ost->st->codec->time_base);
2168 //if (ost->source_index >= 0)
2169 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
2171 if (of->start_time && filtered_frame->pts < of->start_time) {
2172 avfilter_unref_buffer(picref);
2176 switch (ost->filter->filter->inputs[0]->type) {
2177 case AVMEDIA_TYPE_VIDEO:
2178 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);
2179 filtered_frame->pts = frame_pts;
2180 if (!ost->frame_aspect_ratio)
2181 ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
2183 do_video_out(of->ctx, ost, filtered_frame,
2184 same_quant ? ost->last_quality :
2185 ost->st->codec->global_quality);
2187 case AVMEDIA_TYPE_AUDIO:
2188 avfilter_copy_buf_props(filtered_frame, picref);
2189 filtered_frame->pts = frame_pts;
2190 do_audio_out(of->ctx, ost, filtered_frame);
2193 // TODO support subtitle filters
2197 avfilter_unref_buffer(picref);
2200 /* Request frames through all the graphs */
2201 ret_all = nb_success = nb_eof = 0;
2202 for (i = 0; i < nb_filtergraphs; i++) {
2203 ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
2206 } else if (ret == AVERROR_EOF) {
2208 } else if (ret != AVERROR(EAGAIN)) {
2210 av_strerror(ret, buf, sizeof(buf));
2211 av_log(NULL, AV_LOG_WARNING,
2212 "Error in request_frame(): %s\n", buf);
2218 /* Try again if anything succeeded */
2220 return nb_eof == nb_filtergraphs ? AVERROR_EOF : ret_all;
2223 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
2227 AVFormatContext *oc;
2229 AVCodecContext *enc;
2230 int frame_number, vid, i;
2232 int64_t pts = INT64_MAX;
2233 static int64_t last_time = -1;
2234 static int qp_histogram[52];
2235 int hours, mins, secs, us;
2237 if (!print_stats && !is_last_report)
2240 if (!is_last_report) {
2241 if (last_time == -1) {
2242 last_time = cur_time;
2245 if ((cur_time - last_time) < 500000)
2247 last_time = cur_time;
2251 oc = output_files[0]->ctx;
2253 total_size = avio_size(oc->pb);
2254 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
2255 total_size = avio_tell(oc->pb);
2262 for (i = 0; i < nb_output_streams; i++) {
2264 ost = output_streams[i];
2265 enc = ost->st->codec;
2266 if (!ost->stream_copy && enc->coded_frame)
2267 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
2268 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2269 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
2271 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2272 float fps, t = (cur_time-timer_start) / 1000000.0;
2274 frame_number = ost->frame_number;
2275 fps = t > 1 ? frame_number / t : 0;
2276 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
2277 frame_number, fps < 9.95, fps, q);
2279 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
2283 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
2285 for (j = 0; j < 32; j++)
2286 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
2288 if (enc->flags&CODEC_FLAG_PSNR) {
2290 double error, error_sum = 0;
2291 double scale, scale_sum = 0;
2292 char type[3] = { 'Y','U','V' };
2293 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
2294 for (j = 0; j < 3; j++) {
2295 if (is_last_report) {
2296 error = enc->error[j];
2297 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
2299 error = enc->coded_frame->error[j];
2300 scale = enc->width * enc->height * 255.0 * 255.0;
2306 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
2308 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
2312 /* compute min output value */
2313 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
2314 ost->st->time_base, AV_TIME_BASE_Q));
2317 secs = pts / AV_TIME_BASE;
2318 us = pts % AV_TIME_BASE;
2324 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
2326 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2327 "size=%8.0fkB time=", total_size / 1024.0);
2328 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2329 "%02d:%02d:%02d.%02d ", hours, mins, secs,
2330 (100 * us) / AV_TIME_BASE);
2331 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2332 "bitrate=%6.1fkbits/s", bitrate);
2334 if (nb_frames_dup || nb_frames_drop)
2335 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
2336 nb_frames_dup, nb_frames_drop);
2338 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
2342 if (is_last_report) {
2343 int64_t raw= audio_size + video_size + extra_size;
2344 av_log(NULL, AV_LOG_INFO, "\n");
2345 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
2346 video_size / 1024.0,
2347 audio_size / 1024.0,
2348 extra_size / 1024.0,
2349 100.0 * (total_size - raw) / raw
2351 if(video_size + audio_size + extra_size == 0){
2352 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
2357 static void flush_encoders(void)
2361 for (i = 0; i < nb_output_streams; i++) {
2362 OutputStream *ost = output_streams[i];
2363 AVCodecContext *enc = ost->st->codec;
2364 AVFormatContext *os = output_files[ost->file_index]->ctx;
2365 int stop_encoding = 0;
2367 if (!ost->encoding_needed)
2370 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
2372 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
2376 int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
2380 switch (ost->st->codec->codec_type) {
2381 case AVMEDIA_TYPE_AUDIO:
2382 encode = avcodec_encode_audio2;
2386 case AVMEDIA_TYPE_VIDEO:
2387 encode = avcodec_encode_video2;
2398 av_init_packet(&pkt);
2402 update_benchmark(NULL);
2403 ret = encode(enc, &pkt, NULL, &got_packet);
2404 update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index);
2406 av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
2410 if (ost->logfile && enc->stats_out) {
2411 fprintf(ost->logfile, "%s", enc->stats_out);
2417 if (pkt.pts != AV_NOPTS_VALUE)
2418 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2419 if (pkt.dts != AV_NOPTS_VALUE)
2420 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2421 write_frame(os, &pkt, ost);
2431 * Check whether a packet from ist should be written into ost at this time
2433 static int check_output_constraints(InputStream *ist, OutputStream *ost)
2435 OutputFile *of = output_files[ost->file_index];
2436 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
2438 if (ost->source_index != ist_index)
2441 if (of->start_time && ist->pts < of->start_time)
2444 if (of->recording_time != INT64_MAX &&
2445 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
2446 (AVRational){ 1, 1000000 }) >= 0) {
2447 ost->is_past_recording_time = 1;
2454 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2456 OutputFile *of = output_files[ost->file_index];
2457 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
2461 av_init_packet(&opkt);
2463 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2464 !ost->copy_initial_nonkeyframes)
2467 /* force the input stream PTS */
2468 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2469 audio_size += pkt->size;
2470 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2471 video_size += pkt->size;
2475 if (pkt->pts != AV_NOPTS_VALUE)
2476 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
2478 opkt.pts = AV_NOPTS_VALUE;
2480 if (pkt->dts == AV_NOPTS_VALUE)
2481 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
2483 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
2484 opkt.dts -= ost_tb_start_time;
2486 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
2487 opkt.flags = pkt->flags;
2489 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2490 if ( ost->st->codec->codec_id != CODEC_ID_H264
2491 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
2492 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
2493 && ost->st->codec->codec_id != CODEC_ID_VC1
2495 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
2496 opkt.destruct = av_destruct_packet;
2498 opkt.data = pkt->data;
2499 opkt.size = pkt->size;
2501 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2502 /* store AVPicture in AVPacket, as expected by the output format */
2503 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2504 opkt.data = (uint8_t *)&pict;
2505 opkt.size = sizeof(AVPicture);
2506 opkt.flags |= AV_PKT_FLAG_KEY;
2509 write_frame(of->ctx, &opkt, ost);
2510 ost->st->codec->frame_number++;
2511 av_free_packet(&opkt);
2514 static void rate_emu_sleep(InputStream *ist)
2516 if (input_files[ist->file_index]->rate_emu) {
2517 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2518 int64_t now = av_gettime() - ist->start;
2524 static int guess_input_channel_layout(InputStream *ist)
2526 AVCodecContext *dec = ist->st->codec;
2528 if (!dec->channel_layout) {
2529 char layout_name[256];
2531 dec->channel_layout = av_get_default_channel_layout(dec->channels);
2532 if (!dec->channel_layout)
2534 av_get_channel_layout_string(layout_name, sizeof(layout_name),
2535 dec->channels, dec->channel_layout);
2536 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2537 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2542 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2544 AVFrame *decoded_frame;
2545 AVCodecContext *avctx = ist->st->codec;
2546 int i, ret, resample_changed;
2548 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2549 return AVERROR(ENOMEM);
2551 avcodec_get_frame_defaults(ist->decoded_frame);
2552 decoded_frame = ist->decoded_frame;
2554 update_benchmark(NULL);
2555 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2556 update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2560 if (avctx->sample_rate <= 0) {
2561 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2562 return AVERROR_INVALIDDATA;
2566 /* no audio frame */
2568 for (i = 0; i < ist->nb_filters; i++)
2569 av_buffersrc_add_ref(ist->filters[i]->filter, NULL,
2570 AV_BUFFERSRC_FLAG_NO_COPY);
2574 /* if the decoder provides a pts, use it instead of the last packet pts.
2575 the decoder could be delaying output by a packet or more. */
2576 if (decoded_frame->pts != AV_NOPTS_VALUE)
2577 ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2578 else if (pkt->pts != AV_NOPTS_VALUE) {
2579 decoded_frame->pts = pkt->pts;
2580 pkt->pts = AV_NOPTS_VALUE;
2582 decoded_frame->pts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2586 /* increment next_dts to use for the case where the input stream does not
2587 have timestamps or there are multiple frames in the packet */
2588 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2590 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2594 rate_emu_sleep(ist);
2596 resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
2597 ist->resample_channels != avctx->channels ||
2598 ist->resample_channel_layout != decoded_frame->channel_layout ||
2599 ist->resample_sample_rate != decoded_frame->sample_rate;
2600 if (resample_changed) {
2601 char layout1[64], layout2[64];
2603 if (!guess_input_channel_layout(ist)) {
2604 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
2605 "layout for Input Stream #%d.%d\n", ist->file_index,
2609 decoded_frame->channel_layout = avctx->channel_layout;
2611 av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
2612 ist->resample_channel_layout);
2613 av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
2614 decoded_frame->channel_layout);
2616 av_log(NULL, AV_LOG_INFO,
2617 "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n",
2618 ist->file_index, ist->st->index,
2619 ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt),
2620 ist->resample_channels, layout1,
2621 decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2622 avctx->channels, layout2);
2624 ist->resample_sample_fmt = decoded_frame->format;
2625 ist->resample_sample_rate = decoded_frame->sample_rate;
2626 ist->resample_channel_layout = decoded_frame->channel_layout;
2627 ist->resample_channels = avctx->channels;
2629 for (i = 0; i < nb_filtergraphs; i++)
2630 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2631 configure_filtergraph(filtergraphs[i]) < 0) {
2632 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2637 for (i = 0; i < ist->nb_filters; i++)
2638 av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0);
2643 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2645 AVFrame *decoded_frame;
2646 void *buffer_to_free = NULL;
2647 int i, ret = 0, resample_changed;
2648 int64_t best_effort_timestamp;
2649 AVRational *frame_sample_aspect;
2652 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2653 return AVERROR(ENOMEM);
2655 avcodec_get_frame_defaults(ist->decoded_frame);
2656 decoded_frame = ist->decoded_frame;
2657 pkt->dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2659 update_benchmark(NULL);
2660 ret = avcodec_decode_video2(ist->st->codec,
2661 decoded_frame, got_output, pkt);
2662 update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2666 quality = same_quant ? decoded_frame->quality : 0;
2668 /* no picture yet */
2670 for (i = 0; i < ist->nb_filters; i++)
2671 av_buffersrc_add_ref(ist->filters[i]->filter, NULL, AV_BUFFERSRC_FLAG_NO_COPY);
2675 best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2676 if(best_effort_timestamp != AV_NOPTS_VALUE)
2677 ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2680 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2682 rate_emu_sleep(ist);
2684 if (ist->st->sample_aspect_ratio.num)
2685 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2687 resample_changed = ist->resample_width != decoded_frame->width ||
2688 ist->resample_height != decoded_frame->height ||
2689 ist->resample_pix_fmt != decoded_frame->format;
2690 if (resample_changed) {
2691 av_log(NULL, AV_LOG_INFO,
2692 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2693 ist->file_index, ist->st->index,
2694 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2695 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2697 ist->resample_width = decoded_frame->width;
2698 ist->resample_height = decoded_frame->height;
2699 ist->resample_pix_fmt = decoded_frame->format;
2701 for (i = 0; i < nb_filtergraphs; i++)
2702 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2703 configure_filtergraph(filtergraphs[i]) < 0) {
2704 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2709 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2710 for (i = 0; i < ist->nb_filters; i++) {
2711 int changed = ist->st->codec->width != ist->filters[i]->filter->outputs[0]->w
2712 || ist->st->codec->height != ist->filters[i]->filter->outputs[0]->h
2713 || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2714 // XXX what an ugly hack
2715 if (ist->filters[i]->graph->nb_outputs == 1)
2716 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2718 if (!frame_sample_aspect->num)
2719 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2720 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2721 FrameBuffer *buf = decoded_frame->opaque;
2722 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2723 decoded_frame->data, decoded_frame->linesize,
2724 AV_PERM_READ | AV_PERM_PRESERVE,
2725 ist->st->codec->width, ist->st->codec->height,
2726 ist->st->codec->pix_fmt);
2728 avfilter_copy_frame_props(fb, decoded_frame);
2729 fb->buf->priv = buf;
2730 fb->buf->free = filter_release_buffer;
2732 av_assert0(buf->refcount>0);
2734 av_buffersrc_add_ref(ist->filters[i]->filter, fb,
2735 AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
2736 AV_BUFFERSRC_FLAG_NO_COPY);
2738 if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0)<0) {
2739 av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2745 av_free(buffer_to_free);
2749 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2751 AVSubtitle subtitle;
2752 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2753 &subtitle, got_output, pkt);
2759 rate_emu_sleep(ist);
2761 for (i = 0; i < nb_output_streams; i++) {
2762 OutputStream *ost = output_streams[i];
2764 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2767 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2770 avsubtitle_free(&subtitle);
2774 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2775 static int output_packet(InputStream *ist, const AVPacket *pkt)
2781 if (!ist->saw_first_ts) {
2782 ist->dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
2784 if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2785 ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2786 ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2788 ist->saw_first_ts = 1;
2791 if (ist->next_dts == AV_NOPTS_VALUE)
2792 ist->next_dts = ist->dts;
2793 if (ist->next_pts == AV_NOPTS_VALUE)
2794 ist->next_pts = ist->pts;
2798 av_init_packet(&avpkt);
2806 if (pkt->dts != AV_NOPTS_VALUE) {
2807 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2808 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2809 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2812 // while we have more to decode or while the decoder did output something on EOF
2813 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2817 ist->pts = ist->next_pts;
2818 ist->dts = ist->next_dts;
2820 if (avpkt.size && avpkt.size != pkt->size) {
2821 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2822 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2823 ist->showed_multi_packet_warning = 1;
2826 switch (ist->st->codec->codec_type) {
2827 case AVMEDIA_TYPE_AUDIO:
2828 ret = transcode_audio (ist, &avpkt, &got_output);
2830 case AVMEDIA_TYPE_VIDEO:
2831 ret = transcode_video (ist, &avpkt, &got_output);
2832 if (avpkt.duration) {
2833 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2834 } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2835 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2836 duration = ((int64_t)AV_TIME_BASE *
2837 ist->st->codec->time_base.num * ticks) /
2838 ist->st->codec->time_base.den;
2842 if(ist->dts != AV_NOPTS_VALUE && duration) {
2843 ist->next_dts += duration;
2845 ist->next_dts = AV_NOPTS_VALUE;
2848 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2850 case AVMEDIA_TYPE_SUBTITLE:
2851 ret = transcode_subtitles(ist, &avpkt, &got_output);
2861 avpkt.pts= AV_NOPTS_VALUE;
2863 // touch data and size only if not EOF
2865 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2875 /* handle stream copy */
2876 if (!ist->decoding_needed) {
2877 rate_emu_sleep(ist);
2878 ist->dts = ist->next_dts;
2879 switch (ist->st->codec->codec_type) {
2880 case AVMEDIA_TYPE_AUDIO:
2881 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2882 ist->st->codec->sample_rate;
2884 case AVMEDIA_TYPE_VIDEO:
2885 if (pkt->duration) {
2886 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2887 } else if(ist->st->codec->time_base.num != 0) {
2888 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2889 ist->next_dts += ((int64_t)AV_TIME_BASE *
2890 ist->st->codec->time_base.num * ticks) /
2891 ist->st->codec->time_base.den;
2895 ist->pts = ist->dts;
2896 ist->next_pts = ist->next_dts;
2898 for (i = 0; pkt && i < nb_output_streams; i++) {
2899 OutputStream *ost = output_streams[i];
2901 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2904 do_streamcopy(ist, ost, pkt);
2910 static void print_sdp(void)
2914 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2918 for (i = 0; i < nb_output_files; i++)
2919 avc[i] = output_files[i]->ctx;
2921 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2922 printf("SDP:\n%s\n", sdp);
2927 static int init_input_stream(int ist_index, char *error, int error_len)
2929 InputStream *ist = input_streams[ist_index];
2931 if (ist->decoding_needed) {
2932 AVCodec *codec = ist->dec;
2934 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2935 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2936 return AVERROR(EINVAL);
2939 ist->dr1 = (codec->capabilities & CODEC_CAP_DR1) && !do_deinterlace;
2940 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2941 ist->st->codec->get_buffer = codec_get_buffer;
2942 ist->st->codec->release_buffer = codec_release_buffer;
2943 ist->st->codec->opaque = ist;
2946 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2947 av_dict_set(&ist->opts, "threads", "auto", 0);
2948 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2949 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2950 ist->file_index, ist->st->index);
2951 return AVERROR(EINVAL);
2953 assert_codec_experimental(ist->st->codec, 0);
2954 assert_avoptions(ist->opts);
2957 ist->next_pts = AV_NOPTS_VALUE;
2958 ist->next_dts = AV_NOPTS_VALUE;
2964 static InputStream *get_input_stream(OutputStream *ost)
2966 if (ost->source_index >= 0)
2967 return input_streams[ost->source_index];
2970 FilterGraph *fg = ost->filter->graph;
2973 for (i = 0; i < fg->nb_inputs; i++)
2974 if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2975 return fg->inputs[i]->ist;
2981 static int transcode_init(void)
2983 int ret = 0, i, j, k;
2984 AVFormatContext *oc;
2985 AVCodecContext *codec, *icodec;
2991 /* init framerate emulation */
2992 for (i = 0; i < nb_input_files; i++) {
2993 InputFile *ifile = input_files[i];
2994 if (ifile->rate_emu)
2995 for (j = 0; j < ifile->nb_streams; j++)
2996 input_streams[j + ifile->ist_index]->start = av_gettime();
2999 /* output stream init */
3000 for (i = 0; i < nb_output_files; i++) {
3001 oc = output_files[i]->ctx;
3002 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
3003 av_dump_format(oc, i, oc->filename, 1);
3004 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
3005 return AVERROR(EINVAL);
3009 /* init complex filtergraphs */
3010 for (i = 0; i < nb_filtergraphs; i++)
3011 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
3014 /* for each output stream, we compute the right encoding parameters */
3015 for (i = 0; i < nb_output_streams; i++) {
3016 ost = output_streams[i];
3017 oc = output_files[ost->file_index]->ctx;
3018 ist = get_input_stream(ost);
3020 if (ost->attachment_filename)
3023 codec = ost->st->codec;
3026 icodec = ist->st->codec;
3028 ost->st->disposition = ist->st->disposition;
3029 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
3030 codec->chroma_sample_location = icodec->chroma_sample_location;
3033 if (ost->stream_copy) {
3034 uint64_t extra_size;
3036 av_assert0(ist && !ost->filter);
3038 extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
3040 if (extra_size > INT_MAX) {
3041 return AVERROR(EINVAL);
3044 /* if stream_copy is selected, no need to decode or encode */
3045 codec->codec_id = icodec->codec_id;
3046 codec->codec_type = icodec->codec_type;
3048 if (!codec->codec_tag) {
3049 if (!oc->oformat->codec_tag ||
3050 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
3051 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
3052 codec->codec_tag = icodec->codec_tag;
3055 codec->bit_rate = icodec->bit_rate;
3056 codec->rc_max_rate = icodec->rc_max_rate;
3057 codec->rc_buffer_size = icodec->rc_buffer_size;
3058 codec->field_order = icodec->field_order;
3059 codec->extradata = av_mallocz(extra_size);
3060 if (!codec->extradata) {
3061 return AVERROR(ENOMEM);
3063 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
3064 codec->extradata_size= icodec->extradata_size;
3065 codec->bits_per_coded_sample = icodec->bits_per_coded_sample;
3067 codec->time_base = ist->st->time_base;
3069 * Avi is a special case here because it supports variable fps but
3070 * having the fps and timebase differe significantly adds quite some
3073 if(!strcmp(oc->oformat->name, "avi")) {
3074 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
3075 && av_q2d(ist->st->time_base) < 1.0/500
3077 codec->time_base = icodec->time_base;
3078 codec->time_base.num *= icodec->ticks_per_frame;
3079 codec->time_base.den *= 2;
3080 codec->ticks_per_frame = 2;
3082 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
3083 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
3084 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
3086 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
3087 && av_q2d(ist->st->time_base) < 1.0/500
3089 codec->time_base = icodec->time_base;
3090 codec->time_base.num *= icodec->ticks_per_frame;
3093 av_reduce(&codec->time_base.num, &codec->time_base.den,
3094 codec->time_base.num, codec->time_base.den, INT_MAX);
3096 switch (codec->codec_type) {
3097 case AVMEDIA_TYPE_AUDIO:
3098 if (audio_volume != 256) {
3099 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3102 codec->channel_layout = icodec->channel_layout;
3103 codec->sample_rate = icodec->sample_rate;
3104 codec->channels = icodec->channels;
3105 codec->frame_size = icodec->frame_size;
3106 codec->audio_service_type = icodec->audio_service_type;
3107 codec->block_align = icodec->block_align;
3108 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
3109 codec->block_align= 0;
3110 if(codec->codec_id == CODEC_ID_AC3)
3111 codec->block_align= 0;
3113 case AVMEDIA_TYPE_VIDEO:
3114 codec->pix_fmt = icodec->pix_fmt;
3115 codec->width = icodec->width;
3116 codec->height = icodec->height;
3117 codec->has_b_frames = icodec->has_b_frames;
3118 if (!codec->sample_aspect_ratio.num) {
3119 codec->sample_aspect_ratio =
3120 ost->st->sample_aspect_ratio =
3121 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
3122 ist->st->codec->sample_aspect_ratio.num ?
3123 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
3125 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3127 case AVMEDIA_TYPE_SUBTITLE:
3128 codec->width = icodec->width;
3129 codec->height = icodec->height;
3131 case AVMEDIA_TYPE_DATA:
3132 case AVMEDIA_TYPE_ATTACHMENT:
3139 ost->enc = avcodec_find_encoder(codec->codec_id);
3141 /* should only happen when a default codec is not present. */
3142 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3143 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3144 ret = AVERROR(EINVAL);
3149 ist->decoding_needed = 1;
3150 ost->encoding_needed = 1;
3153 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3154 codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
3156 fg = init_simple_filtergraph(ist, ost);
3157 if (configure_simple_filtergraph(fg)) {
3158 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3163 switch (codec->codec_type) {
3164 case AVMEDIA_TYPE_AUDIO:
3165 codec->sample_fmt = ost->filter->filter->inputs[0]->format;
3166 codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
3167 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3168 codec->channels = av_get_channel_layout_nb_channels(codec->channel_layout);
3169 codec->time_base = (AVRational){ 1, codec->sample_rate };
3171 case AVMEDIA_TYPE_VIDEO:
3172 if (ist && !ost->frame_rate.num)
3173 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
3174 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3175 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3176 ost->frame_rate = ost->enc->supported_framerates[idx];
3178 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3179 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3180 && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3181 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3182 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3184 for (j = 0; j < ost->forced_kf_count; j++)
3185 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3189 codec->width = ost->filter->filter->inputs[0]->w;
3190 codec->height = ost->filter->filter->inputs[0]->h;
3191 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3192 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3193 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3194 ost->filter->filter->inputs[0]->sample_aspect_ratio;
3195 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3197 if (codec->width != icodec->width ||
3198 codec->height != icodec->height ||
3199 codec->pix_fmt != icodec->pix_fmt) {
3200 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3204 case AVMEDIA_TYPE_SUBTITLE:
3205 codec->time_base = (AVRational){1, 1000};
3212 if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3213 char logfilename[1024];
3216 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3217 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3219 if (!strcmp(ost->enc->name, "libx264")) {
3220 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3222 if (codec->flags & CODEC_FLAG_PASS2) {
3224 size_t logbuffer_size;
3225 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3226 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3230 codec->stats_in = logbuffer;
3232 if (codec->flags & CODEC_FLAG_PASS1) {
3233 f = fopen(logfilename, "wb");
3235 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3236 logfilename, strerror(errno));
3246 /* open each encoder */
3247 for (i = 0; i < nb_output_streams; i++) {
3248 ost = output_streams[i];
3249 if (ost->encoding_needed) {
3250 AVCodec *codec = ost->enc;
3251 AVCodecContext *dec = NULL;
3253 if ((ist = get_input_stream(ost)))
3254 dec = ist->st->codec;
3255 if (dec && dec->subtitle_header) {
3256 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3257 if (!ost->st->codec->subtitle_header) {
3258 ret = AVERROR(ENOMEM);
3261 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3262 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3264 if (!av_dict_get(ost->opts, "threads", NULL, 0))
3265 av_dict_set(&ost->opts, "threads", "auto", 0);
3266 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3267 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3268 ost->file_index, ost->index);
3269 ret = AVERROR(EINVAL);
3272 assert_codec_experimental(ost->st->codec, 1);
3273 assert_avoptions(ost->opts);
3274 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3275 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3276 " It takes bits/s as argument, not kbits/s\n");
3277 extra_size += ost->st->codec->extradata_size;
3279 if (ost->st->codec->me_threshold)
3280 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3284 /* init input streams */
3285 for (i = 0; i < nb_input_streams; i++)
3286 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3289 /* discard unused programs */
3290 for (i = 0; i < nb_input_files; i++) {
3291 InputFile *ifile = input_files[i];
3292 for (j = 0; j < ifile->ctx->nb_programs; j++) {
3293 AVProgram *p = ifile->ctx->programs[j];
3294 int discard = AVDISCARD_ALL;
3296 for (k = 0; k < p->nb_stream_indexes; k++)
3297 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3298 discard = AVDISCARD_DEFAULT;
3301 p->discard = discard;
3305 /* open files and write file headers */
3306 for (i = 0; i < nb_output_files; i++) {
3307 oc = output_files[i]->ctx;
3308 oc->interrupt_callback = int_cb;
3309 if (avformat_write_header(oc, &output_files[i]->opts) < 0) {
3310 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
3311 ret = AVERROR(EINVAL);
3314 // assert_avoptions(output_files[i]->opts);
3315 if (strcmp(oc->oformat->name, "rtp")) {
3321 /* dump the file output parameters - cannot be done before in case
3323 for (i = 0; i < nb_output_files; i++) {
3324 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3327 /* dump the stream mapping */
3328 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3329 for (i = 0; i < nb_input_streams; i++) {
3330 ist = input_streams[i];
3332 for (j = 0; j < ist->nb_filters; j++) {
3333 AVFilterLink *link = ist->filters[j]->filter->outputs[0];
3334 if (ist->filters[j]->graph->graph_desc) {
3335 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
3336 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3337 link->dst->filter->name);
3338 if (link->dst->input_count > 1)
3339 av_log(NULL, AV_LOG_INFO, ":%s", link->dstpad->name);
3340 if (nb_filtergraphs > 1)
3341 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3342 av_log(NULL, AV_LOG_INFO, "\n");
3347 for (i = 0; i < nb_output_streams; i++) {
3348 ost = output_streams[i];
3350 if (ost->attachment_filename) {
3351 /* an attached file */
3352 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
3353 ost->attachment_filename, ost->file_index, ost->index);
3357 if (ost->filter && ost->filter->graph->graph_desc) {
3358 /* output from a complex graph */
3359 AVFilterLink *link = ost->filter->filter->inputs[0];
3360 av_log(NULL, AV_LOG_INFO, " %s", link->src->filter->name);
3361 if (link->src->output_count > 1)
3362 av_log(NULL, AV_LOG_INFO, ":%s", link->srcpad->name);
3363 if (nb_filtergraphs > 1)
3364 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3366 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3367 ost->index, ost->enc ? ost->enc->name : "?");
3371 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
3372 input_streams[ost->source_index]->file_index,
3373 input_streams[ost->source_index]->st->index,
3376 if (ost->sync_ist != input_streams[ost->source_index])
3377 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3378 ost->sync_ist->file_index,
3379 ost->sync_ist->st->index);
3380 if (ost->stream_copy)
3381 av_log(NULL, AV_LOG_INFO, " (copy)");
3383 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3384 input_streams[ost->source_index]->dec->name : "?",
3385 ost->enc ? ost->enc->name : "?");
3386 av_log(NULL, AV_LOG_INFO, "\n");
3390 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3402 * The following code is the main loop of the file converter
3404 static int transcode(void)
3407 AVFormatContext *is, *os;
3411 int no_packet_count = 0;
3412 int64_t timer_start;
3415 if (!(no_packet = av_mallocz(nb_input_files)))
3418 ret = transcode_init();
3423 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3426 timer_start = av_gettime();
3428 for (; received_sigterm == 0;) {
3429 int file_index, ist_index, past_recording_time = 1;
3432 int64_t cur_time= av_gettime();
3434 ipts_min = INT64_MAX;
3435 /* if 'q' pressed, exits */
3437 static int64_t last_time;
3438 if (received_nb_signals)
3440 /* read_key() returns 0 on EOF */
3441 if(cur_time - last_time >= 100000 && !run_as_daemon){
3443 last_time = cur_time;
3448 if (key == '+') av_log_set_level(av_log_get_level()+10);
3449 if (key == '-') av_log_set_level(av_log_get_level()-10);
3450 if (key == 's') qp_hist ^= 1;
3453 do_hex_dump = do_pkt_dump = 0;
3454 } else if(do_pkt_dump){
3458 av_log_set_level(AV_LOG_DEBUG);
3460 if (key == 'c' || key == 'C'){
3461 char buf[4096], target[64], command[256], arg[256] = {0};
3464 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3466 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3471 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3472 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3473 target, time, command, arg);
3474 for (i = 0; i < nb_filtergraphs; i++) {
3475 FilterGraph *fg = filtergraphs[i];
3478 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3479 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3480 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3482 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3487 av_log(NULL, AV_LOG_ERROR,
3488 "Parse error, at least 3 arguments were expected, "
3489 "only %d given in string '%s'\n", n, buf);
3492 if (key == 'd' || key == 'D'){
3495 debug = input_streams[0]->st->codec->debug<<1;
3496 if(!debug) debug = 1;
3497 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3500 if(scanf("%d", &debug)!=1)
3501 fprintf(stderr,"error parsing debug value\n");
3502 for(i=0;i<nb_input_streams;i++) {
3503 input_streams[i]->st->codec->debug = debug;
3505 for(i=0;i<nb_output_streams;i++) {
3506 ost = output_streams[i];
3507 ost->st->codec->debug = debug;
3509 if(debug) av_log_set_level(AV_LOG_DEBUG);
3510 fprintf(stderr,"debug=%d\n", debug);
3513 fprintf(stderr, "key function\n"
3514 "? show this help\n"
3515 "+ increase verbosity\n"
3516 "- decrease verbosity\n"
3517 "c Send command to filtergraph\n"
3518 "D cycle through available debug modes\n"
3519 "h dump packets/hex press to cycle through the 3 states\n"
3521 "s Show QP histogram\n"
3526 /* check if there's any stream where output is still needed */
3527 for (i = 0; i < nb_output_streams; i++) {
3529 ost = output_streams[i];
3530 of = output_files[ost->file_index];
3531 os = output_files[ost->file_index]->ctx;
3532 if (ost->is_past_recording_time ||
3533 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3535 if (ost->frame_number >= ost->max_frames) {
3537 for (j = 0; j < of->ctx->nb_streams; j++)
3538 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3541 past_recording_time = 0;
3543 if (past_recording_time)
3546 /* select the stream that we must read now by looking at the
3547 smallest output pts */
3549 for (i = 0; i < nb_input_streams; i++) {
3551 ist = input_streams[i];
3553 if (ist->discard || no_packet[ist->file_index])
3555 if (!input_files[ist->file_index]->eof_reached) {
3556 if (ipts < ipts_min) {
3558 file_index = ist->file_index;
3562 /* if none, if is finished */
3563 if (file_index < 0) {
3564 if (no_packet_count) {
3565 no_packet_count = 0;
3566 memset(no_packet, 0, nb_input_files);
3573 /* read a frame from it and output it in the fifo */
3574 is = input_files[file_index]->ctx;
3575 ret = av_read_frame(is, &pkt);
3576 if (ret == AVERROR(EAGAIN)) {
3577 no_packet[file_index] = 1;
3582 input_files[file_index]->eof_reached = 1;
3584 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3585 ist = input_streams[input_files[file_index]->ist_index + i];
3586 if (ist->decoding_needed)
3587 output_packet(ist, NULL);
3596 no_packet_count = 0;
3597 memset(no_packet, 0, nb_input_files);
3600 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3601 is->streams[pkt.stream_index]);
3603 /* the following test is needed in case new streams appear
3604 dynamically in stream : we ignore them */
3605 if (pkt.stream_index >= input_files[file_index]->nb_streams)
3606 goto discard_packet;
3607 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3608 ist = input_streams[ist_index];
3610 goto discard_packet;
3612 if (pkt.dts != AV_NOPTS_VALUE)
3613 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3614 if (pkt.pts != AV_NOPTS_VALUE)
3615 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3617 if (pkt.pts != AV_NOPTS_VALUE)
3618 pkt.pts *= ist->ts_scale;
3619 if (pkt.dts != AV_NOPTS_VALUE)
3620 pkt.dts *= ist->ts_scale;
3623 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3624 "next_dts:%s next_dts_time:%s next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%"PRId64"\n",
3625 ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3626 av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &ist->st->time_base),
3627 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3628 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3629 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3630 input_files[ist->file_index]->ts_offset);
3633 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3634 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3635 int64_t delta = pkt_dts - ist->next_dts;
3636 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3637 if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3638 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3639 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3640 pkt_dts+1<ist->pts){
3641 input_files[ist->file_index]->ts_offset -= delta;
3642 av_log(NULL, AV_LOG_DEBUG,
3643 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3644 delta, input_files[ist->file_index]->ts_offset);
3645 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3646 if (pkt.pts != AV_NOPTS_VALUE)
3647 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3650 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3651 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3652 pkt_dts+1<ist->pts){
3653 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3654 pkt.dts = AV_NOPTS_VALUE;
3656 if (pkt.pts != AV_NOPTS_VALUE){
3657 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3658 delta = pkt_pts - ist->next_dts;
3659 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3660 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3661 pkt_pts+1<ist->pts) {
3662 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3663 pkt.pts = AV_NOPTS_VALUE;
3669 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3670 if (output_packet(ist, &pkt) < 0 ||
3671 ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3672 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3673 ist->file_index, ist->st->index);
3676 av_free_packet(&pkt);
3681 av_free_packet(&pkt);
3683 /* dump report by using the output first video and audio streams */
3684 print_report(0, timer_start, cur_time);
3687 /* at the end of stream, we must flush the decoder buffers */
3688 for (i = 0; i < nb_input_streams; i++) {
3689 ist = input_streams[i];
3690 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3691 output_packet(ist, NULL);
3699 /* write the trailer if needed and close file */
3700 for (i = 0; i < nb_output_files; i++) {
3701 os = output_files[i]->ctx;
3702 av_write_trailer(os);
3705 /* dump report by using the first video and audio streams */
3706 print_report(1, timer_start, av_gettime());
3708 /* close each encoder */
3709 for (i = 0; i < nb_output_streams; i++) {
3710 ost = output_streams[i];
3711 if (ost->encoding_needed) {
3712 av_freep(&ost->st->codec->stats_in);
3713 avcodec_close(ost->st->codec);
3717 /* close each decoder */
3718 for (i = 0; i < nb_input_streams; i++) {
3719 ist = input_streams[i];
3720 if (ist->decoding_needed) {
3721 avcodec_close(ist->st->codec);
3729 av_freep(&no_packet);
3731 if (output_streams) {
3732 for (i = 0; i < nb_output_streams; i++) {
3733 ost = output_streams[i];
3735 if (ost->stream_copy)
3736 av_freep(&ost->st->codec->extradata);
3738 fclose(ost->logfile);
3739 ost->logfile = NULL;
3741 av_freep(&ost->st->codec->subtitle_header);
3742 av_free(ost->forced_kf_pts);
3743 av_dict_free(&ost->opts);
3750 static int opt_frame_crop(const char *opt, const char *arg)
3752 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3753 return AVERROR(EINVAL);
3756 static int opt_pad(const char *opt, const char *arg)
3758 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3762 static int opt_video_channel(const char *opt, const char *arg)
3764 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3765 return opt_default("channel", arg);
3768 static int opt_video_standard(const char *opt, const char *arg)
3770 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3771 return opt_default("standard", arg);
3774 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3776 audio_codec_name = arg;
3777 return parse_option(o, "codec:a", arg, options);
3780 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3782 video_codec_name = arg;
3783 return parse_option(o, "codec:v", arg, options);
3786 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3788 subtitle_codec_name = arg;
3789 return parse_option(o, "codec:s", arg, options);
3792 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3794 return parse_option(o, "codec:d", arg, options);
3797 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3799 StreamMap *m = NULL;
3800 int i, negative = 0, file_idx;
3801 int sync_file_idx = -1, sync_stream_idx = 0;
3809 map = av_strdup(arg);
3811 /* parse sync stream first, just pick first matching stream */
3812 if (sync = strchr(map, ',')) {
3814 sync_file_idx = strtol(sync + 1, &sync, 0);
3815 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3816 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3821 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3822 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3823 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3824 sync_stream_idx = i;
3827 if (i == input_files[sync_file_idx]->nb_streams) {
3828 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3829 "match any streams.\n", arg);
3835 if (map[0] == '[') {
3836 /* this mapping refers to lavfi output */
3837 const char *c = map + 1;
3838 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3839 &o->nb_stream_maps, o->nb_stream_maps + 1);
3840 m = &o->stream_maps[o->nb_stream_maps - 1];
3841 m->linklabel = av_get_token(&c, "]");
3842 if (!m->linklabel) {
3843 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3847 file_idx = strtol(map, &p, 0);
3848 if (file_idx >= nb_input_files || file_idx < 0) {
3849 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3853 /* disable some already defined maps */
3854 for (i = 0; i < o->nb_stream_maps; i++) {
3855 m = &o->stream_maps[i];
3856 if (file_idx == m->file_index &&
3857 check_stream_specifier(input_files[m->file_index]->ctx,
3858 input_files[m->file_index]->ctx->streams[m->stream_index],
3859 *p == ':' ? p + 1 : p) > 0)
3863 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3864 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3865 *p == ':' ? p + 1 : p) <= 0)
3867 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3868 &o->nb_stream_maps, o->nb_stream_maps + 1);
3869 m = &o->stream_maps[o->nb_stream_maps - 1];
3871 m->file_index = file_idx;
3872 m->stream_index = i;
3874 if (sync_file_idx >= 0) {
3875 m->sync_file_index = sync_file_idx;
3876 m->sync_stream_index = sync_stream_idx;
3878 m->sync_file_index = file_idx;
3879 m->sync_stream_index = i;
3885 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3893 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3895 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3896 &o->nb_attachments, o->nb_attachments + 1);
3897 o->attachments[o->nb_attachments - 1] = arg;
3901 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3907 o->audio_channel_maps =
3908 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3909 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3910 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3912 /* muted channel syntax */
3913 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3914 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3915 m->file_idx = m->stream_idx = -1;
3917 m->ofile_idx = m->ostream_idx = -1;
3922 n = sscanf(arg, "%d.%d.%d:%d.%d",
3923 &m->file_idx, &m->stream_idx, &m->channel_idx,
3924 &m->ofile_idx, &m->ostream_idx);
3926 if (n != 3 && n != 5) {
3927 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3928 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3932 if (n != 5) // only file.stream.channel specified
3933 m->ofile_idx = m->ostream_idx = -1;
3936 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3937 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3941 if (m->stream_idx < 0 ||
3942 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
3943 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3944 m->file_idx, m->stream_idx);
3947 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
3948 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3949 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3950 m->file_idx, m->stream_idx);
3953 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3954 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3955 m->file_idx, m->stream_idx, m->channel_idx);
3962 * Parse a metadata specifier in arg.
3963 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3964 * @param index for type c/p, chapter/program index is written here
3965 * @param stream_spec for type s, the stream specifier is written here
3967 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3975 if (*(++arg) && *arg != ':') {
3976 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3979 *stream_spec = *arg == ':' ? arg + 1 : "";
3983 if (*(++arg) == ':')
3984 *index = strtol(++arg, NULL, 0);
3987 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3994 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3996 AVDictionary **meta_in = NULL;
3997 AVDictionary **meta_out = NULL;
3999 char type_in, type_out;
4000 const char *istream_spec = NULL, *ostream_spec = NULL;
4001 int idx_in = 0, idx_out = 0;
4003 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
4004 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
4007 if (type_out == 'g' || !*outspec)
4008 o->metadata_global_manual = 1;
4009 if (type_out == 's' || !*outspec)
4010 o->metadata_streams_manual = 1;
4011 if (type_out == 'c' || !*outspec)
4012 o->metadata_chapters_manual = 1;
4016 if (type_in == 'g' || type_out == 'g')
4017 o->metadata_global_manual = 1;
4018 if (type_in == 's' || type_out == 's')
4019 o->metadata_streams_manual = 1;
4020 if (type_in == 'c' || type_out == 'c')
4021 o->metadata_chapters_manual = 1;
4023 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4024 if ((index) < 0 || (index) >= (nb_elems)) {\
4025 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
4030 #define SET_DICT(type, meta, context, index)\
4033 meta = &context->metadata;\
4036 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
4037 meta = &context->chapters[index]->metadata;\
4040 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
4041 meta = &context->programs[index]->metadata;\
4045 SET_DICT(type_in, meta_in, ic, idx_in);
4046 SET_DICT(type_out, meta_out, oc, idx_out);
4048 /* for input streams choose first matching stream */
4049 if (type_in == 's') {
4050 for (i = 0; i < ic->nb_streams; i++) {
4051 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
4052 meta_in = &ic->streams[i]->metadata;
4058 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
4063 if (type_out == 's') {
4064 for (i = 0; i < oc->nb_streams; i++) {
4065 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
4066 meta_out = &oc->streams[i]->metadata;
4067 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4072 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4077 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
4080 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
4081 struct tm time = *gmtime((time_t*)&recording_timestamp);
4082 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
4083 parse_option(o, "metadata", buf, options);
4085 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
4086 "tag instead.\n", opt);
4090 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
4092 const char *codec_string = encoder ? "encoder" : "decoder";
4096 avcodec_find_encoder_by_name(name) :
4097 avcodec_find_decoder_by_name(name);
4099 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4102 if (codec->type != type) {
4103 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4109 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4111 char *codec_name = NULL;
4113 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4115 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4116 st->codec->codec_id = codec->id;
4119 return avcodec_find_decoder(st->codec->codec_id);
4123 * Add all the streams from the given input file to the global
4124 * list of input streams.
4126 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4129 char *next, *codec_tag = NULL;
4131 for (i = 0; i < ic->nb_streams; i++) {
4132 AVStream *st = ic->streams[i];
4133 AVCodecContext *dec = st->codec;
4134 InputStream *ist = av_mallocz(sizeof(*ist));
4139 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4140 input_streams[nb_input_streams - 1] = ist;
4143 ist->file_index = nb_input_files;
4145 st->discard = AVDISCARD_ALL;
4146 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
4148 ist->ts_scale = 1.0;
4149 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4151 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4153 uint32_t tag = strtol(codec_tag, &next, 0);
4155 tag = AV_RL32(codec_tag);
4156 st->codec->codec_tag = tag;
4159 ist->dec = choose_decoder(o, ic, st);
4161 switch (dec->codec_type) {
4162 case AVMEDIA_TYPE_VIDEO:
4164 ist->dec = avcodec_find_decoder(dec->codec_id);
4166 dec->flags |= CODEC_FLAG_EMU_EDGE;
4169 ist->resample_height = dec->height;
4170 ist->resample_width = dec->width;
4171 ist->resample_pix_fmt = dec->pix_fmt;
4174 case AVMEDIA_TYPE_AUDIO:
4175 guess_input_channel_layout(ist);
4177 ist->resample_sample_fmt = dec->sample_fmt;
4178 ist->resample_sample_rate = dec->sample_rate;
4179 ist->resample_channels = dec->channels;
4180 ist->resample_channel_layout = dec->channel_layout;
4183 case AVMEDIA_TYPE_DATA:
4184 case AVMEDIA_TYPE_SUBTITLE:
4186 ist->dec = avcodec_find_decoder(dec->codec_id);
4188 case AVMEDIA_TYPE_ATTACHMENT:
4189 case AVMEDIA_TYPE_UNKNOWN:
4197 static void assert_file_overwrite(const char *filename)
4199 if ((!file_overwrite || no_file_overwrite) &&
4200 (strchr(filename, ':') == NULL || filename[1] == ':' ||
4201 av_strstart(filename, "file:", NULL))) {
4202 if (avio_check(filename, 0) == 0) {
4203 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
4204 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4207 signal(SIGINT, SIG_DFL);
4208 if (!read_yesno()) {
4209 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4215 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4222 static void dump_attachment(AVStream *st, const char *filename)
4225 AVIOContext *out = NULL;
4226 AVDictionaryEntry *e;
4228 if (!st->codec->extradata_size) {
4229 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4230 nb_input_files - 1, st->index);
4233 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4234 filename = e->value;
4236 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4237 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4241 assert_file_overwrite(filename);
4243 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4244 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4249 avio_write(out, st->codec->extradata, st->codec->extradata_size);
4254 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4256 AVFormatContext *ic;
4257 AVInputFormat *file_iformat = NULL;
4261 AVDictionary **opts;
4262 int orig_nb_streams; // number of streams before avformat_find_stream_info
4265 if (!(file_iformat = av_find_input_format(o->format))) {
4266 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4271 if (!strcmp(filename, "-"))
4274 using_stdin |= !strncmp(filename, "pipe:", 5) ||
4275 !strcmp(filename, "/dev/stdin");
4277 /* get default parameters from command line */
4278 ic = avformat_alloc_context();
4280 print_error(filename, AVERROR(ENOMEM));
4283 if (o->nb_audio_sample_rate) {
4284 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4285 av_dict_set(&format_opts, "sample_rate", buf, 0);
4287 if (o->nb_audio_channels) {
4288 /* because we set audio_channels based on both the "ac" and
4289 * "channel_layout" options, we need to check that the specified
4290 * demuxer actually has the "channels" option before setting it */
4291 if (file_iformat && file_iformat->priv_class &&
4292 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4293 AV_OPT_SEARCH_FAKE_OBJ)) {
4294 snprintf(buf, sizeof(buf), "%d",
4295 o->audio_channels[o->nb_audio_channels - 1].u.i);
4296 av_dict_set(&format_opts, "channels", buf, 0);
4299 if (o->nb_frame_rates) {
4300 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4302 if (o->nb_frame_sizes) {
4303 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4305 if (o->nb_frame_pix_fmts)
4306 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4308 ic->video_codec_id = video_codec_name ?
4309 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
4310 ic->audio_codec_id = audio_codec_name ?
4311 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
4312 ic->subtitle_codec_id= subtitle_codec_name ?
4313 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4314 ic->flags |= AVFMT_FLAG_NONBLOCK;
4315 ic->interrupt_callback = int_cb;
4317 /* open the input file with generic avformat function */
4318 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4320 print_error(filename, err);
4323 assert_avoptions(format_opts);
4325 /* apply forced codec ids */
4326 for (i = 0; i < ic->nb_streams; i++)
4327 choose_decoder(o, ic, ic->streams[i]);
4329 /* Set AVCodecContext options for avformat_find_stream_info */
4330 opts = setup_find_stream_info_opts(ic, codec_opts);
4331 orig_nb_streams = ic->nb_streams;
4333 /* If not enough info to get the stream parameters, we decode the
4334 first frames to get it. (used in mpeg case for example) */
4335 ret = avformat_find_stream_info(ic, opts);
4337 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4338 avformat_close_input(&ic);
4342 timestamp = o->start_time;
4343 /* add the stream start time */
4344 if (ic->start_time != AV_NOPTS_VALUE)
4345 timestamp += ic->start_time;
4347 /* if seeking requested, we execute it */
4348 if (o->start_time != 0) {
4349 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4351 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4352 filename, (double)timestamp / AV_TIME_BASE);
4356 /* update the current parameters so that they match the one of the input stream */
4357 add_input_streams(o, ic);
4359 /* dump the file content */
4360 av_dump_format(ic, nb_input_files, filename, 0);
4362 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4363 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4366 input_files[nb_input_files - 1]->ctx = ic;
4367 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
4368 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4369 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4370 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
4372 for (i = 0; i < o->nb_dump_attachment; i++) {
4375 for (j = 0; j < ic->nb_streams; j++) {
4376 AVStream *st = ic->streams[j];
4378 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4379 dump_attachment(st, o->dump_attachment[i].u.str);
4383 for (i = 0; i < orig_nb_streams; i++)
4384 av_dict_free(&opts[i]);
4387 reset_options(o, 1);
4391 static void parse_forced_key_frames(char *kf, OutputStream *ost)
4396 for (p = kf; *p; p++)
4399 ost->forced_kf_count = n;
4400 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
4401 if (!ost->forced_kf_pts) {
4402 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
4406 for (i = 0; i < n; i++) {
4407 char *next = strchr(p, ',');
4408 if (next) *next++ = 0;
4409 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
4414 static uint8_t *get_line(AVIOContext *s)
4420 if (avio_open_dyn_buf(&line) < 0) {
4421 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4425 while ((c = avio_r8(s)) && c != '\n')
4428 avio_close_dyn_buf(line, &buf);
4433 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4436 char filename[1000];
4437 const char *base[3] = { getenv("AVCONV_DATADIR"),
4442 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4446 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4447 i != 1 ? "" : "/.avconv", codec_name, preset_name);
4448 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4451 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4452 i != 1 ? "" : "/.avconv", preset_name);
4453 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4459 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4461 char *codec_name = NULL;
4463 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4465 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4466 NULL, ost->st->codec->codec_type);
4467 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4468 } else if (!strcmp(codec_name, "copy"))
4469 ost->stream_copy = 1;
4471 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4472 ost->st->codec->codec_id = ost->enc->id;
4476 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4479 AVStream *st = avformat_new_stream(oc, NULL);
4480 int idx = oc->nb_streams - 1, ret = 0;
4481 char *bsf = NULL, *next, *codec_tag = NULL;
4482 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4484 char *buf = NULL, *arg = NULL, *preset = NULL;
4485 AVIOContext *s = NULL;
4488 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4492 if (oc->nb_streams - 1 < o->nb_streamid_map)
4493 st->id = o->streamid_map[oc->nb_streams - 1];
4495 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4496 nb_output_streams + 1);
4497 if (!(ost = av_mallocz(sizeof(*ost))))
4499 output_streams[nb_output_streams - 1] = ost;
4501 ost->file_index = nb_output_files;
4504 st->codec->codec_type = type;
4505 choose_encoder(o, oc, ost);
4507 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
4510 avcodec_get_context_defaults3(st->codec, ost->enc);
4511 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4513 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4514 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4517 if (!buf[0] || buf[0] == '#') {
4521 if (!(arg = strchr(buf, '='))) {
4522 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4526 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4528 } while (!s->eof_reached);
4532 av_log(NULL, AV_LOG_FATAL,
4533 "Preset %s specified for stream %d:%d, but could not be opened.\n",
4534 preset, ost->file_index, ost->index);
4538 ost->max_frames = INT64_MAX;
4539 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4541 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4543 if (next = strchr(bsf, ','))
4545 if (!(bsfc = av_bitstream_filter_init(bsf))) {
4546 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4550 bsfc_prev->next = bsfc;
4552 ost->bitstream_filters = bsfc;
4558 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4560 uint32_t tag = strtol(codec_tag, &next, 0);
4562 tag = AV_RL32(codec_tag);
4563 st->codec->codec_tag = tag;
4566 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4567 if (qscale >= 0 || same_quant) {
4568 st->codec->flags |= CODEC_FLAG_QSCALE;
4569 st->codec->global_quality = FF_QP2LAMBDA * qscale;
4572 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4573 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4575 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4576 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4577 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4579 ost->source_index = source_index;
4580 if (source_index >= 0) {
4581 ost->sync_ist = input_streams[source_index];
4582 input_streams[source_index]->discard = 0;
4583 input_streams[source_index]->st->discard = AVDISCARD_NONE;
4589 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4592 const char *p = str;
4599 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4606 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4610 AVCodecContext *video_enc;
4612 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4614 video_enc = st->codec;
4616 if (!ost->stream_copy) {
4617 const char *p = NULL;
4618 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
4619 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4620 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
4623 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4624 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4625 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4629 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4630 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4631 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4635 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4636 if (frame_aspect_ratio) {
4638 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4639 q.num <= 0 || q.den <= 0) {
4640 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4643 ost->frame_aspect_ratio = av_q2d(q);
4646 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4647 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4648 if (frame_pix_fmt && *frame_pix_fmt == '+') {
4649 ost->keep_pix_fmt = 1;
4650 if (!*++frame_pix_fmt)
4651 frame_pix_fmt = NULL;
4653 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4654 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4657 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4660 video_enc->gop_size = 0;
4661 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4663 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4664 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4667 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4669 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4671 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4672 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4675 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4678 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4679 for (i = 0; p; i++) {
4681 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4683 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4686 /* FIXME realloc failure */
4687 video_enc->rc_override =
4688 av_realloc(video_enc->rc_override,
4689 sizeof(RcOverride) * (i + 1));
4690 video_enc->rc_override[i].start_frame = start;
4691 video_enc->rc_override[i].end_frame = end;
4693 video_enc->rc_override[i].qscale = q;
4694 video_enc->rc_override[i].quality_factor = 1.0;
4697 video_enc->rc_override[i].qscale = 0;
4698 video_enc->rc_override[i].quality_factor = -q/100.0;
4703 video_enc->rc_override_count = i;
4704 if (!video_enc->rc_initial_buffer_occupancy)
4705 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4706 video_enc->intra_dc_precision = intra_dc_precision - 8;
4709 video_enc->flags|= CODEC_FLAG_PSNR;
4714 video_enc->flags |= CODEC_FLAG_PASS1;
4717 video_enc->flags |= CODEC_FLAG_PASS2;
4721 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4722 if (forced_key_frames)
4723 parse_forced_key_frames(forced_key_frames, ost);
4725 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4727 ost->top_field_first = -1;
4728 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4730 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4732 ost->avfilter = av_strdup(filters);
4734 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4740 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4745 AVCodecContext *audio_enc;
4747 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4750 audio_enc = st->codec;
4751 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4753 if (!ost->stream_copy) {
4754 char *sample_fmt = NULL, *filters = NULL;
4756 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4758 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4760 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4761 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4765 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4767 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4769 ost->avfilter = av_strdup(filters);
4771 /* check for channel mapping for this audio stream */
4772 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4773 AudioChannelMap *map = &o->audio_channel_maps[n];
4774 InputStream *ist = input_streams[ost->source_index];
4775 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4776 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4777 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4778 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4779 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4781 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4782 ost->file_index, ost->st->index);
4790 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4794 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4795 if (!ost->stream_copy) {
4796 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4803 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4805 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4806 ost->stream_copy = 1;
4810 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4814 AVCodecContext *subtitle_enc;
4816 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4818 subtitle_enc = st->codec;
4820 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4822 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4827 /* arg format is "output-stream-index:streamid-value". */
4828 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4834 av_strlcpy(idx_str, arg, sizeof(idx_str));
4835 p = strchr(idx_str, ':');
4837 av_log(NULL, AV_LOG_FATAL,
4838 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4843 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4844 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4845 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4849 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4851 AVFormatContext *is = ifile->ctx;
4852 AVFormatContext *os = ofile->ctx;
4855 for (i = 0; i < is->nb_chapters; i++) {
4856 AVChapter *in_ch = is->chapters[i], *out_ch;
4857 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4858 AV_TIME_BASE_Q, in_ch->time_base);
4859 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4860 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4863 if (in_ch->end < ts_off)
4865 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4868 out_ch = av_mallocz(sizeof(AVChapter));
4870 return AVERROR(ENOMEM);
4872 out_ch->id = in_ch->id;
4873 out_ch->time_base = in_ch->time_base;
4874 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4875 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4878 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4881 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4883 return AVERROR(ENOMEM);
4884 os->chapters[os->nb_chapters - 1] = out_ch;
4889 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4892 AVFormatContext *ic = avformat_alloc_context();
4894 ic->interrupt_callback = int_cb;
4895 err = avformat_open_input(&ic, filename, NULL, NULL);
4898 /* copy stream format */
4899 for(i=0;i<ic->nb_streams;i++) {
4903 AVCodecContext *avctx;
4905 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4906 ost = new_output_stream(o, s, codec->type, -1);
4911 // FIXME: a more elegant solution is needed
4912 memcpy(st, ic->streams[i], sizeof(AVStream));
4914 st->info = av_malloc(sizeof(*st->info));
4915 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4917 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4919 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4920 choose_sample_fmt(st, codec);
4921 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4922 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4925 avformat_close_input(&ic);
4929 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4930 AVFormatContext *oc)
4934 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4935 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
4936 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
4938 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
4943 ost->source_index = -1;
4944 ost->filter = ofilter;
4948 if (ost->stream_copy) {
4949 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4950 "which is fed from a complex filtergraph. Filtering and streamcopy "
4951 "cannot be used together.\n", ost->file_index, ost->index);
4955 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4956 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4959 avfilter_inout_free(&ofilter->out_tmp);
4962 static void opt_output_file(void *optctx, const char *filename)
4964 OptionsContext *o = optctx;
4965 AVFormatContext *oc;
4967 AVOutputFormat *file_oformat;
4971 if (configure_complex_filters() < 0) {
4972 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4976 if (!strcmp(filename, "-"))
4979 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4981 print_error(filename, err);
4984 file_oformat= oc->oformat;
4985 oc->interrupt_callback = int_cb;
4987 /* create streams for all unlabeled output pads */
4988 for (i = 0; i < nb_filtergraphs; i++) {
4989 FilterGraph *fg = filtergraphs[i];
4990 for (j = 0; j < fg->nb_outputs; j++) {
4991 OutputFilter *ofilter = fg->outputs[j];
4993 if (!ofilter->out_tmp || ofilter->out_tmp->name)
4996 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4997 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
4998 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
4999 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
5001 init_output_filter(ofilter, o, oc);
5005 if (!strcmp(file_oformat->name, "ffm") &&
5006 av_strstart(filename, "http:", NULL)) {
5008 /* special case for files sent to ffserver: we get the stream
5009 parameters from ffserver */
5010 int err = read_ffserver_streams(o, oc, filename);
5012 print_error(filename, err);
5015 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
5016 ost = output_streams[j];
5017 for (i = 0; i < nb_input_streams; i++) {
5018 ist = input_streams[i];
5019 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
5021 ost->source_index= i;
5023 ist->st->discard = AVDISCARD_NONE;
5028 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
5032 } else if (!o->nb_stream_maps) {
5033 /* pick the "best" stream of each type */
5035 /* video: highest resolution */
5036 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
5037 int area = 0, idx = -1;
5038 for (i = 0; i < nb_input_streams; i++) {
5039 ist = input_streams[i];
5040 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
5041 ist->st->codec->width * ist->st->codec->height > area) {
5042 area = ist->st->codec->width * ist->st->codec->height;
5047 new_video_stream(o, oc, idx);
5050 /* audio: most channels */
5051 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
5052 int channels = 0, idx = -1;
5053 for (i = 0; i < nb_input_streams; i++) {
5054 ist = input_streams[i];
5055 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
5056 ist->st->codec->channels > channels) {
5057 channels = ist->st->codec->channels;
5062 new_audio_stream(o, oc, idx);
5065 /* subtitles: pick first */
5066 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
5067 for (i = 0; i < nb_input_streams; i++)
5068 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
5069 new_subtitle_stream(o, oc, i);
5073 /* do something with data? */
5075 for (i = 0; i < o->nb_stream_maps; i++) {
5076 StreamMap *map = &o->stream_maps[i];
5077 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5082 if (map->linklabel) {
5084 OutputFilter *ofilter = NULL;
5087 for (j = 0; j < nb_filtergraphs; j++) {
5088 fg = filtergraphs[j];
5089 for (k = 0; k < fg->nb_outputs; k++) {
5090 AVFilterInOut *out = fg->outputs[k]->out_tmp;
5091 if (out && !strcmp(out->name, map->linklabel)) {
5092 ofilter = fg->outputs[k];
5099 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5100 "in any defined filter graph.\n", map->linklabel);
5103 init_output_filter(ofilter, o, oc);
5105 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5106 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5108 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5110 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5112 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5115 switch (ist->st->codec->codec_type) {
5116 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
5117 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
5118 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
5119 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
5120 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5122 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5123 map->file_index, map->stream_index);
5131 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5132 AVDictionaryEntry *e;
5133 ost = output_streams[i];
5135 if ( ost->stream_copy
5136 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5137 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5138 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5142 /* handle attached files */
5143 for (i = 0; i < o->nb_attachments; i++) {
5145 uint8_t *attachment;
5149 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5150 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5154 if ((len = avio_size(pb)) <= 0) {
5155 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5159 if (!(attachment = av_malloc(len))) {
5160 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5164 avio_read(pb, attachment, len);
5166 ost = new_attachment_stream(o, oc, -1);
5167 ost->stream_copy = 0;
5168 ost->attachment_filename = o->attachments[i];
5169 ost->st->codec->extradata = attachment;
5170 ost->st->codec->extradata_size = len;
5172 p = strrchr(o->attachments[i], '/');
5173 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5177 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5178 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5181 output_files[nb_output_files - 1]->ctx = oc;
5182 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
5183 output_files[nb_output_files - 1]->recording_time = o->recording_time;
5184 if (o->recording_time != INT64_MAX)
5185 oc->duration = o->recording_time;
5186 output_files[nb_output_files - 1]->start_time = o->start_time;
5187 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5188 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5190 /* check filename in case of an image number is expected */
5191 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5192 if (!av_filename_number_test(oc->filename)) {
5193 print_error(oc->filename, AVERROR(EINVAL));
5198 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5199 /* test if it already exists to avoid losing precious files */
5200 assert_file_overwrite(filename);
5203 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5204 &oc->interrupt_callback,
5205 &output_files[nb_output_files - 1]->opts)) < 0) {
5206 print_error(filename, err);
5211 if (o->mux_preload) {
5213 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5214 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5216 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5219 for (i = 0; i < o->nb_metadata_map; i++) {
5221 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5223 if (in_file_index >= nb_input_files) {
5224 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5227 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5231 if (o->chapters_input_file >= nb_input_files) {
5232 if (o->chapters_input_file == INT_MAX) {
5233 /* copy chapters from the first input file that has them*/
5234 o->chapters_input_file = -1;
5235 for (i = 0; i < nb_input_files; i++)
5236 if (input_files[i]->ctx->nb_chapters) {
5237 o->chapters_input_file = i;
5241 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5242 o->chapters_input_file);
5246 if (o->chapters_input_file >= 0)
5247 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5248 !o->metadata_chapters_manual);
5250 /* copy global metadata by default */
5251 if (!o->metadata_global_manual && nb_input_files){
5252 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5253 AV_DICT_DONT_OVERWRITE);
5254 if(o->recording_time != INT64_MAX)
5255 av_dict_set(&oc->metadata, "duration", NULL, 0);
5257 if (!o->metadata_streams_manual)
5258 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5260 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
5262 ist = input_streams[output_streams[i]->source_index];
5263 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5266 /* process manually set metadata */
5267 for (i = 0; i < o->nb_metadata; i++) {
5270 const char *stream_spec;
5271 int index = 0, j, ret = 0;
5273 val = strchr(o->metadata[i].u.str, '=');
5275 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5276 o->metadata[i].u.str);
5281 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5283 for (j = 0; j < oc->nb_streams; j++) {
5284 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5285 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5289 printf("ret %d, stream_spec %s\n", ret, stream_spec);
5297 if (index < 0 || index >= oc->nb_chapters) {
5298 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5301 m = &oc->chapters[index]->metadata;
5304 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5307 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5311 reset_options(o, 0);
5314 /* same option as mencoder */
5315 static int opt_pass(const char *opt, const char *arg)
5317 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5321 static int64_t getmaxrss(void)
5323 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5324 struct rusage rusage;
5325 getrusage(RUSAGE_SELF, &rusage);
5326 return (int64_t)rusage.ru_maxrss * 1024;
5327 #elif HAVE_GETPROCESSMEMORYINFO
5329 PROCESS_MEMORY_COUNTERS memcounters;
5330 proc = GetCurrentProcess();
5331 memcounters.cb = sizeof(memcounters);
5332 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5333 return memcounters.PeakPagefileUsage;
5339 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5341 return parse_option(o, "q:a", arg, options);
5344 static void show_usage(void)
5346 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5347 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5348 av_log(NULL, AV_LOG_INFO, "\n");
5351 static int opt_help(const char *opt, const char *arg)
5353 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5354 av_log_set_callback(log_callback_help);
5356 show_help_options(options, "Main options:\n",
5357 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5358 show_help_options(options, "\nAdvanced options:\n",
5359 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5361 show_help_options(options, "\nVideo options:\n",
5362 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5364 show_help_options(options, "\nAdvanced Video options:\n",
5365 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5366 OPT_VIDEO | OPT_EXPERT);
5367 show_help_options(options, "\nAudio options:\n",
5368 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5370 show_help_options(options, "\nAdvanced Audio options:\n",
5371 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5372 OPT_AUDIO | OPT_EXPERT);
5373 show_help_options(options, "\nSubtitle options:\n",
5374 OPT_SUBTITLE | OPT_GRAB,
5376 show_help_options(options, "\nAudio/Video grab options:\n",
5380 show_help_children(avcodec_get_class(), flags);
5381 show_help_children(avformat_get_class(), flags);
5382 show_help_children(sws_get_class(), flags);
5387 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5389 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5390 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5392 if (!strncmp(arg, "pal-", 4)) {
5395 } else if (!strncmp(arg, "ntsc-", 5)) {
5398 } else if (!strncmp(arg, "film-", 5)) {
5402 /* Try to determine PAL/NTSC by peeking in the input files */
5403 if (nb_input_files) {
5405 for (j = 0; j < nb_input_files; j++) {
5406 for (i = 0; i < input_files[j]->nb_streams; i++) {
5407 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5408 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5410 fr = c->time_base.den * 1000 / c->time_base.num;
5414 } else if ((fr == 29970) || (fr == 23976)) {
5419 if (norm != UNKNOWN)
5423 if (norm != UNKNOWN)
5424 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5427 if (norm == UNKNOWN) {
5428 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5429 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5430 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5434 if (!strcmp(arg, "vcd")) {
5435 opt_video_codec(o, "c:v", "mpeg1video");
5436 opt_audio_codec(o, "c:a", "mp2");
5437 parse_option(o, "f", "vcd", options);
5439 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5440 parse_option(o, "r", frame_rates[norm], options);
5441 opt_default("g", norm == PAL ? "15" : "18");
5443 opt_default("b:v", "1150000");
5444 opt_default("maxrate", "1150000");
5445 opt_default("minrate", "1150000");
5446 opt_default("bufsize", "327680"); // 40*1024*8;
5448 opt_default("b:a", "224000");
5449 parse_option(o, "ar", "44100", options);
5450 parse_option(o, "ac", "2", options);
5452 opt_default("packetsize", "2324");
5453 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5455 /* We have to offset the PTS, so that it is consistent with the SCR.
5456 SCR starts at 36000, but the first two packs contain only padding
5457 and the first pack from the other stream, respectively, may also have
5458 been written before.
5459 So the real data starts at SCR 36000+3*1200. */
5460 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5461 } else if (!strcmp(arg, "svcd")) {
5463 opt_video_codec(o, "c:v", "mpeg2video");
5464 opt_audio_codec(o, "c:a", "mp2");
5465 parse_option(o, "f", "svcd", options);
5467 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5468 parse_option(o, "r", frame_rates[norm], options);
5469 parse_option(o, "pix_fmt", "yuv420p", options);
5470 opt_default("g", norm == PAL ? "15" : "18");
5472 opt_default("b:v", "2040000");
5473 opt_default("maxrate", "2516000");
5474 opt_default("minrate", "0"); // 1145000;
5475 opt_default("bufsize", "1835008"); // 224*1024*8;
5476 opt_default("scan_offset", "1");
5479 opt_default("b:a", "224000");
5480 parse_option(o, "ar", "44100", options);
5482 opt_default("packetsize", "2324");
5484 } else if (!strcmp(arg, "dvd")) {
5486 opt_video_codec(o, "c:v", "mpeg2video");
5487 opt_audio_codec(o, "c:a", "ac3");
5488 parse_option(o, "f", "dvd", options);
5490 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5491 parse_option(o, "r", frame_rates[norm], options);
5492 parse_option(o, "pix_fmt", "yuv420p", options);
5493 opt_default("g", norm == PAL ? "15" : "18");
5495 opt_default("b:v", "6000000");
5496 opt_default("maxrate", "9000000");
5497 opt_default("minrate", "0"); // 1500000;
5498 opt_default("bufsize", "1835008"); // 224*1024*8;
5500 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5501 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5503 opt_default("b:a", "448000");
5504 parse_option(o, "ar", "48000", options);
5506 } else if (!strncmp(arg, "dv", 2)) {
5508 parse_option(o, "f", "dv", options);
5510 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5511 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5512 norm == PAL ? "yuv420p" : "yuv411p", options);
5513 parse_option(o, "r", frame_rates[norm], options);
5515 parse_option(o, "ar", "48000", options);
5516 parse_option(o, "ac", "2", options);
5519 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5520 return AVERROR(EINVAL);
5525 static int opt_vstats_file(const char *opt, const char *arg)
5527 av_free (vstats_filename);
5528 vstats_filename = av_strdup (arg);
5532 static int opt_vstats(const char *opt, const char *arg)
5535 time_t today2 = time(NULL);
5536 struct tm *today = localtime(&today2);
5538 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5540 return opt_vstats_file(opt, filename);
5543 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5545 return parse_option(o, "frames:v", arg, options);
5548 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5550 return parse_option(o, "frames:a", arg, options);
5553 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5555 return parse_option(o, "frames:d", arg, options);
5558 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5561 char filename[1000], line[1000], tmp_line[1000];
5562 const char *codec_name = *opt == 'v' ? video_codec_name :
5563 *opt == 'a' ? audio_codec_name :
5564 subtitle_codec_name;
5566 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5567 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5568 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5570 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5574 while (fgets(line, sizeof(line), f)) {
5575 char *key = tmp_line, *value, *endptr;
5577 if (strcspn(line, "#\n\r") == 0)
5579 strcpy(tmp_line, line);
5580 if (!av_strtok(key, "=", &value) ||
5581 !av_strtok(value, "\r\n", &endptr)) {
5582 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5585 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
5587 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
5588 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
5589 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
5590 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
5591 else if (opt_default(key, value) < 0) {
5592 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
5593 filename, line, key, value);
5603 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5607 static int opt_passlogfile(const char *opt, const char *arg)
5609 pass_logfilename_prefix = arg;
5610 #if CONFIG_LIBX264_ENCODER
5611 return opt_default(opt, arg);
5617 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5619 char *s = av_asprintf("%s:%c", opt + 1, *opt);
5620 int ret = parse_option(o, s, arg, options);
5625 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5627 if(!strcmp(opt, "b")){
5628 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5629 return parse_option(o, "b:v", arg, options);
5631 return opt_default(opt, arg);
5634 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5638 if(!strcmp(opt, "qscale")){
5639 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5640 return parse_option(o, "q:v", arg, options);
5642 s = av_asprintf("q%s", opt + 6);
5643 ret = parse_option(o, s, arg, options);
5648 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5650 if(!strcmp(opt, "profile")){
5651 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5652 return parse_option(o, "profile:v", arg, options);
5654 return opt_default(opt, arg);
5657 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5659 return parse_option(o, "filter:v", arg, options);
5662 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
5664 return parse_option(o, "filter:a", arg, options);
5667 static int opt_vsync(const char *opt, const char *arg)
5669 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
5670 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
5671 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5672 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
5674 if (video_sync_method == VSYNC_AUTO)
5675 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5679 static int opt_deinterlace(const char *opt, const char *arg)
5681 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5686 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5688 int idx = locate_option(argc, argv, options, "cpuflags");
5689 if (idx && argv[idx + 1])
5690 opt_cpuflags("cpuflags", argv[idx + 1]);
5693 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5695 char layout_str[32];
5698 int ret, channels, ac_str_size;
5701 layout = av_get_channel_layout(arg);
5703 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5704 return AVERROR(EINVAL);
5706 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5707 ret = opt_default(opt, layout_str);
5711 /* set 'ac' option based on channel layout */
5712 channels = av_get_channel_layout_nb_channels(layout);
5713 snprintf(layout_str, sizeof(layout_str), "%d", channels);
5714 stream_str = strchr(opt, ':');
5715 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5716 ac_str = av_mallocz(ac_str_size);
5718 return AVERROR(ENOMEM);
5719 av_strlcpy(ac_str, "ac", 3);
5721 av_strlcat(ac_str, stream_str, ac_str_size);
5722 ret = parse_option(o, ac_str, layout_str, options);
5728 static int opt_filter_complex(const char *opt, const char *arg)
5730 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5731 &nb_filtergraphs, nb_filtergraphs + 1);
5732 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5733 return AVERROR(ENOMEM);
5734 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
5735 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5739 #define OFFSET(x) offsetof(OptionsContext, x)
5740 static const OptionDef options[] = {
5742 #include "cmdutils_common_opts.h"
5743 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5744 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5745 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5746 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5747 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5748 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5749 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5750 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5751 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
5752 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5753 "outfile[,metadata]:infile[,metadata]" },
5754 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
5755 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5756 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5757 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5758 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5759 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5760 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5761 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5762 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5763 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5764 "add timings for benchmarking" },
5765 { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5766 "add timings for each task" },
5767 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5768 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5769 "dump each input packet" },
5770 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5771 "when dumping packets, also dump the payload" },
5772 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5773 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5774 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5775 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5776 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5777 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
5778 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
5779 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5780 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5781 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5782 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5783 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5784 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5785 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5786 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5787 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5788 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5789 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5790 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5791 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5792 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5793 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5794 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5797 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5798 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5799 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5800 { "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" },
5801 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5802 { "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" },
5803 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5804 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5805 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5806 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5807 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5808 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5809 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5810 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5811 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5812 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5813 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5814 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5815 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5816 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5817 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5818 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5819 "use same quantizer as source (implies VBR)" },
5820 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5821 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5822 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5823 "this option is deprecated, use the yadif filter instead" },
5824 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5825 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5826 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5827 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5828 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5829 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5830 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5831 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5832 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5833 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5834 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5835 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5836 { "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" },
5837 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5840 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5841 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5842 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5843 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5844 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5845 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5846 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5847 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5848 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5849 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5850 { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
5852 /* subtitle options */
5853 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5854 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5855 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5858 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5859 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5860 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5863 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5864 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5866 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5867 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5868 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5870 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5871 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5872 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5873 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5874 /* data codec support */
5875 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5876 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5878 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5882 int main(int argc, char **argv)
5884 OptionsContext o = { 0 };
5887 reset_options(&o, 0);
5889 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5890 parse_loglevel(argc, argv, options);
5892 if(argc>1 && !strcmp(argv[1], "-d")){
5894 av_log_set_callback(log_callback_null);
5899 avcodec_register_all();
5901 avdevice_register_all();
5903 avfilter_register_all();
5905 avformat_network_init();
5907 show_banner(argc, argv, options);
5911 parse_cpuflags(argc, argv, options);
5914 parse_options(&o, argc, argv, options, opt_output_file);
5916 if (nb_output_files <= 0 && nb_input_files == 0) {
5918 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5922 /* file converter / grab */
5923 if (nb_output_files <= 0) {
5924 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5928 if (nb_input_files == 0) {
5929 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5933 current_time = ti = getutime();
5934 if (transcode() < 0)
5936 ti = getutime() - ti;
5938 int maxrss = getmaxrss() / 1024;
5939 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);