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 static void do_video_stats(AVFormatContext *os, OutputStream *ost, int frame_size);
443 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
446 for (i = 0; i < o->nb_ ## name; i++) {\
447 char *spec = o->name[i].specifier;\
448 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
449 outvar = o->name[i].u.type;\
455 static int64_t getutime(void)
458 struct rusage rusage;
460 getrusage(RUSAGE_SELF, &rusage);
461 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
462 #elif HAVE_GETPROCESSTIMES
465 proc = GetCurrentProcess();
466 GetProcessTimes(proc, &c, &e, &k, &u);
467 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
473 static void update_benchmark(const char *fmt, ...)
475 if (do_benchmark_all) {
476 int64_t t = getutime();
482 vsnprintf(buf, sizeof(buf), fmt, va);
484 printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
490 static void reset_options(OptionsContext *o, int is_input)
492 const OptionDef *po = options;
493 OptionsContext bak= *o;
496 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
498 void *dst = (uint8_t*)o + po->u.off;
500 if (po->flags & OPT_SPEC) {
501 SpecifierOpt **so = dst;
502 int i, *count = (int*)(so + 1);
503 for (i = 0; i < *count; i++) {
504 av_freep(&(*so)[i].specifier);
505 if (po->flags & OPT_STRING)
506 av_freep(&(*so)[i].u.str);
510 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
515 for (i = 0; i < o->nb_stream_maps; i++)
516 av_freep(&o->stream_maps[i].linklabel);
517 av_freep(&o->stream_maps);
518 av_freep(&o->audio_channel_maps);
519 av_freep(&o->streamid_map);
521 memset(o, 0, sizeof(*o));
523 if(is_input) o->recording_time = bak.recording_time;
524 else o->recording_time = INT64_MAX;
525 o->mux_max_delay = 0.7;
526 o->limit_filesize = UINT64_MAX;
527 o->chapters_input_file = INT_MAX;
533 static int alloc_buffer(InputStream *ist, AVCodecContext *s, FrameBuffer **pbuf)
535 FrameBuffer *buf = av_mallocz(sizeof(*buf));
537 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
538 int h_chroma_shift, v_chroma_shift;
539 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
540 int w = s->width, h = s->height;
543 return AVERROR(ENOMEM);
545 avcodec_align_dimensions(s, &w, &h);
547 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
552 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
553 s->pix_fmt, 32)) < 0) {
557 /* XXX this shouldn't be needed, but some tests break without this line
558 * those decoders are buggy and need to be fixed.
559 * the following tests fail:
560 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
562 memset(buf->base[0], 128, ret);
564 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
565 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
566 const int h_shift = i==0 ? 0 : h_chroma_shift;
567 const int v_shift = i==0 ? 0 : v_chroma_shift;
568 if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1] || !buf->base[i])
569 buf->data[i] = buf->base[i];
571 buf->data[i] = buf->base[i] +
572 FFALIGN((buf->linesize[i]*edge >> v_shift) +
573 (pixel_size*edge >> h_shift), 32);
577 buf->pix_fmt = s->pix_fmt;
584 static void free_buffer_pool(InputStream *ist)
586 FrameBuffer *buf = ist->buffer_pool;
588 ist->buffer_pool = buf->next;
589 av_freep(&buf->base[0]);
591 buf = ist->buffer_pool;
595 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
597 av_assert0(buf->refcount > 0);
599 if (!buf->refcount) {
601 for(tmp= ist->buffer_pool; tmp; tmp= tmp->next)
602 av_assert1(tmp != buf);
603 buf->next = ist->buffer_pool;
604 ist->buffer_pool = buf;
608 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
610 InputStream *ist = s->opaque;
614 if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0)
617 if (!ist->buffer_pool && (ret = alloc_buffer(ist, s, &ist->buffer_pool)) < 0)
620 buf = ist->buffer_pool;
621 ist->buffer_pool = buf->next;
623 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
624 av_freep(&buf->base[0]);
626 if ((ret = alloc_buffer(ist, s, &buf)) < 0)
629 av_assert0(!buf->refcount);
633 frame->type = FF_BUFFER_TYPE_USER;
634 frame->extended_data = frame->data;
635 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
636 frame->width = buf->w;
637 frame->height = buf->h;
638 frame->format = buf->pix_fmt;
639 frame->sample_aspect_ratio = s->sample_aspect_ratio;
641 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
642 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
643 frame->data[i] = buf->data[i];
644 frame->linesize[i] = buf->linesize[i];
650 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
652 InputStream *ist = s->opaque;
653 FrameBuffer *buf = frame->opaque;
656 if(frame->type!=FF_BUFFER_TYPE_USER)
657 return avcodec_default_release_buffer(s, frame);
659 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
660 frame->data[i] = NULL;
662 unref_buffer(ist, buf);
665 static void filter_release_buffer(AVFilterBuffer *fb)
667 FrameBuffer *buf = fb->priv;
669 unref_buffer(buf->ist, buf);
672 static enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target)
674 if (codec && codec->pix_fmts) {
675 const enum PixelFormat *p = codec->pix_fmts;
676 int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0;
677 enum PixelFormat best= PIX_FMT_NONE;
678 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
679 if (st->codec->codec_id == CODEC_ID_MJPEG) {
680 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
681 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
682 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
683 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
686 for (; *p != PIX_FMT_NONE; p++) {
687 best= avcodec_find_best_pix_fmt2(best, *p, target, has_alpha, NULL);
691 if (*p == PIX_FMT_NONE) {
692 if (target != PIX_FMT_NONE)
693 av_log(NULL, AV_LOG_WARNING,
694 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
695 av_pix_fmt_descriptors[target].name,
697 av_pix_fmt_descriptors[best].name);
704 static char *choose_pix_fmts(OutputStream *ost)
706 if (ost->keep_pix_fmt) {
708 avfilter_graph_set_auto_convert(ost->filter->graph->graph,
709 AVFILTER_AUTO_CONVERT_NONE);
710 if (ost->st->codec->pix_fmt == PIX_FMT_NONE)
712 return av_strdup(av_get_pix_fmt_name(ost->st->codec->pix_fmt));
714 if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
715 return av_strdup(av_get_pix_fmt_name(choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt)));
716 } else if (ost->enc && ost->enc->pix_fmts) {
717 const enum PixelFormat *p;
718 AVIOContext *s = NULL;
722 if (avio_open_dyn_buf(&s) < 0)
725 p = ost->enc->pix_fmts;
726 if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
727 if (ost->st->codec->codec_id == CODEC_ID_MJPEG) {
728 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
729 } else if (ost->st->codec->codec_id == CODEC_ID_LJPEG) {
730 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
731 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
735 for (; *p != PIX_FMT_NONE; p++) {
736 const char *name = av_get_pix_fmt_name(*p);
737 avio_printf(s, "%s:", name);
739 len = avio_close_dyn_buf(s, &ret);
747 * Define a function for building a string containing a list of
750 #define DEF_CHOOSE_FORMAT(type, var, supported_list, none, get_name, separator) \
751 static char *choose_ ## var ## s(OutputStream *ost) \
753 if (ost->st->codec->var != none) { \
754 get_name(ost->st->codec->var); \
755 return av_strdup(name); \
756 } else if (ost->enc->supported_list) { \
758 AVIOContext *s = NULL; \
762 if (avio_open_dyn_buf(&s) < 0) \
765 for (p = ost->enc->supported_list; *p != none; p++) { \
767 avio_printf(s, "%s" separator, name); \
769 len = avio_close_dyn_buf(s, &ret); \
776 #define GET_PIX_FMT_NAME(pix_fmt)\
777 const char *name = av_get_pix_fmt_name(pix_fmt);
779 // DEF_CHOOSE_FORMAT(enum PixelFormat, pix_fmt, pix_fmts, PIX_FMT_NONE,
780 // GET_PIX_FMT_NAME, ":")
782 #define GET_SAMPLE_FMT_NAME(sample_fmt)\
783 const char *name = av_get_sample_fmt_name(sample_fmt)
785 DEF_CHOOSE_FORMAT(enum AVSampleFormat, sample_fmt, sample_fmts,
786 AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME, ",")
788 #define GET_SAMPLE_RATE_NAME(rate)\
790 snprintf(name, sizeof(name), "%d", rate);
792 DEF_CHOOSE_FORMAT(int, sample_rate, supported_samplerates, 0,
793 GET_SAMPLE_RATE_NAME, ",")
795 #define GET_CH_LAYOUT_NAME(ch_layout)\
797 snprintf(name, sizeof(name), "0x%"PRIx64, ch_layout);
799 DEF_CHOOSE_FORMAT(uint64_t, channel_layout, channel_layouts, 0,
800 GET_CH_LAYOUT_NAME, ",")
802 static int configure_audio_filters(FilterGraph *fg, AVFilterContext **in_filter,
803 AVFilterContext **out_filter)
805 InputStream *ist = fg->inputs[0]->ist;
806 OutputStream *ost = fg->outputs[0]->ost;
807 AVCodecContext *codec = ost->st->codec;
808 AVCodecContext *icodec = ist->st->codec;
809 char *sample_fmts, *sample_rates, *channel_layouts;
813 avfilter_graph_free(&fg->graph);
814 if (!(fg->graph = avfilter_graph_alloc()))
815 return AVERROR(ENOMEM);
817 snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:"
818 "channel_layout=0x%"PRIx64, ist->st->time_base.num,
819 ist->st->time_base.den, icodec->sample_rate,
820 av_get_sample_fmt_name(icodec->sample_fmt), icodec->channel_layout);
821 ret = avfilter_graph_create_filter(&fg->inputs[0]->filter,
822 avfilter_get_by_name("abuffer"),
823 "src", args, NULL, fg->graph);
827 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter,
828 avfilter_get_by_name("abuffersink_old"),
829 "out", NULL, NULL, fg->graph);
833 *in_filter = fg->inputs[0]->filter;
834 *out_filter = fg->outputs[0]->filter;
836 if (codec->channels && !codec->channel_layout)
837 codec->channel_layout = av_get_default_channel_layout(codec->channels);
839 sample_fmts = choose_sample_fmts(ost);
840 sample_rates = choose_sample_rates(ost);
841 channel_layouts = choose_channel_layouts(ost);
842 if (sample_fmts || sample_rates || channel_layouts) {
843 AVFilterContext *format;
848 len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:",
851 len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:",
854 len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:",
858 av_freep(&sample_fmts);
859 av_freep(&sample_rates);
860 av_freep(&channel_layouts);
862 ret = avfilter_graph_create_filter(&format,
863 avfilter_get_by_name("aformat"),
864 "aformat", args, NULL, fg->graph);
868 ret = avfilter_link(format, 0, fg->outputs[0]->filter, 0);
872 *out_filter = format;
875 if (audio_sync_method > 0) {
876 AVFilterContext *aswr;
877 char args[256] = {0};
879 av_strlcatf(args, sizeof(args), "min_comp=0.001:min_hard_comp=%f", audio_drift_threshold);
881 if (audio_sync_method > 1)
882 av_strlcatf(args, sizeof(args), ":max_soft_comp=%f", audio_sync_method/(double)icodec->sample_rate);
884 av_log(NULL, AV_LOG_INFO, "-async %d is forwarded to lavfi similarly to -af aresample=%s\n", audio_sync_method, args);
886 ret = avfilter_graph_create_filter(&aswr, avfilter_get_by_name("aresample"),
887 "aresample", args, NULL, fg->graph);
891 ret = avfilter_link(*in_filter, 0, aswr, 0);
898 #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \
899 AVFilterContext *filt_ctx; \
901 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
902 "similarly to -af " filter_name "=%s.\n", arg); \
904 ret = avfilter_graph_create_filter(&filt_ctx, \
905 avfilter_get_by_name(filter_name), \
906 filter_name, arg, NULL, fg->graph); \
910 ret = avfilter_link(*in_filter, 0, filt_ctx, 0); \
914 *in_filter = filt_ctx; \
917 if (ost->audio_channels_mapped) {
921 av_bprint_init(&pan_buf, 256, 8192);
922 av_bprintf(&pan_buf, "0x%"PRIx64,
923 av_get_default_channel_layout(ost->audio_channels_mapped));
924 for (i = 0; i < ost->audio_channels_mapped; i++)
925 if (ost->audio_channels_map[i] != -1)
926 av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
928 AUTO_INSERT_FILTER("-map_channel", "pan", pan_buf.str);
929 av_bprint_finalize(&pan_buf, NULL);
932 if (audio_volume != 256) {
935 snprintf(args, sizeof(args), "%lf", audio_volume / 256.);
936 AUTO_INSERT_FILTER("-vol", "volume", args);
942 static int configure_video_filters(FilterGraph *fg, AVFilterContext **in_filter,
943 AVFilterContext **out_filter)
945 InputStream *ist = fg->inputs[0]->ist;
946 OutputStream *ost = fg->outputs[0]->ost;
947 AVFilterContext *filter;
948 AVCodecContext *codec = ost->st->codec;
949 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
951 AVRational sample_aspect_ratio;
955 if (ist->st->sample_aspect_ratio.num) {
956 sample_aspect_ratio = ist->st->sample_aspect_ratio;
958 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
960 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,
961 ist->st->codec->height, ist->st->codec->pix_fmt,
962 ist->st->time_base.num, ist->st->time_base.den,
963 sample_aspect_ratio.num, sample_aspect_ratio.den,
964 SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
966 ret = avfilter_graph_create_filter(&fg->inputs[0]->filter,
967 avfilter_get_by_name("buffer"),
968 "src", args, NULL, fg->graph);
972 #if FF_API_OLD_VSINK_API
973 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter,
974 avfilter_get_by_name("buffersink"),
975 "out", NULL, NULL, fg->graph);
977 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter,
978 avfilter_get_by_name("buffersink"),
979 "out", NULL, buffersink_params, fg->graph);
981 av_freep(&buffersink_params);
985 *in_filter = fg->inputs[0]->filter;
986 *out_filter = fg->outputs[0]->filter;
988 if (codec->width || codec->height) {
989 snprintf(args, 255, "%d:%d:flags=0x%X",
992 (unsigned)ost->sws_flags);
993 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
994 NULL, args, NULL, fg->graph)) < 0)
996 if ((ret = avfilter_link(*in_filter, 0, filter, 0)) < 0)
1001 if ((pix_fmts = choose_pix_fmts(ost))) {
1002 if ((ret = avfilter_graph_create_filter(&filter,
1003 avfilter_get_by_name("format"),
1004 "format", pix_fmts, NULL,
1007 if ((ret = avfilter_link(filter, 0, *out_filter, 0)) < 0)
1010 *out_filter = filter;
1011 av_freep(&pix_fmts);
1014 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
1015 fg->graph->scale_sws_opts = av_strdup(args);
1020 static int configure_simple_filtergraph(FilterGraph *fg)
1022 OutputStream *ost = fg->outputs[0]->ost;
1023 AVFilterContext *in_filter, *out_filter;
1026 avfilter_graph_free(&fg->graph);
1027 fg->graph = avfilter_graph_alloc();
1029 return AVERROR(ENOMEM);
1031 switch (ost->st->codec->codec_type) {
1032 case AVMEDIA_TYPE_VIDEO:
1033 ret = configure_video_filters(fg, &in_filter, &out_filter);
1035 case AVMEDIA_TYPE_AUDIO:
1036 ret = configure_audio_filters(fg, &in_filter, &out_filter);
1038 default: av_assert0(0);
1043 if (ost->avfilter) {
1044 AVFilterInOut *outputs = avfilter_inout_alloc();
1045 AVFilterInOut *inputs = avfilter_inout_alloc();
1047 outputs->name = av_strdup("in");
1048 outputs->filter_ctx = in_filter;
1049 outputs->pad_idx = 0;
1050 outputs->next = NULL;
1052 inputs->name = av_strdup("out");
1053 inputs->filter_ctx = out_filter;
1054 inputs->pad_idx = 0;
1055 inputs->next = NULL;
1057 if ((ret = avfilter_graph_parse(fg->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
1059 av_freep(&ost->avfilter);
1061 if ((ret = avfilter_link(in_filter, 0, out_filter, 0)) < 0)
1065 if (ost->keep_pix_fmt)
1066 avfilter_graph_set_auto_convert(fg->graph,
1067 AVFILTER_AUTO_CONVERT_NONE);
1069 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1072 ost->filter = fg->outputs[0];
1077 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
1079 FilterGraph *fg = av_mallocz(sizeof(*fg));
1083 fg->index = nb_filtergraphs;
1085 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
1086 fg->nb_outputs + 1);
1087 if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
1089 fg->outputs[0]->ost = ost;
1090 fg->outputs[0]->graph = fg;
1092 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
1094 if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
1096 fg->inputs[0]->ist = ist;
1097 fg->inputs[0]->graph = fg;
1099 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
1100 &ist->nb_filters, ist->nb_filters + 1);
1101 ist->filters[ist->nb_filters - 1] = fg->inputs[0];
1103 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1104 &nb_filtergraphs, nb_filtergraphs + 1);
1105 filtergraphs[nb_filtergraphs - 1] = fg;
1110 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
1112 InputStream *ist = NULL;
1113 enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
1116 // TODO: support other filter types
1117 if (type != AVMEDIA_TYPE_VIDEO && type != AVMEDIA_TYPE_AUDIO) {
1118 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters supported "
1125 AVStream *st = NULL;
1127 int file_idx = strtol(in->name, &p, 0);
1129 if (file_idx < 0 || file_idx >= nb_input_files) {
1130 av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n",
1131 file_idx, fg->graph_desc);
1134 s = input_files[file_idx]->ctx;
1136 for (i = 0; i < s->nb_streams; i++) {
1137 if (s->streams[i]->codec->codec_type != type)
1139 if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
1145 av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
1146 "matches no streams.\n", p, fg->graph_desc);
1149 ist = input_streams[input_files[file_idx]->ist_index + st->index];
1151 /* find the first unused stream of corresponding type */
1152 for (i = 0; i < nb_input_streams; i++) {
1153 ist = input_streams[i];
1154 if (ist->st->codec->codec_type == type && ist->discard)
1157 if (i == nb_input_streams) {
1158 av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
1159 "unlabeled input pad %d on filter %s", in->pad_idx,
1160 in->filter_ctx->name);
1165 ist->decoding_needed = 1;
1166 ist->st->discard = AVDISCARD_NONE;
1168 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
1169 &fg->nb_inputs, fg->nb_inputs + 1);
1170 if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
1172 fg->inputs[fg->nb_inputs - 1]->ist = ist;
1173 fg->inputs[fg->nb_inputs - 1]->graph = fg;
1175 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
1176 &ist->nb_filters, ist->nb_filters + 1);
1177 ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
1180 static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
1183 AVCodecContext *codec = ofilter->ost->st->codec;
1184 AVFilterContext *last_filter = out->filter_ctx;
1185 int pad_idx = out->pad_idx;
1187 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
1189 #if FF_API_OLD_VSINK_API
1190 ret = avfilter_graph_create_filter(&ofilter->filter,
1191 avfilter_get_by_name("buffersink"),
1192 "out", NULL, NULL, fg->graph);
1194 ret = avfilter_graph_create_filter(&ofilter->filter,
1195 avfilter_get_by_name("buffersink"),
1196 "out", NULL, buffersink_params, fg->graph);
1198 av_freep(&buffersink_params);
1203 if (codec->width || codec->height) {
1205 AVFilterContext *filter;
1207 snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
1210 (unsigned)ofilter->ost->sws_flags);
1211 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
1212 NULL, args, NULL, fg->graph)) < 0)
1214 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
1217 last_filter = filter;
1221 if ((pix_fmts = choose_pix_fmts(ofilter->ost))) {
1222 AVFilterContext *filter;
1223 if ((ret = avfilter_graph_create_filter(&filter,
1224 avfilter_get_by_name("format"),
1225 "format", pix_fmts, NULL,
1228 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
1231 last_filter = filter;
1233 av_freep(&pix_fmts);
1236 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
1242 static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
1244 OutputStream *ost = ofilter->ost;
1245 AVCodecContext *codec = ost->st->codec;
1246 AVFilterContext *last_filter = out->filter_ctx;
1247 int pad_idx = out->pad_idx;
1248 char *sample_fmts, *sample_rates, *channel_layouts;
1251 ret = avfilter_graph_create_filter(&ofilter->filter,
1252 avfilter_get_by_name("abuffersink"),
1253 "out", NULL, NULL, fg->graph);
1257 if (codec->channels && !codec->channel_layout)
1258 codec->channel_layout = av_get_default_channel_layout(codec->channels);
1260 sample_fmts = choose_sample_fmts(ost);
1261 sample_rates = choose_sample_rates(ost);
1262 channel_layouts = choose_channel_layouts(ost);
1263 if (sample_fmts || sample_rates || channel_layouts) {
1264 AVFilterContext *format;
1269 len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:",
1272 len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:",
1274 if (channel_layouts)
1275 len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:",
1279 av_freep(&sample_fmts);
1280 av_freep(&sample_rates);
1281 av_freep(&channel_layouts);
1283 ret = avfilter_graph_create_filter(&format,
1284 avfilter_get_by_name("aformat"),
1285 "aformat", args, NULL, fg->graph);
1289 ret = avfilter_link(last_filter, pad_idx, format, 0);
1293 last_filter = format;
1297 if (audio_sync_method > 0) {
1298 AVFilterContext *async;
1302 av_log(NULL, AV_LOG_WARNING, "-async has been deprecated. Used the "
1303 "asyncts audio filter instead.\n");
1305 if (audio_sync_method > 1)
1306 len += snprintf(args + len, sizeof(args) - len, "compensate=1:"
1307 "max_comp=%d:", audio_sync_method);
1308 snprintf(args + len, sizeof(args) - len, "min_delta=%f",
1309 audio_drift_threshold);
1311 ret = avfilter_graph_create_filter(&async,
1312 avfilter_get_by_name("asyncts"),
1313 "async", args, NULL, fg->graph);
1317 ret = avfilter_link(last_filter, pad_idx, async, 0);
1321 last_filter = async;
1325 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
1331 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
1333 switch (out->filter_ctx->output_pads[out->pad_idx].type) {
1334 case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, ofilter, out);
1335 case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, ofilter, out);
1336 default: av_assert0(0);
1340 static int configure_complex_filter(FilterGraph *fg)
1342 AVFilterInOut *inputs, *outputs, *cur;
1343 int ret, i, init = !fg->graph;
1345 avfilter_graph_free(&fg->graph);
1346 if (!(fg->graph = avfilter_graph_alloc()))
1347 return AVERROR(ENOMEM);
1349 if ((ret = avfilter_graph_parse2(fg->graph, fg->graph_desc, &inputs, &outputs)) < 0)
1352 for (cur = inputs; init && cur; cur = cur->next)
1353 init_input_filter(fg, cur);
1355 for (cur = inputs, i = 0; cur; cur = cur->next, i++) {
1356 InputFilter *ifilter = fg->inputs[i];
1357 InputStream *ist = ifilter->ist;
1362 switch (cur->filter_ctx->input_pads[cur->pad_idx].type) {
1363 case AVMEDIA_TYPE_VIDEO:
1364 sar = ist->st->sample_aspect_ratio.num ?
1365 ist->st->sample_aspect_ratio :
1366 ist->st->codec->sample_aspect_ratio;
1367 snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
1368 ist->st->codec->height, ist->st->codec->pix_fmt,
1369 ist->st->time_base.num, ist->st->time_base.den,
1371 filter = avfilter_get_by_name("buffer");
1373 case AVMEDIA_TYPE_AUDIO:
1374 snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:"
1375 "sample_fmt=%s:channel_layout=0x%"PRIx64,
1376 ist->st->time_base.num, ist->st->time_base.den,
1377 ist->st->codec->sample_rate,
1378 av_get_sample_fmt_name(ist->st->codec->sample_fmt),
1379 ist->st->codec->channel_layout);
1380 filter = avfilter_get_by_name("abuffer");
1386 if ((ret = avfilter_graph_create_filter(&ifilter->filter,
1388 args, NULL, fg->graph)) < 0)
1390 if ((ret = avfilter_link(ifilter->filter, 0,
1391 cur->filter_ctx, cur->pad_idx)) < 0)
1394 avfilter_inout_free(&inputs);
1397 /* we already know the mappings between lavfi outputs and output streams,
1398 * so we can finish the setup */
1399 for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1400 configure_output_filter(fg, fg->outputs[i], cur);
1401 avfilter_inout_free(&outputs);
1403 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1406 /* wait until output mappings are processed */
1407 for (cur = outputs; cur;) {
1408 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1409 &fg->nb_outputs, fg->nb_outputs + 1);
1410 if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1412 fg->outputs[fg->nb_outputs - 1]->graph = fg;
1413 fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1415 fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1422 static int configure_complex_filters(void)
1426 for (i = 0; i < nb_filtergraphs; i++)
1427 if (!filtergraphs[i]->graph &&
1428 (ret = configure_complex_filter(filtergraphs[i])) < 0)
1433 static int configure_filtergraph(FilterGraph *fg)
1435 return fg->graph_desc ? configure_complex_filter(fg) :
1436 configure_simple_filtergraph(fg);
1439 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1442 for (i = 0; i < fg->nb_inputs; i++)
1443 if (fg->inputs[i]->ist == ist)
1448 static void term_exit(void)
1450 av_log(NULL, AV_LOG_QUIET, "%s", "");
1453 tcsetattr (0, TCSANOW, &oldtty);
1457 static volatile int received_sigterm = 0;
1459 static void sigterm_handler(int sig)
1461 received_sigterm = sig;
1462 received_nb_signals++;
1464 if(received_nb_signals > 3)
1468 static void term_init(void)
1474 if (tcgetattr (0, &tty) == 0) {
1479 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1480 |INLCR|IGNCR|ICRNL|IXON);
1481 tty.c_oflag |= OPOST;
1482 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1483 tty.c_cflag &= ~(CSIZE|PARENB);
1486 tty.c_cc[VTIME] = 0;
1488 tcsetattr (0, TCSANOW, &tty);
1490 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
1493 avformat_network_deinit();
1495 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
1496 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
1498 signal(SIGXCPU, sigterm_handler);
1502 /* read a key without blocking */
1503 static int read_key(void)
1515 n = select(1, &rfds, NULL, NULL, &tv);
1517 n = read(0, &ch, 1);
1524 # if HAVE_PEEKNAMEDPIPE
1526 static HANDLE input_handle;
1529 input_handle = GetStdHandle(STD_INPUT_HANDLE);
1530 is_pipe = !GetConsoleMode(input_handle, &dw);
1533 if (stdin->_cnt > 0) {
1538 /* When running under a GUI, you will end here. */
1539 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
1556 static int decode_interrupt_cb(void *ctx)
1558 return received_nb_signals > 1;
1561 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1563 void av_noreturn exit_program(int ret)
1567 for (i = 0; i < nb_filtergraphs; i++) {
1568 avfilter_graph_free(&filtergraphs[i]->graph);
1569 for (j = 0; j < filtergraphs[i]->nb_inputs; j++)
1570 av_freep(&filtergraphs[i]->inputs[j]);
1571 av_freep(&filtergraphs[i]->inputs);
1572 for (j = 0; j < filtergraphs[i]->nb_outputs; j++)
1573 av_freep(&filtergraphs[i]->outputs[j]);
1574 av_freep(&filtergraphs[i]->outputs);
1575 av_freep(&filtergraphs[i]);
1577 av_freep(&filtergraphs);
1580 for (i = 0; i < nb_output_files; i++) {
1581 AVFormatContext *s = output_files[i]->ctx;
1582 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1584 avformat_free_context(s);
1585 av_dict_free(&output_files[i]->opts);
1586 av_freep(&output_files[i]);
1588 for (i = 0; i < nb_output_streams; i++) {
1589 AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1591 AVBitStreamFilterContext *next = bsfc->next;
1592 av_bitstream_filter_close(bsfc);
1595 output_streams[i]->bitstream_filters = NULL;
1597 av_freep(&output_streams[i]->filtered_frame);
1598 av_freep(&output_streams[i]);
1600 for (i = 0; i < nb_input_files; i++) {
1601 avformat_close_input(&input_files[i]->ctx);
1602 av_freep(&input_files[i]);
1604 for (i = 0; i < nb_input_streams; i++) {
1605 av_freep(&input_streams[i]->decoded_frame);
1606 av_dict_free(&input_streams[i]->opts);
1607 free_buffer_pool(input_streams[i]);
1608 av_freep(&input_streams[i]->filters);
1609 av_freep(&input_streams[i]);
1613 fclose(vstats_file);
1614 av_free(vstats_filename);
1616 av_freep(&input_streams);
1617 av_freep(&input_files);
1618 av_freep(&output_streams);
1619 av_freep(&output_files);
1624 avformat_network_deinit();
1626 if (received_sigterm) {
1627 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1628 (int) received_sigterm);
1635 static void assert_avoptions(AVDictionary *m)
1637 AVDictionaryEntry *t;
1638 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1639 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1644 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1646 const char *codec_string = encoder ? "encoder" : "decoder";
1648 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1649 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1650 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1651 "results.\nAdd '-strict experimental' if you want to use it.\n",
1652 codec_string, c->codec->name);
1653 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1654 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1655 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1656 codec_string, codec->name);
1661 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
1663 if (codec && codec->sample_fmts) {
1664 const enum AVSampleFormat *p = codec->sample_fmts;
1665 for (; *p != -1; p++) {
1666 if (*p == st->codec->sample_fmt)
1670 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
1671 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
1672 if(av_get_sample_fmt_name(st->codec->sample_fmt))
1673 av_log(NULL, AV_LOG_WARNING,
1674 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
1675 av_get_sample_fmt_name(st->codec->sample_fmt),
1677 av_get_sample_fmt_name(codec->sample_fmts[0]));
1678 st->codec->sample_fmt = codec->sample_fmts[0];
1683 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1685 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1686 AVCodecContext *avctx = ost->st->codec;
1689 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1690 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1691 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1693 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
1694 int64_t max = ost->st->cur_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
1695 if (ost->st->cur_dts && ost->st->cur_dts != AV_NOPTS_VALUE && max > pkt->dts) {
1696 av_log(s, max - pkt->dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG, "Audio timestamp %"PRId64" < %"PRId64" invalid, cliping\n", pkt->dts, max);
1697 pkt->pts = pkt->dts = max;
1702 * Audio encoders may split the packets -- #frames in != #packets out.
1703 * But there is no reordering, so we can limit the number of output packets
1704 * by simply dropping them here.
1705 * Counting encoded video frames needs to be done separately because of
1706 * reordering, see do_video_out()
1708 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1709 if (ost->frame_number >= ost->max_frames) {
1710 av_free_packet(pkt);
1713 ost->frame_number++;
1717 AVPacket new_pkt = *pkt;
1718 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1719 &new_pkt.data, &new_pkt.size,
1720 pkt->data, pkt->size,
1721 pkt->flags & AV_PKT_FLAG_KEY);
1723 av_free_packet(pkt);
1724 new_pkt.destruct = av_destruct_packet;
1726 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1727 bsfc->filter->name, pkt->stream_index,
1728 avctx->codec ? avctx->codec->name : "copy");
1738 pkt->stream_index = ost->index;
1739 ret = av_interleaved_write_frame(s, pkt);
1741 print_error("av_interleaved_write_frame()", ret);
1746 static int check_recording_time(OutputStream *ost)
1748 OutputFile *of = output_files[ost->file_index];
1750 if (of->recording_time != INT64_MAX &&
1751 av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
1752 AV_TIME_BASE_Q) >= 0) {
1753 ost->is_past_recording_time = 1;
1759 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1762 AVCodecContext *enc = ost->st->codec;
1766 av_init_packet(&pkt);
1770 if (!check_recording_time(ost))
1773 if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
1774 frame->pts = ost->sync_opts;
1775 ost->sync_opts = frame->pts + frame->nb_samples;
1777 av_assert0(pkt.size || !pkt.data);
1778 update_benchmark(NULL);
1779 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1780 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1783 update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
1786 if (pkt.pts != AV_NOPTS_VALUE)
1787 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1788 if (pkt.dts != AV_NOPTS_VALUE)
1789 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1790 if (pkt.duration > 0)
1791 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1794 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1795 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1796 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1797 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1800 write_frame(s, &pkt, ost);
1802 audio_size += pkt.size;
1803 av_free_packet(&pkt);
1807 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1809 AVCodecContext *dec;
1810 AVPicture *picture2;
1811 AVPicture picture_tmp;
1814 dec = ist->st->codec;
1816 /* deinterlace : must be done before any resize */
1817 if (do_deinterlace) {
1820 /* create temporary picture */
1821 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1822 buf = av_malloc(size);
1826 picture2 = &picture_tmp;
1827 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1829 if (avpicture_deinterlace(picture2, picture,
1830 dec->pix_fmt, dec->width, dec->height) < 0) {
1831 /* if error, do not deinterlace */
1832 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1841 if (picture != picture2)
1842 *picture = *picture2;
1846 static void do_subtitle_out(AVFormatContext *s,
1852 static uint8_t *subtitle_out = NULL;
1853 int subtitle_out_max_size = 1024 * 1024;
1854 int subtitle_out_size, nb, i;
1855 AVCodecContext *enc;
1858 if (pts == AV_NOPTS_VALUE) {
1859 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1865 enc = ost->st->codec;
1867 if (!subtitle_out) {
1868 subtitle_out = av_malloc(subtitle_out_max_size);
1871 /* Note: DVB subtitle need one packet to draw them and one other
1872 packet to clear them */
1873 /* XXX: signal it in the codec context ? */
1874 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1879 for (i = 0; i < nb; i++) {
1880 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1882 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1883 // start_display_time is required to be 0
1884 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1885 sub->end_display_time -= sub->start_display_time;
1886 sub->start_display_time = 0;
1887 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1888 subtitle_out_max_size, sub);
1889 if (subtitle_out_size < 0) {
1890 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1894 av_init_packet(&pkt);
1895 pkt.data = subtitle_out;
1896 pkt.size = subtitle_out_size;
1897 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1898 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1899 /* XXX: the pts correction is handled here. Maybe handling
1900 it in the codec would be better */
1902 pkt.pts += 90 * sub->start_display_time;
1904 pkt.pts += 90 * sub->end_display_time;
1906 write_frame(s, &pkt, ost);
1910 static void do_video_out(AVFormatContext *s,
1912 AVFrame *in_picture,
1915 int ret, format_video_sync;
1917 AVCodecContext *enc = ost->st->codec;
1919 double sync_ipts, delta;
1920 double duration = 0;
1922 InputStream *ist = NULL;
1924 if (ost->source_index >= 0)
1925 ist = input_streams[ost->source_index];
1927 if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1928 duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));
1930 sync_ipts = in_picture->pts;
1931 delta = sync_ipts - ost->sync_opts + duration;
1933 /* by default, we output a single frame */
1936 format_video_sync = video_sync_method;
1937 if (format_video_sync == VSYNC_AUTO)
1938 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1940 switch (format_video_sync) {
1942 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1945 else if (delta > 1.1)
1946 nb_frames = lrintf(delta);
1951 else if (delta > 0.6)
1952 ost->sync_opts = lrint(sync_ipts);
1955 case VSYNC_PASSTHROUGH:
1956 ost->sync_opts = lrint(sync_ipts);
1962 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1963 if (nb_frames == 0) {
1965 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1967 } else if (nb_frames > 1) {
1968 nb_frames_dup += nb_frames - 1;
1969 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1974 av_init_packet(&pkt);
1978 in_picture->pts = ost->sync_opts;
1980 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1981 enc->codec->id == CODEC_ID_RAWVIDEO) {
1982 /* raw pictures are written as AVPicture structure to
1983 avoid any copies. We support temporarily the older
1985 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1986 enc->coded_frame->top_field_first = in_picture->top_field_first;
1987 pkt.data = (uint8_t *)in_picture;
1988 pkt.size = sizeof(AVPicture);
1989 pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
1990 pkt.flags |= AV_PKT_FLAG_KEY;
1992 write_frame(s, &pkt, ost);
1995 AVFrame big_picture;
1997 big_picture = *in_picture;
1998 /* better than nothing: use input picture interlaced
2000 big_picture.interlaced_frame = in_picture->interlaced_frame;
2001 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
2002 if (ost->top_field_first == -1)
2003 big_picture.top_field_first = in_picture->top_field_first;
2005 big_picture.top_field_first = !!ost->top_field_first;
2008 /* handles same_quant here. This is not correct because it may
2009 not be a global option */
2010 big_picture.quality = quality;
2011 if (!enc->me_threshold)
2012 big_picture.pict_type = 0;
2013 if (ost->forced_kf_index < ost->forced_kf_count &&
2014 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
2015 big_picture.pict_type = AV_PICTURE_TYPE_I;
2016 ost->forced_kf_index++;
2018 update_benchmark(NULL);
2019 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
2020 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
2022 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
2027 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
2028 pkt.pts = ost->sync_opts;
2030 if (pkt.pts != AV_NOPTS_VALUE)
2031 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2032 if (pkt.dts != AV_NOPTS_VALUE)
2033 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2036 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
2037 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
2038 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
2039 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
2042 write_frame(s, &pkt, ost);
2043 frame_size = pkt.size;
2044 video_size += pkt.size;
2045 av_free_packet(&pkt);
2047 /* if two pass, output log */
2048 if (ost->logfile && enc->stats_out) {
2049 fprintf(ost->logfile, "%s", enc->stats_out);
2055 * For video, number of frames in == number of packets out.
2056 * But there may be reordering, so we can't throw away frames on encoder
2057 * flush, we need to limit them here, before they go into encoder.
2059 ost->frame_number++;
2062 goto duplicate_frame;
2064 if (vstats_filename && frame_size)
2065 do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
2068 static double psnr(double d)
2070 return -10.0 * log(d) / log(10.0);
2073 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
2076 AVCodecContext *enc;
2078 double ti1, bitrate, avg_bitrate;
2080 /* this is executed just the first time do_video_stats is called */
2082 vstats_file = fopen(vstats_filename, "w");
2089 enc = ost->st->codec;
2090 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2091 frame_number = ost->frame_number;
2092 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
2093 if (enc->flags&CODEC_FLAG_PSNR)
2094 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
2096 fprintf(vstats_file,"f_size= %6d ", frame_size);
2097 /* compute pts value */
2098 ti1 = ost->sync_opts * av_q2d(enc->time_base);
2102 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
2103 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
2104 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
2105 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
2106 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
2110 /* check for new output on any of the filtergraphs */
2111 static int poll_filters(void)
2113 AVFilterBufferRef *picref;
2114 AVFrame *filtered_frame = NULL;
2115 int i, ret, ret_all;
2116 unsigned nb_success, nb_eof;
2120 /* Reap all buffers present in the buffer sinks */
2121 for (i = 0; i < nb_output_streams; i++) {
2122 OutputStream *ost = output_streams[i];
2123 OutputFile *of = output_files[ost->file_index];
2126 if (!ost->filter || ost->is_past_recording_time)
2129 if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
2130 return AVERROR(ENOMEM);
2132 avcodec_get_frame_defaults(ost->filtered_frame);
2133 filtered_frame = ost->filtered_frame;
2136 AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base;
2137 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2138 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
2139 ret = av_buffersink_read_samples(ost->filter->filter, &picref,
2140 ost->st->codec->frame_size);
2143 ret = av_buffersink_read(ost->filter->filter, &picref);
2145 ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
2146 AV_BUFFERSINK_FLAG_NO_REQUEST);
2149 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
2151 av_strerror(ret, buf, sizeof(buf));
2152 av_log(NULL, AV_LOG_WARNING,
2153 "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
2157 frame_pts = AV_NOPTS_VALUE;
2158 if (picref->pts != AV_NOPTS_VALUE) {
2159 filtered_frame->pts = frame_pts = av_rescale_q(picref->pts,
2160 ost->filter->filter->inputs[0]->time_base,
2161 ost->st->codec->time_base) -
2162 av_rescale_q(of->start_time,
2164 ost->st->codec->time_base);
2166 if (of->start_time && filtered_frame->pts < 0) {
2167 avfilter_unref_buffer(picref);
2171 //if (ost->source_index >= 0)
2172 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
2175 switch (ost->filter->filter->inputs[0]->type) {
2176 case AVMEDIA_TYPE_VIDEO:
2177 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);
2178 filtered_frame->pts = frame_pts;
2179 if (!ost->frame_aspect_ratio)
2180 ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
2182 do_video_out(of->ctx, ost, filtered_frame,
2183 same_quant ? ost->last_quality :
2184 ost->st->codec->global_quality);
2186 case AVMEDIA_TYPE_AUDIO:
2187 avfilter_copy_buf_props(filtered_frame, picref);
2188 filtered_frame->pts = frame_pts;
2189 do_audio_out(of->ctx, ost, filtered_frame);
2192 // TODO support subtitle filters
2196 avfilter_unref_buffer(picref);
2199 /* Request frames through all the graphs */
2200 ret_all = nb_success = nb_eof = 0;
2201 for (i = 0; i < nb_filtergraphs; i++) {
2202 ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
2205 } else if (ret == AVERROR_EOF) {
2207 } else if (ret != AVERROR(EAGAIN)) {
2209 av_strerror(ret, buf, sizeof(buf));
2210 av_log(NULL, AV_LOG_WARNING,
2211 "Error in request_frame(): %s\n", buf);
2217 /* Try again if anything succeeded */
2219 return nb_eof == nb_filtergraphs ? AVERROR_EOF : ret_all;
2222 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
2226 AVFormatContext *oc;
2228 AVCodecContext *enc;
2229 int frame_number, vid, i;
2231 int64_t pts = INT64_MAX;
2232 static int64_t last_time = -1;
2233 static int qp_histogram[52];
2234 int hours, mins, secs, us;
2236 if (!print_stats && !is_last_report)
2239 if (!is_last_report) {
2240 if (last_time == -1) {
2241 last_time = cur_time;
2244 if ((cur_time - last_time) < 500000)
2246 last_time = cur_time;
2250 oc = output_files[0]->ctx;
2252 total_size = avio_size(oc->pb);
2253 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
2254 total_size = avio_tell(oc->pb);
2261 for (i = 0; i < nb_output_streams; i++) {
2263 ost = output_streams[i];
2264 enc = ost->st->codec;
2265 if (!ost->stream_copy && enc->coded_frame)
2266 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
2267 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2268 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
2270 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2271 float fps, t = (cur_time-timer_start) / 1000000.0;
2273 frame_number = ost->frame_number;
2274 fps = t > 1 ? frame_number / t : 0;
2275 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
2276 frame_number, fps < 9.95, fps, q);
2278 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
2282 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
2284 for (j = 0; j < 32; j++)
2285 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
2287 if (enc->flags&CODEC_FLAG_PSNR) {
2289 double error, error_sum = 0;
2290 double scale, scale_sum = 0;
2291 char type[3] = { 'Y','U','V' };
2292 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
2293 for (j = 0; j < 3; j++) {
2294 if (is_last_report) {
2295 error = enc->error[j];
2296 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
2298 error = enc->coded_frame->error[j];
2299 scale = enc->width * enc->height * 255.0 * 255.0;
2305 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
2307 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
2311 /* compute min output value */
2312 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
2313 ost->st->time_base, AV_TIME_BASE_Q));
2316 secs = pts / AV_TIME_BASE;
2317 us = pts % AV_TIME_BASE;
2323 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
2325 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2326 "size=%8.0fkB time=", total_size / 1024.0);
2327 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2328 "%02d:%02d:%02d.%02d ", hours, mins, secs,
2329 (100 * us) / AV_TIME_BASE);
2330 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2331 "bitrate=%6.1fkbits/s", bitrate);
2333 if (nb_frames_dup || nb_frames_drop)
2334 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
2335 nb_frames_dup, nb_frames_drop);
2337 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
2341 if (is_last_report) {
2342 int64_t raw= audio_size + video_size + extra_size;
2343 av_log(NULL, AV_LOG_INFO, "\n");
2344 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
2345 video_size / 1024.0,
2346 audio_size / 1024.0,
2347 extra_size / 1024.0,
2348 100.0 * (total_size - raw) / raw
2350 if(video_size + audio_size + extra_size == 0){
2351 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
2356 static void flush_encoders(void)
2360 for (i = 0; i < nb_output_streams; i++) {
2361 OutputStream *ost = output_streams[i];
2362 AVCodecContext *enc = ost->st->codec;
2363 AVFormatContext *os = output_files[ost->file_index]->ctx;
2364 int stop_encoding = 0;
2366 if (!ost->encoding_needed)
2369 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
2371 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
2375 int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
2379 switch (ost->st->codec->codec_type) {
2380 case AVMEDIA_TYPE_AUDIO:
2381 encode = avcodec_encode_audio2;
2385 case AVMEDIA_TYPE_VIDEO:
2386 encode = avcodec_encode_video2;
2397 av_init_packet(&pkt);
2401 update_benchmark(NULL);
2402 ret = encode(enc, &pkt, NULL, &got_packet);
2403 update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index);
2405 av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
2409 if (ost->logfile && enc->stats_out) {
2410 fprintf(ost->logfile, "%s", enc->stats_out);
2416 if (pkt.pts != AV_NOPTS_VALUE)
2417 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2418 if (pkt.dts != AV_NOPTS_VALUE)
2419 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2420 write_frame(os, &pkt, ost);
2430 * Check whether a packet from ist should be written into ost at this time
2432 static int check_output_constraints(InputStream *ist, OutputStream *ost)
2434 OutputFile *of = output_files[ost->file_index];
2435 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
2437 if (ost->source_index != ist_index)
2440 if (of->start_time && ist->pts < of->start_time)
2443 if (of->recording_time != INT64_MAX &&
2444 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
2445 (AVRational){ 1, 1000000 }) >= 0) {
2446 ost->is_past_recording_time = 1;
2453 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2455 OutputFile *of = output_files[ost->file_index];
2456 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
2460 av_init_packet(&opkt);
2462 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2463 !ost->copy_initial_nonkeyframes)
2466 /* force the input stream PTS */
2467 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2468 audio_size += pkt->size;
2469 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2470 video_size += pkt->size;
2474 if (pkt->pts != AV_NOPTS_VALUE)
2475 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
2477 opkt.pts = AV_NOPTS_VALUE;
2479 if (pkt->dts == AV_NOPTS_VALUE)
2480 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
2482 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
2483 opkt.dts -= ost_tb_start_time;
2485 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
2486 opkt.flags = pkt->flags;
2488 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2489 if ( ost->st->codec->codec_id != CODEC_ID_H264
2490 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
2491 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
2492 && ost->st->codec->codec_id != CODEC_ID_VC1
2494 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
2495 opkt.destruct = av_destruct_packet;
2497 opkt.data = pkt->data;
2498 opkt.size = pkt->size;
2500 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2501 /* store AVPicture in AVPacket, as expected by the output format */
2502 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2503 opkt.data = (uint8_t *)&pict;
2504 opkt.size = sizeof(AVPicture);
2505 opkt.flags |= AV_PKT_FLAG_KEY;
2508 write_frame(of->ctx, &opkt, ost);
2509 ost->st->codec->frame_number++;
2510 av_free_packet(&opkt);
2513 static void rate_emu_sleep(InputStream *ist)
2515 if (input_files[ist->file_index]->rate_emu) {
2516 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2517 int64_t now = av_gettime() - ist->start;
2523 static int guess_input_channel_layout(InputStream *ist)
2525 AVCodecContext *dec = ist->st->codec;
2527 if (!dec->channel_layout) {
2528 char layout_name[256];
2530 dec->channel_layout = av_get_default_channel_layout(dec->channels);
2531 if (!dec->channel_layout)
2533 av_get_channel_layout_string(layout_name, sizeof(layout_name),
2534 dec->channels, dec->channel_layout);
2535 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2536 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2541 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2543 AVFrame *decoded_frame;
2544 AVCodecContext *avctx = ist->st->codec;
2545 int i, ret, resample_changed;
2547 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2548 return AVERROR(ENOMEM);
2550 avcodec_get_frame_defaults(ist->decoded_frame);
2551 decoded_frame = ist->decoded_frame;
2553 update_benchmark(NULL);
2554 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2555 update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2559 if (avctx->sample_rate <= 0) {
2560 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2561 return AVERROR_INVALIDDATA;
2565 /* no audio frame */
2567 for (i = 0; i < ist->nb_filters; i++)
2568 av_buffersrc_add_ref(ist->filters[i]->filter, NULL,
2569 AV_BUFFERSRC_FLAG_NO_COPY);
2573 /* if the decoder provides a pts, use it instead of the last packet pts.
2574 the decoder could be delaying output by a packet or more. */
2575 if (decoded_frame->pts != AV_NOPTS_VALUE)
2576 ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2577 else if (pkt->pts != AV_NOPTS_VALUE) {
2578 decoded_frame->pts = pkt->pts;
2579 pkt->pts = AV_NOPTS_VALUE;
2581 decoded_frame->pts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2585 /* increment next_dts to use for the case where the input stream does not
2586 have timestamps or there are multiple frames in the packet */
2587 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2589 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2593 rate_emu_sleep(ist);
2595 resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
2596 ist->resample_channels != avctx->channels ||
2597 ist->resample_channel_layout != decoded_frame->channel_layout ||
2598 ist->resample_sample_rate != decoded_frame->sample_rate;
2599 if (resample_changed) {
2600 char layout1[64], layout2[64];
2602 if (!guess_input_channel_layout(ist)) {
2603 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
2604 "layout for Input Stream #%d.%d\n", ist->file_index,
2608 decoded_frame->channel_layout = avctx->channel_layout;
2610 av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
2611 ist->resample_channel_layout);
2612 av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
2613 decoded_frame->channel_layout);
2615 av_log(NULL, AV_LOG_INFO,
2616 "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",
2617 ist->file_index, ist->st->index,
2618 ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt),
2619 ist->resample_channels, layout1,
2620 decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2621 avctx->channels, layout2);
2623 ist->resample_sample_fmt = decoded_frame->format;
2624 ist->resample_sample_rate = decoded_frame->sample_rate;
2625 ist->resample_channel_layout = decoded_frame->channel_layout;
2626 ist->resample_channels = avctx->channels;
2628 for (i = 0; i < nb_filtergraphs; i++)
2629 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2630 configure_filtergraph(filtergraphs[i]) < 0) {
2631 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2636 for (i = 0; i < ist->nb_filters; i++)
2637 av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0);
2642 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2644 AVFrame *decoded_frame;
2645 void *buffer_to_free = NULL;
2646 int i, ret = 0, resample_changed;
2647 int64_t best_effort_timestamp;
2648 AVRational *frame_sample_aspect;
2651 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2652 return AVERROR(ENOMEM);
2654 avcodec_get_frame_defaults(ist->decoded_frame);
2655 decoded_frame = ist->decoded_frame;
2656 pkt->dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2658 update_benchmark(NULL);
2659 ret = avcodec_decode_video2(ist->st->codec,
2660 decoded_frame, got_output, pkt);
2661 update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2665 quality = same_quant ? decoded_frame->quality : 0;
2667 /* no picture yet */
2669 for (i = 0; i < ist->nb_filters; i++)
2670 av_buffersrc_add_ref(ist->filters[i]->filter, NULL, AV_BUFFERSRC_FLAG_NO_COPY);
2674 best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2675 if(best_effort_timestamp != AV_NOPTS_VALUE)
2676 ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2679 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2681 rate_emu_sleep(ist);
2683 if (ist->st->sample_aspect_ratio.num)
2684 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2686 resample_changed = ist->resample_width != decoded_frame->width ||
2687 ist->resample_height != decoded_frame->height ||
2688 ist->resample_pix_fmt != decoded_frame->format;
2689 if (resample_changed) {
2690 av_log(NULL, AV_LOG_INFO,
2691 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2692 ist->file_index, ist->st->index,
2693 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2694 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2696 ist->resample_width = decoded_frame->width;
2697 ist->resample_height = decoded_frame->height;
2698 ist->resample_pix_fmt = decoded_frame->format;
2700 for (i = 0; i < nb_filtergraphs; i++)
2701 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2702 configure_filtergraph(filtergraphs[i]) < 0) {
2703 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2708 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2709 for (i = 0; i < ist->nb_filters; i++) {
2710 int changed = ist->st->codec->width != ist->filters[i]->filter->outputs[0]->w
2711 || ist->st->codec->height != ist->filters[i]->filter->outputs[0]->h
2712 || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2713 // XXX what an ugly hack
2714 if (ist->filters[i]->graph->nb_outputs == 1)
2715 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2717 if (!frame_sample_aspect->num)
2718 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2719 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2720 FrameBuffer *buf = decoded_frame->opaque;
2721 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2722 decoded_frame->data, decoded_frame->linesize,
2723 AV_PERM_READ | AV_PERM_PRESERVE,
2724 ist->st->codec->width, ist->st->codec->height,
2725 ist->st->codec->pix_fmt);
2727 avfilter_copy_frame_props(fb, decoded_frame);
2728 fb->buf->priv = buf;
2729 fb->buf->free = filter_release_buffer;
2731 av_assert0(buf->refcount>0);
2733 av_buffersrc_add_ref(ist->filters[i]->filter, fb,
2734 AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
2735 AV_BUFFERSRC_FLAG_NO_COPY);
2737 if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0)<0) {
2738 av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2744 av_free(buffer_to_free);
2748 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2750 AVSubtitle subtitle;
2751 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2752 &subtitle, got_output, pkt);
2758 rate_emu_sleep(ist);
2760 for (i = 0; i < nb_output_streams; i++) {
2761 OutputStream *ost = output_streams[i];
2763 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2766 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2769 avsubtitle_free(&subtitle);
2773 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2774 static int output_packet(InputStream *ist, const AVPacket *pkt)
2780 if (!ist->saw_first_ts) {
2781 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;
2783 if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2784 ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2785 ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2787 ist->saw_first_ts = 1;
2790 if (ist->next_dts == AV_NOPTS_VALUE)
2791 ist->next_dts = ist->dts;
2792 if (ist->next_pts == AV_NOPTS_VALUE)
2793 ist->next_pts = ist->pts;
2797 av_init_packet(&avpkt);
2805 if (pkt->dts != AV_NOPTS_VALUE) {
2806 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2807 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2808 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2811 // while we have more to decode or while the decoder did output something on EOF
2812 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2816 ist->pts = ist->next_pts;
2817 ist->dts = ist->next_dts;
2819 if (avpkt.size && avpkt.size != pkt->size) {
2820 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2821 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2822 ist->showed_multi_packet_warning = 1;
2825 switch (ist->st->codec->codec_type) {
2826 case AVMEDIA_TYPE_AUDIO:
2827 ret = decode_audio (ist, &avpkt, &got_output);
2829 case AVMEDIA_TYPE_VIDEO:
2830 ret = decode_video (ist, &avpkt, &got_output);
2831 if (avpkt.duration) {
2832 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2833 } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2834 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2835 duration = ((int64_t)AV_TIME_BASE *
2836 ist->st->codec->time_base.num * ticks) /
2837 ist->st->codec->time_base.den;
2841 if(ist->dts != AV_NOPTS_VALUE && duration) {
2842 ist->next_dts += duration;
2844 ist->next_dts = AV_NOPTS_VALUE;
2847 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2849 case AVMEDIA_TYPE_SUBTITLE:
2850 ret = transcode_subtitles(ist, &avpkt, &got_output);
2860 avpkt.pts= AV_NOPTS_VALUE;
2862 // touch data and size only if not EOF
2864 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2874 /* handle stream copy */
2875 if (!ist->decoding_needed) {
2876 rate_emu_sleep(ist);
2877 ist->dts = ist->next_dts;
2878 switch (ist->st->codec->codec_type) {
2879 case AVMEDIA_TYPE_AUDIO:
2880 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2881 ist->st->codec->sample_rate;
2883 case AVMEDIA_TYPE_VIDEO:
2884 if (pkt->duration) {
2885 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2886 } else if(ist->st->codec->time_base.num != 0) {
2887 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2888 ist->next_dts += ((int64_t)AV_TIME_BASE *
2889 ist->st->codec->time_base.num * ticks) /
2890 ist->st->codec->time_base.den;
2894 ist->pts = ist->dts;
2895 ist->next_pts = ist->next_dts;
2897 for (i = 0; pkt && i < nb_output_streams; i++) {
2898 OutputStream *ost = output_streams[i];
2900 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2903 do_streamcopy(ist, ost, pkt);
2909 static void print_sdp(void)
2913 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2917 for (i = 0; i < nb_output_files; i++)
2918 avc[i] = output_files[i]->ctx;
2920 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2921 printf("SDP:\n%s\n", sdp);
2926 static int init_input_stream(int ist_index, char *error, int error_len)
2928 InputStream *ist = input_streams[ist_index];
2930 if (ist->decoding_needed) {
2931 AVCodec *codec = ist->dec;
2933 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2934 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2935 return AVERROR(EINVAL);
2938 ist->dr1 = (codec->capabilities & CODEC_CAP_DR1) && !do_deinterlace;
2939 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2940 ist->st->codec->get_buffer = codec_get_buffer;
2941 ist->st->codec->release_buffer = codec_release_buffer;
2942 ist->st->codec->opaque = ist;
2945 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2946 av_dict_set(&ist->opts, "threads", "auto", 0);
2947 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2948 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2949 ist->file_index, ist->st->index);
2950 return AVERROR(EINVAL);
2952 assert_codec_experimental(ist->st->codec, 0);
2953 assert_avoptions(ist->opts);
2956 ist->next_pts = AV_NOPTS_VALUE;
2957 ist->next_dts = AV_NOPTS_VALUE;
2963 static InputStream *get_input_stream(OutputStream *ost)
2965 if (ost->source_index >= 0)
2966 return input_streams[ost->source_index];
2969 FilterGraph *fg = ost->filter->graph;
2972 for (i = 0; i < fg->nb_inputs; i++)
2973 if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2974 return fg->inputs[i]->ist;
2980 static int transcode_init(void)
2982 int ret = 0, i, j, k;
2983 AVFormatContext *oc;
2984 AVCodecContext *codec, *icodec;
2990 /* init framerate emulation */
2991 for (i = 0; i < nb_input_files; i++) {
2992 InputFile *ifile = input_files[i];
2993 if (ifile->rate_emu)
2994 for (j = 0; j < ifile->nb_streams; j++)
2995 input_streams[j + ifile->ist_index]->start = av_gettime();
2998 /* output stream init */
2999 for (i = 0; i < nb_output_files; i++) {
3000 oc = output_files[i]->ctx;
3001 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
3002 av_dump_format(oc, i, oc->filename, 1);
3003 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
3004 return AVERROR(EINVAL);
3008 /* init complex filtergraphs */
3009 for (i = 0; i < nb_filtergraphs; i++)
3010 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
3013 /* for each output stream, we compute the right encoding parameters */
3014 for (i = 0; i < nb_output_streams; i++) {
3015 ost = output_streams[i];
3016 oc = output_files[ost->file_index]->ctx;
3017 ist = get_input_stream(ost);
3019 if (ost->attachment_filename)
3022 codec = ost->st->codec;
3025 icodec = ist->st->codec;
3027 ost->st->disposition = ist->st->disposition;
3028 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
3029 codec->chroma_sample_location = icodec->chroma_sample_location;
3032 if (ost->stream_copy) {
3033 uint64_t extra_size;
3035 av_assert0(ist && !ost->filter);
3037 extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
3039 if (extra_size > INT_MAX) {
3040 return AVERROR(EINVAL);
3043 /* if stream_copy is selected, no need to decode or encode */
3044 codec->codec_id = icodec->codec_id;
3045 codec->codec_type = icodec->codec_type;
3047 if (!codec->codec_tag) {
3048 if (!oc->oformat->codec_tag ||
3049 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
3050 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
3051 codec->codec_tag = icodec->codec_tag;
3054 codec->bit_rate = icodec->bit_rate;
3055 codec->rc_max_rate = icodec->rc_max_rate;
3056 codec->rc_buffer_size = icodec->rc_buffer_size;
3057 codec->field_order = icodec->field_order;
3058 codec->extradata = av_mallocz(extra_size);
3059 if (!codec->extradata) {
3060 return AVERROR(ENOMEM);
3062 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
3063 codec->extradata_size= icodec->extradata_size;
3064 codec->bits_per_coded_sample = icodec->bits_per_coded_sample;
3066 codec->time_base = ist->st->time_base;
3068 * Avi is a special case here because it supports variable fps but
3069 * having the fps and timebase differe significantly adds quite some
3072 if(!strcmp(oc->oformat->name, "avi")) {
3073 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
3074 && av_q2d(ist->st->time_base) < 1.0/500
3076 codec->time_base = icodec->time_base;
3077 codec->time_base.num *= icodec->ticks_per_frame;
3078 codec->time_base.den *= 2;
3079 codec->ticks_per_frame = 2;
3081 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
3082 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
3083 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
3085 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
3086 && av_q2d(ist->st->time_base) < 1.0/500
3088 codec->time_base = icodec->time_base;
3089 codec->time_base.num *= icodec->ticks_per_frame;
3092 av_reduce(&codec->time_base.num, &codec->time_base.den,
3093 codec->time_base.num, codec->time_base.den, INT_MAX);
3095 switch (codec->codec_type) {
3096 case AVMEDIA_TYPE_AUDIO:
3097 if (audio_volume != 256) {
3098 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3101 codec->channel_layout = icodec->channel_layout;
3102 codec->sample_rate = icodec->sample_rate;
3103 codec->channels = icodec->channels;
3104 codec->frame_size = icodec->frame_size;
3105 codec->audio_service_type = icodec->audio_service_type;
3106 codec->block_align = icodec->block_align;
3107 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
3108 codec->block_align= 0;
3109 if(codec->codec_id == CODEC_ID_AC3)
3110 codec->block_align= 0;
3112 case AVMEDIA_TYPE_VIDEO:
3113 codec->pix_fmt = icodec->pix_fmt;
3114 codec->width = icodec->width;
3115 codec->height = icodec->height;
3116 codec->has_b_frames = icodec->has_b_frames;
3117 if (!codec->sample_aspect_ratio.num) {
3118 codec->sample_aspect_ratio =
3119 ost->st->sample_aspect_ratio =
3120 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
3121 ist->st->codec->sample_aspect_ratio.num ?
3122 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
3124 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3126 case AVMEDIA_TYPE_SUBTITLE:
3127 codec->width = icodec->width;
3128 codec->height = icodec->height;
3130 case AVMEDIA_TYPE_DATA:
3131 case AVMEDIA_TYPE_ATTACHMENT:
3138 ost->enc = avcodec_find_encoder(codec->codec_id);
3140 /* should only happen when a default codec is not present. */
3141 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3142 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3143 ret = AVERROR(EINVAL);
3148 ist->decoding_needed = 1;
3149 ost->encoding_needed = 1;
3151 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3152 if (ist && !ost->frame_rate.num)
3153 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
3154 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3155 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3156 ost->frame_rate = ost->enc->supported_framerates[idx];
3161 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3162 codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
3164 fg = init_simple_filtergraph(ist, ost);
3165 if (configure_simple_filtergraph(fg)) {
3166 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3171 switch (codec->codec_type) {
3172 case AVMEDIA_TYPE_AUDIO:
3173 codec->sample_fmt = ost->filter->filter->inputs[0]->format;
3174 codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
3175 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3176 codec->channels = av_get_channel_layout_nb_channels(codec->channel_layout);
3177 codec->time_base = (AVRational){ 1, codec->sample_rate };
3179 case AVMEDIA_TYPE_VIDEO:
3180 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3181 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3182 && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3183 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3184 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3186 for (j = 0; j < ost->forced_kf_count; j++)
3187 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3191 codec->width = ost->filter->filter->inputs[0]->w;
3192 codec->height = ost->filter->filter->inputs[0]->h;
3193 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3194 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3195 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3196 ost->filter->filter->inputs[0]->sample_aspect_ratio;
3197 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3199 if (codec->width != icodec->width ||
3200 codec->height != icodec->height ||
3201 codec->pix_fmt != icodec->pix_fmt) {
3202 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3206 case AVMEDIA_TYPE_SUBTITLE:
3207 codec->time_base = (AVRational){1, 1000};
3214 if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3215 char logfilename[1024];
3218 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3219 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3221 if (!strcmp(ost->enc->name, "libx264")) {
3222 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3224 if (codec->flags & CODEC_FLAG_PASS2) {
3226 size_t logbuffer_size;
3227 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3228 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3232 codec->stats_in = logbuffer;
3234 if (codec->flags & CODEC_FLAG_PASS1) {
3235 f = fopen(logfilename, "wb");
3237 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3238 logfilename, strerror(errno));
3248 /* open each encoder */
3249 for (i = 0; i < nb_output_streams; i++) {
3250 ost = output_streams[i];
3251 if (ost->encoding_needed) {
3252 AVCodec *codec = ost->enc;
3253 AVCodecContext *dec = NULL;
3255 if ((ist = get_input_stream(ost)))
3256 dec = ist->st->codec;
3257 if (dec && dec->subtitle_header) {
3258 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3259 if (!ost->st->codec->subtitle_header) {
3260 ret = AVERROR(ENOMEM);
3263 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3264 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3266 if (!av_dict_get(ost->opts, "threads", NULL, 0))
3267 av_dict_set(&ost->opts, "threads", "auto", 0);
3268 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3269 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3270 ost->file_index, ost->index);
3271 ret = AVERROR(EINVAL);
3274 assert_codec_experimental(ost->st->codec, 1);
3275 assert_avoptions(ost->opts);
3276 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3277 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3278 " It takes bits/s as argument, not kbits/s\n");
3279 extra_size += ost->st->codec->extradata_size;
3281 if (ost->st->codec->me_threshold)
3282 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3286 /* init input streams */
3287 for (i = 0; i < nb_input_streams; i++)
3288 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3291 /* discard unused programs */
3292 for (i = 0; i < nb_input_files; i++) {
3293 InputFile *ifile = input_files[i];
3294 for (j = 0; j < ifile->ctx->nb_programs; j++) {
3295 AVProgram *p = ifile->ctx->programs[j];
3296 int discard = AVDISCARD_ALL;
3298 for (k = 0; k < p->nb_stream_indexes; k++)
3299 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3300 discard = AVDISCARD_DEFAULT;
3303 p->discard = discard;
3307 /* open files and write file headers */
3308 for (i = 0; i < nb_output_files; i++) {
3309 oc = output_files[i]->ctx;
3310 oc->interrupt_callback = int_cb;
3311 if (avformat_write_header(oc, &output_files[i]->opts) < 0) {
3312 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
3313 ret = AVERROR(EINVAL);
3316 // assert_avoptions(output_files[i]->opts);
3317 if (strcmp(oc->oformat->name, "rtp")) {
3323 /* dump the file output parameters - cannot be done before in case
3325 for (i = 0; i < nb_output_files; i++) {
3326 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3329 /* dump the stream mapping */
3330 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3331 for (i = 0; i < nb_input_streams; i++) {
3332 ist = input_streams[i];
3334 for (j = 0; j < ist->nb_filters; j++) {
3335 AVFilterLink *link = ist->filters[j]->filter->outputs[0];
3336 if (ist->filters[j]->graph->graph_desc) {
3337 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
3338 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3339 link->dst->filter->name);
3340 if (link->dst->input_count > 1)
3341 av_log(NULL, AV_LOG_INFO, ":%s", link->dstpad->name);
3342 if (nb_filtergraphs > 1)
3343 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3344 av_log(NULL, AV_LOG_INFO, "\n");
3349 for (i = 0; i < nb_output_streams; i++) {
3350 ost = output_streams[i];
3352 if (ost->attachment_filename) {
3353 /* an attached file */
3354 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
3355 ost->attachment_filename, ost->file_index, ost->index);
3359 if (ost->filter && ost->filter->graph->graph_desc) {
3360 /* output from a complex graph */
3361 AVFilterLink *link = ost->filter->filter->inputs[0];
3362 av_log(NULL, AV_LOG_INFO, " %s", link->src->filter->name);
3363 if (link->src->output_count > 1)
3364 av_log(NULL, AV_LOG_INFO, ":%s", link->srcpad->name);
3365 if (nb_filtergraphs > 1)
3366 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3368 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3369 ost->index, ost->enc ? ost->enc->name : "?");
3373 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
3374 input_streams[ost->source_index]->file_index,
3375 input_streams[ost->source_index]->st->index,
3378 if (ost->sync_ist != input_streams[ost->source_index])
3379 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3380 ost->sync_ist->file_index,
3381 ost->sync_ist->st->index);
3382 if (ost->stream_copy)
3383 av_log(NULL, AV_LOG_INFO, " (copy)");
3385 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3386 input_streams[ost->source_index]->dec->name : "?",
3387 ost->enc ? ost->enc->name : "?");
3388 av_log(NULL, AV_LOG_INFO, "\n");
3392 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3404 * The following code is the main loop of the file converter
3406 static int transcode(void)
3409 AVFormatContext *is, *os;
3413 int no_packet_count = 0;
3414 int64_t timer_start;
3417 if (!(no_packet = av_mallocz(nb_input_files)))
3420 ret = transcode_init();
3425 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3428 timer_start = av_gettime();
3430 for (; received_sigterm == 0;) {
3431 int file_index, ist_index, past_recording_time = 1;
3434 int64_t cur_time= av_gettime();
3436 ipts_min = INT64_MAX;
3437 /* if 'q' pressed, exits */
3439 static int64_t last_time;
3440 if (received_nb_signals)
3442 /* read_key() returns 0 on EOF */
3443 if(cur_time - last_time >= 100000 && !run_as_daemon){
3445 last_time = cur_time;
3450 if (key == '+') av_log_set_level(av_log_get_level()+10);
3451 if (key == '-') av_log_set_level(av_log_get_level()-10);
3452 if (key == 's') qp_hist ^= 1;
3455 do_hex_dump = do_pkt_dump = 0;
3456 } else if(do_pkt_dump){
3460 av_log_set_level(AV_LOG_DEBUG);
3462 if (key == 'c' || key == 'C'){
3463 char buf[4096], target[64], command[256], arg[256] = {0};
3466 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3468 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3473 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3474 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3475 target, time, command, arg);
3476 for (i = 0; i < nb_filtergraphs; i++) {
3477 FilterGraph *fg = filtergraphs[i];
3480 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3481 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3482 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3484 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3489 av_log(NULL, AV_LOG_ERROR,
3490 "Parse error, at least 3 arguments were expected, "
3491 "only %d given in string '%s'\n", n, buf);
3494 if (key == 'd' || key == 'D'){
3497 debug = input_streams[0]->st->codec->debug<<1;
3498 if(!debug) debug = 1;
3499 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3502 if(scanf("%d", &debug)!=1)
3503 fprintf(stderr,"error parsing debug value\n");
3504 for(i=0;i<nb_input_streams;i++) {
3505 input_streams[i]->st->codec->debug = debug;
3507 for(i=0;i<nb_output_streams;i++) {
3508 ost = output_streams[i];
3509 ost->st->codec->debug = debug;
3511 if(debug) av_log_set_level(AV_LOG_DEBUG);
3512 fprintf(stderr,"debug=%d\n", debug);
3515 fprintf(stderr, "key function\n"
3516 "? show this help\n"
3517 "+ increase verbosity\n"
3518 "- decrease verbosity\n"
3519 "c Send command to filtergraph\n"
3520 "D cycle through available debug modes\n"
3521 "h dump packets/hex press to cycle through the 3 states\n"
3523 "s Show QP histogram\n"
3528 /* check if there's any stream where output is still needed */
3529 for (i = 0; i < nb_output_streams; i++) {
3531 ost = output_streams[i];
3532 of = output_files[ost->file_index];
3533 os = output_files[ost->file_index]->ctx;
3534 if (ost->is_past_recording_time ||
3535 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3537 if (ost->frame_number >= ost->max_frames) {
3539 for (j = 0; j < of->ctx->nb_streams; j++)
3540 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3543 past_recording_time = 0;
3545 if (past_recording_time)
3548 /* select the stream that we must read now by looking at the
3549 smallest output pts */
3551 for (i = 0; i < nb_input_streams; i++) {
3553 ist = input_streams[i];
3555 if (ist->discard || no_packet[ist->file_index])
3557 if (!input_files[ist->file_index]->eof_reached) {
3558 if (ipts < ipts_min) {
3560 file_index = ist->file_index;
3564 /* if none, if is finished */
3565 if (file_index < 0) {
3566 if (no_packet_count) {
3567 no_packet_count = 0;
3568 memset(no_packet, 0, nb_input_files);
3575 /* read a frame from it and output it in the fifo */
3576 is = input_files[file_index]->ctx;
3577 ret = av_read_frame(is, &pkt);
3578 if (ret == AVERROR(EAGAIN)) {
3579 no_packet[file_index] = 1;
3584 input_files[file_index]->eof_reached = 1;
3586 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3587 ist = input_streams[input_files[file_index]->ist_index + i];
3588 if (ist->decoding_needed)
3589 output_packet(ist, NULL);
3598 no_packet_count = 0;
3599 memset(no_packet, 0, nb_input_files);
3602 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3603 is->streams[pkt.stream_index]);
3605 /* the following test is needed in case new streams appear
3606 dynamically in stream : we ignore them */
3607 if (pkt.stream_index >= input_files[file_index]->nb_streams)
3608 goto discard_packet;
3609 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3610 ist = input_streams[ist_index];
3612 goto discard_packet;
3614 if (pkt.dts != AV_NOPTS_VALUE)
3615 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3616 if (pkt.pts != AV_NOPTS_VALUE)
3617 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3619 if (pkt.pts != AV_NOPTS_VALUE)
3620 pkt.pts *= ist->ts_scale;
3621 if (pkt.dts != AV_NOPTS_VALUE)
3622 pkt.dts *= ist->ts_scale;
3625 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3626 "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",
3627 ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3628 av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &ist->st->time_base),
3629 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3630 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3631 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3632 input_files[ist->file_index]->ts_offset);
3635 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3636 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3637 int64_t delta = pkt_dts - ist->next_dts;
3638 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3639 if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3640 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3641 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3642 pkt_dts+1<ist->pts){
3643 input_files[ist->file_index]->ts_offset -= delta;
3644 av_log(NULL, AV_LOG_DEBUG,
3645 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3646 delta, input_files[ist->file_index]->ts_offset);
3647 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3648 if (pkt.pts != AV_NOPTS_VALUE)
3649 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3652 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3653 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3654 pkt_dts+1<ist->pts){
3655 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3656 pkt.dts = AV_NOPTS_VALUE;
3658 if (pkt.pts != AV_NOPTS_VALUE){
3659 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3660 delta = pkt_pts - ist->next_dts;
3661 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3662 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3663 pkt_pts+1<ist->pts) {
3664 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3665 pkt.pts = AV_NOPTS_VALUE;
3671 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3672 if (output_packet(ist, &pkt) < 0 ||
3673 ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3674 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3675 ist->file_index, ist->st->index);
3678 av_free_packet(&pkt);
3683 av_free_packet(&pkt);
3685 /* dump report by using the output first video and audio streams */
3686 print_report(0, timer_start, cur_time);
3689 /* at the end of stream, we must flush the decoder buffers */
3690 for (i = 0; i < nb_input_streams; i++) {
3691 ist = input_streams[i];
3692 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3693 output_packet(ist, NULL);
3701 /* write the trailer if needed and close file */
3702 for (i = 0; i < nb_output_files; i++) {
3703 os = output_files[i]->ctx;
3704 av_write_trailer(os);
3707 /* dump report by using the first video and audio streams */
3708 print_report(1, timer_start, av_gettime());
3710 /* close each encoder */
3711 for (i = 0; i < nb_output_streams; i++) {
3712 ost = output_streams[i];
3713 if (ost->encoding_needed) {
3714 av_freep(&ost->st->codec->stats_in);
3715 avcodec_close(ost->st->codec);
3719 /* close each decoder */
3720 for (i = 0; i < nb_input_streams; i++) {
3721 ist = input_streams[i];
3722 if (ist->decoding_needed) {
3723 avcodec_close(ist->st->codec);
3731 av_freep(&no_packet);
3733 if (output_streams) {
3734 for (i = 0; i < nb_output_streams; i++) {
3735 ost = output_streams[i];
3737 if (ost->stream_copy)
3738 av_freep(&ost->st->codec->extradata);
3740 fclose(ost->logfile);
3741 ost->logfile = NULL;
3743 av_freep(&ost->st->codec->subtitle_header);
3744 av_free(ost->forced_kf_pts);
3745 av_dict_free(&ost->opts);
3752 static int opt_frame_crop(const char *opt, const char *arg)
3754 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3755 return AVERROR(EINVAL);
3758 static int opt_pad(const char *opt, const char *arg)
3760 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3764 static int opt_video_channel(const char *opt, const char *arg)
3766 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3767 return opt_default("channel", arg);
3770 static int opt_video_standard(const char *opt, const char *arg)
3772 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3773 return opt_default("standard", arg);
3776 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3778 audio_codec_name = arg;
3779 return parse_option(o, "codec:a", arg, options);
3782 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3784 video_codec_name = arg;
3785 return parse_option(o, "codec:v", arg, options);
3788 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3790 subtitle_codec_name = arg;
3791 return parse_option(o, "codec:s", arg, options);
3794 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3796 return parse_option(o, "codec:d", arg, options);
3799 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3801 StreamMap *m = NULL;
3802 int i, negative = 0, file_idx;
3803 int sync_file_idx = -1, sync_stream_idx = 0;
3811 map = av_strdup(arg);
3813 /* parse sync stream first, just pick first matching stream */
3814 if (sync = strchr(map, ',')) {
3816 sync_file_idx = strtol(sync + 1, &sync, 0);
3817 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3818 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3823 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3824 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3825 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3826 sync_stream_idx = i;
3829 if (i == input_files[sync_file_idx]->nb_streams) {
3830 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3831 "match any streams.\n", arg);
3837 if (map[0] == '[') {
3838 /* this mapping refers to lavfi output */
3839 const char *c = map + 1;
3840 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3841 &o->nb_stream_maps, o->nb_stream_maps + 1);
3842 m = &o->stream_maps[o->nb_stream_maps - 1];
3843 m->linklabel = av_get_token(&c, "]");
3844 if (!m->linklabel) {
3845 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3849 file_idx = strtol(map, &p, 0);
3850 if (file_idx >= nb_input_files || file_idx < 0) {
3851 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3855 /* disable some already defined maps */
3856 for (i = 0; i < o->nb_stream_maps; i++) {
3857 m = &o->stream_maps[i];
3858 if (file_idx == m->file_index &&
3859 check_stream_specifier(input_files[m->file_index]->ctx,
3860 input_files[m->file_index]->ctx->streams[m->stream_index],
3861 *p == ':' ? p + 1 : p) > 0)
3865 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3866 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3867 *p == ':' ? p + 1 : p) <= 0)
3869 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3870 &o->nb_stream_maps, o->nb_stream_maps + 1);
3871 m = &o->stream_maps[o->nb_stream_maps - 1];
3873 m->file_index = file_idx;
3874 m->stream_index = i;
3876 if (sync_file_idx >= 0) {
3877 m->sync_file_index = sync_file_idx;
3878 m->sync_stream_index = sync_stream_idx;
3880 m->sync_file_index = file_idx;
3881 m->sync_stream_index = i;
3887 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3895 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3897 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3898 &o->nb_attachments, o->nb_attachments + 1);
3899 o->attachments[o->nb_attachments - 1] = arg;
3903 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3909 o->audio_channel_maps =
3910 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3911 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3912 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3914 /* muted channel syntax */
3915 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3916 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3917 m->file_idx = m->stream_idx = -1;
3919 m->ofile_idx = m->ostream_idx = -1;
3924 n = sscanf(arg, "%d.%d.%d:%d.%d",
3925 &m->file_idx, &m->stream_idx, &m->channel_idx,
3926 &m->ofile_idx, &m->ostream_idx);
3928 if (n != 3 && n != 5) {
3929 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3930 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3934 if (n != 5) // only file.stream.channel specified
3935 m->ofile_idx = m->ostream_idx = -1;
3938 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3939 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3943 if (m->stream_idx < 0 ||
3944 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
3945 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3946 m->file_idx, m->stream_idx);
3949 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
3950 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3951 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3952 m->file_idx, m->stream_idx);
3955 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3956 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3957 m->file_idx, m->stream_idx, m->channel_idx);
3964 * Parse a metadata specifier in arg.
3965 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3966 * @param index for type c/p, chapter/program index is written here
3967 * @param stream_spec for type s, the stream specifier is written here
3969 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3977 if (*(++arg) && *arg != ':') {
3978 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3981 *stream_spec = *arg == ':' ? arg + 1 : "";
3985 if (*(++arg) == ':')
3986 *index = strtol(++arg, NULL, 0);
3989 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3996 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3998 AVDictionary **meta_in = NULL;
3999 AVDictionary **meta_out = NULL;
4001 char type_in, type_out;
4002 const char *istream_spec = NULL, *ostream_spec = NULL;
4003 int idx_in = 0, idx_out = 0;
4005 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
4006 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
4009 if (type_out == 'g' || !*outspec)
4010 o->metadata_global_manual = 1;
4011 if (type_out == 's' || !*outspec)
4012 o->metadata_streams_manual = 1;
4013 if (type_out == 'c' || !*outspec)
4014 o->metadata_chapters_manual = 1;
4018 if (type_in == 'g' || type_out == 'g')
4019 o->metadata_global_manual = 1;
4020 if (type_in == 's' || type_out == 's')
4021 o->metadata_streams_manual = 1;
4022 if (type_in == 'c' || type_out == 'c')
4023 o->metadata_chapters_manual = 1;
4025 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4026 if ((index) < 0 || (index) >= (nb_elems)) {\
4027 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
4032 #define SET_DICT(type, meta, context, index)\
4035 meta = &context->metadata;\
4038 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
4039 meta = &context->chapters[index]->metadata;\
4042 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
4043 meta = &context->programs[index]->metadata;\
4047 SET_DICT(type_in, meta_in, ic, idx_in);
4048 SET_DICT(type_out, meta_out, oc, idx_out);
4050 /* for input streams choose first matching stream */
4051 if (type_in == 's') {
4052 for (i = 0; i < ic->nb_streams; i++) {
4053 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
4054 meta_in = &ic->streams[i]->metadata;
4060 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
4065 if (type_out == 's') {
4066 for (i = 0; i < oc->nb_streams; i++) {
4067 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
4068 meta_out = &oc->streams[i]->metadata;
4069 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4074 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4079 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
4082 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
4083 struct tm time = *gmtime((time_t*)&recording_timestamp);
4084 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
4085 parse_option(o, "metadata", buf, options);
4087 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
4088 "tag instead.\n", opt);
4092 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
4094 const char *codec_string = encoder ? "encoder" : "decoder";
4098 avcodec_find_encoder_by_name(name) :
4099 avcodec_find_decoder_by_name(name);
4101 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4104 if (codec->type != type) {
4105 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4111 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4113 char *codec_name = NULL;
4115 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4117 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4118 st->codec->codec_id = codec->id;
4121 return avcodec_find_decoder(st->codec->codec_id);
4125 * Add all the streams from the given input file to the global
4126 * list of input streams.
4128 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4131 char *next, *codec_tag = NULL;
4133 for (i = 0; i < ic->nb_streams; i++) {
4134 AVStream *st = ic->streams[i];
4135 AVCodecContext *dec = st->codec;
4136 InputStream *ist = av_mallocz(sizeof(*ist));
4141 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4142 input_streams[nb_input_streams - 1] = ist;
4145 ist->file_index = nb_input_files;
4147 st->discard = AVDISCARD_ALL;
4148 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
4150 ist->ts_scale = 1.0;
4151 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4153 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4155 uint32_t tag = strtol(codec_tag, &next, 0);
4157 tag = AV_RL32(codec_tag);
4158 st->codec->codec_tag = tag;
4161 ist->dec = choose_decoder(o, ic, st);
4163 switch (dec->codec_type) {
4164 case AVMEDIA_TYPE_VIDEO:
4166 ist->dec = avcodec_find_decoder(dec->codec_id);
4168 dec->flags |= CODEC_FLAG_EMU_EDGE;
4171 ist->resample_height = dec->height;
4172 ist->resample_width = dec->width;
4173 ist->resample_pix_fmt = dec->pix_fmt;
4176 case AVMEDIA_TYPE_AUDIO:
4177 guess_input_channel_layout(ist);
4179 ist->resample_sample_fmt = dec->sample_fmt;
4180 ist->resample_sample_rate = dec->sample_rate;
4181 ist->resample_channels = dec->channels;
4182 ist->resample_channel_layout = dec->channel_layout;
4185 case AVMEDIA_TYPE_DATA:
4186 case AVMEDIA_TYPE_SUBTITLE:
4188 ist->dec = avcodec_find_decoder(dec->codec_id);
4190 case AVMEDIA_TYPE_ATTACHMENT:
4191 case AVMEDIA_TYPE_UNKNOWN:
4199 static void assert_file_overwrite(const char *filename)
4201 if ((!file_overwrite || no_file_overwrite) &&
4202 (strchr(filename, ':') == NULL || filename[1] == ':' ||
4203 av_strstart(filename, "file:", NULL))) {
4204 if (avio_check(filename, 0) == 0) {
4205 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
4206 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4209 signal(SIGINT, SIG_DFL);
4210 if (!read_yesno()) {
4211 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4217 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4224 static void dump_attachment(AVStream *st, const char *filename)
4227 AVIOContext *out = NULL;
4228 AVDictionaryEntry *e;
4230 if (!st->codec->extradata_size) {
4231 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4232 nb_input_files - 1, st->index);
4235 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4236 filename = e->value;
4238 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4239 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4243 assert_file_overwrite(filename);
4245 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4246 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4251 avio_write(out, st->codec->extradata, st->codec->extradata_size);
4256 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4258 AVFormatContext *ic;
4259 AVInputFormat *file_iformat = NULL;
4263 AVDictionary **opts;
4264 int orig_nb_streams; // number of streams before avformat_find_stream_info
4267 if (!(file_iformat = av_find_input_format(o->format))) {
4268 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4273 if (!strcmp(filename, "-"))
4276 using_stdin |= !strncmp(filename, "pipe:", 5) ||
4277 !strcmp(filename, "/dev/stdin");
4279 /* get default parameters from command line */
4280 ic = avformat_alloc_context();
4282 print_error(filename, AVERROR(ENOMEM));
4285 if (o->nb_audio_sample_rate) {
4286 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4287 av_dict_set(&format_opts, "sample_rate", buf, 0);
4289 if (o->nb_audio_channels) {
4290 /* because we set audio_channels based on both the "ac" and
4291 * "channel_layout" options, we need to check that the specified
4292 * demuxer actually has the "channels" option before setting it */
4293 if (file_iformat && file_iformat->priv_class &&
4294 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4295 AV_OPT_SEARCH_FAKE_OBJ)) {
4296 snprintf(buf, sizeof(buf), "%d",
4297 o->audio_channels[o->nb_audio_channels - 1].u.i);
4298 av_dict_set(&format_opts, "channels", buf, 0);
4301 if (o->nb_frame_rates) {
4302 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4304 if (o->nb_frame_sizes) {
4305 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4307 if (o->nb_frame_pix_fmts)
4308 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4310 ic->video_codec_id = video_codec_name ?
4311 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
4312 ic->audio_codec_id = audio_codec_name ?
4313 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
4314 ic->subtitle_codec_id= subtitle_codec_name ?
4315 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4316 ic->flags |= AVFMT_FLAG_NONBLOCK;
4317 ic->interrupt_callback = int_cb;
4319 /* open the input file with generic avformat function */
4320 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4322 print_error(filename, err);
4325 assert_avoptions(format_opts);
4327 /* apply forced codec ids */
4328 for (i = 0; i < ic->nb_streams; i++)
4329 choose_decoder(o, ic, ic->streams[i]);
4331 /* Set AVCodecContext options for avformat_find_stream_info */
4332 opts = setup_find_stream_info_opts(ic, codec_opts);
4333 orig_nb_streams = ic->nb_streams;
4335 /* If not enough info to get the stream parameters, we decode the
4336 first frames to get it. (used in mpeg case for example) */
4337 ret = avformat_find_stream_info(ic, opts);
4339 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4340 avformat_close_input(&ic);
4344 timestamp = o->start_time;
4345 /* add the stream start time */
4346 if (ic->start_time != AV_NOPTS_VALUE)
4347 timestamp += ic->start_time;
4349 /* if seeking requested, we execute it */
4350 if (o->start_time != 0) {
4351 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4353 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4354 filename, (double)timestamp / AV_TIME_BASE);
4358 /* update the current parameters so that they match the one of the input stream */
4359 add_input_streams(o, ic);
4361 /* dump the file content */
4362 av_dump_format(ic, nb_input_files, filename, 0);
4364 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4365 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4368 input_files[nb_input_files - 1]->ctx = ic;
4369 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
4370 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4371 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4372 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
4374 for (i = 0; i < o->nb_dump_attachment; i++) {
4377 for (j = 0; j < ic->nb_streams; j++) {
4378 AVStream *st = ic->streams[j];
4380 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4381 dump_attachment(st, o->dump_attachment[i].u.str);
4385 for (i = 0; i < orig_nb_streams; i++)
4386 av_dict_free(&opts[i]);
4389 reset_options(o, 1);
4393 static void parse_forced_key_frames(char *kf, OutputStream *ost)
4398 for (p = kf; *p; p++)
4401 ost->forced_kf_count = n;
4402 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
4403 if (!ost->forced_kf_pts) {
4404 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
4408 for (i = 0; i < n; i++) {
4409 char *next = strchr(p, ',');
4410 if (next) *next++ = 0;
4411 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
4416 static uint8_t *get_line(AVIOContext *s)
4422 if (avio_open_dyn_buf(&line) < 0) {
4423 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4427 while ((c = avio_r8(s)) && c != '\n')
4430 avio_close_dyn_buf(line, &buf);
4435 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4438 char filename[1000];
4439 const char *base[3] = { getenv("AVCONV_DATADIR"),
4444 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4448 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4449 i != 1 ? "" : "/.avconv", codec_name, preset_name);
4450 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4453 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4454 i != 1 ? "" : "/.avconv", preset_name);
4455 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4461 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4463 char *codec_name = NULL;
4465 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4467 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4468 NULL, ost->st->codec->codec_type);
4469 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4470 } else if (!strcmp(codec_name, "copy"))
4471 ost->stream_copy = 1;
4473 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4474 ost->st->codec->codec_id = ost->enc->id;
4478 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4481 AVStream *st = avformat_new_stream(oc, NULL);
4482 int idx = oc->nb_streams - 1, ret = 0;
4483 char *bsf = NULL, *next, *codec_tag = NULL;
4484 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4486 char *buf = NULL, *arg = NULL, *preset = NULL;
4487 AVIOContext *s = NULL;
4490 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4494 if (oc->nb_streams - 1 < o->nb_streamid_map)
4495 st->id = o->streamid_map[oc->nb_streams - 1];
4497 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4498 nb_output_streams + 1);
4499 if (!(ost = av_mallocz(sizeof(*ost))))
4501 output_streams[nb_output_streams - 1] = ost;
4503 ost->file_index = nb_output_files;
4506 st->codec->codec_type = type;
4507 choose_encoder(o, oc, ost);
4509 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
4512 avcodec_get_context_defaults3(st->codec, ost->enc);
4513 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4515 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4516 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4519 if (!buf[0] || buf[0] == '#') {
4523 if (!(arg = strchr(buf, '='))) {
4524 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4528 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4530 } while (!s->eof_reached);
4534 av_log(NULL, AV_LOG_FATAL,
4535 "Preset %s specified for stream %d:%d, but could not be opened.\n",
4536 preset, ost->file_index, ost->index);
4540 ost->max_frames = INT64_MAX;
4541 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4543 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4545 if (next = strchr(bsf, ','))
4547 if (!(bsfc = av_bitstream_filter_init(bsf))) {
4548 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4552 bsfc_prev->next = bsfc;
4554 ost->bitstream_filters = bsfc;
4560 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4562 uint32_t tag = strtol(codec_tag, &next, 0);
4564 tag = AV_RL32(codec_tag);
4565 st->codec->codec_tag = tag;
4568 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4569 if (qscale >= 0 || same_quant) {
4570 st->codec->flags |= CODEC_FLAG_QSCALE;
4571 st->codec->global_quality = FF_QP2LAMBDA * qscale;
4574 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4575 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4577 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4578 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4579 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4581 ost->source_index = source_index;
4582 if (source_index >= 0) {
4583 ost->sync_ist = input_streams[source_index];
4584 input_streams[source_index]->discard = 0;
4585 input_streams[source_index]->st->discard = AVDISCARD_NONE;
4591 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4594 const char *p = str;
4601 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4608 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4612 AVCodecContext *video_enc;
4614 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4616 video_enc = st->codec;
4618 if (!ost->stream_copy) {
4619 const char *p = NULL;
4620 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
4621 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4622 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
4625 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4626 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4627 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4631 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4632 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4633 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4637 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4638 if (frame_aspect_ratio) {
4640 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4641 q.num <= 0 || q.den <= 0) {
4642 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4645 ost->frame_aspect_ratio = av_q2d(q);
4648 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4649 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4650 if (frame_pix_fmt && *frame_pix_fmt == '+') {
4651 ost->keep_pix_fmt = 1;
4652 if (!*++frame_pix_fmt)
4653 frame_pix_fmt = NULL;
4655 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4656 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4659 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4662 video_enc->gop_size = 0;
4663 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4665 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4666 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4669 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4671 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4673 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4674 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4677 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4680 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4681 for (i = 0; p; i++) {
4683 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4685 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4688 /* FIXME realloc failure */
4689 video_enc->rc_override =
4690 av_realloc(video_enc->rc_override,
4691 sizeof(RcOverride) * (i + 1));
4692 video_enc->rc_override[i].start_frame = start;
4693 video_enc->rc_override[i].end_frame = end;
4695 video_enc->rc_override[i].qscale = q;
4696 video_enc->rc_override[i].quality_factor = 1.0;
4699 video_enc->rc_override[i].qscale = 0;
4700 video_enc->rc_override[i].quality_factor = -q/100.0;
4705 video_enc->rc_override_count = i;
4706 if (!video_enc->rc_initial_buffer_occupancy)
4707 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4708 video_enc->intra_dc_precision = intra_dc_precision - 8;
4711 video_enc->flags|= CODEC_FLAG_PSNR;
4716 video_enc->flags |= CODEC_FLAG_PASS1;
4719 video_enc->flags |= CODEC_FLAG_PASS2;
4723 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4724 if (forced_key_frames)
4725 parse_forced_key_frames(forced_key_frames, ost);
4727 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4729 ost->top_field_first = -1;
4730 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4732 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4734 ost->avfilter = av_strdup(filters);
4736 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4742 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4747 AVCodecContext *audio_enc;
4749 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4752 audio_enc = st->codec;
4753 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4755 if (!ost->stream_copy) {
4756 char *sample_fmt = NULL, *filters = NULL;
4758 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4760 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4762 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4763 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4767 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4769 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4771 ost->avfilter = av_strdup(filters);
4773 /* check for channel mapping for this audio stream */
4774 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4775 AudioChannelMap *map = &o->audio_channel_maps[n];
4776 InputStream *ist = input_streams[ost->source_index];
4777 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4778 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4779 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4780 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4781 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4783 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4784 ost->file_index, ost->st->index);
4792 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4796 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4797 if (!ost->stream_copy) {
4798 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4805 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4807 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4808 ost->stream_copy = 1;
4812 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4816 AVCodecContext *subtitle_enc;
4818 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4820 subtitle_enc = st->codec;
4822 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4824 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4829 /* arg format is "output-stream-index:streamid-value". */
4830 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4836 av_strlcpy(idx_str, arg, sizeof(idx_str));
4837 p = strchr(idx_str, ':');
4839 av_log(NULL, AV_LOG_FATAL,
4840 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4845 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4846 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4847 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4851 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4853 AVFormatContext *is = ifile->ctx;
4854 AVFormatContext *os = ofile->ctx;
4857 for (i = 0; i < is->nb_chapters; i++) {
4858 AVChapter *in_ch = is->chapters[i], *out_ch;
4859 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4860 AV_TIME_BASE_Q, in_ch->time_base);
4861 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4862 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4865 if (in_ch->end < ts_off)
4867 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4870 out_ch = av_mallocz(sizeof(AVChapter));
4872 return AVERROR(ENOMEM);
4874 out_ch->id = in_ch->id;
4875 out_ch->time_base = in_ch->time_base;
4876 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4877 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4880 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4883 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4885 return AVERROR(ENOMEM);
4886 os->chapters[os->nb_chapters - 1] = out_ch;
4891 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4894 AVFormatContext *ic = avformat_alloc_context();
4896 ic->interrupt_callback = int_cb;
4897 err = avformat_open_input(&ic, filename, NULL, NULL);
4900 /* copy stream format */
4901 for(i=0;i<ic->nb_streams;i++) {
4905 AVCodecContext *avctx;
4907 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4908 ost = new_output_stream(o, s, codec->type, -1);
4913 // FIXME: a more elegant solution is needed
4914 memcpy(st, ic->streams[i], sizeof(AVStream));
4916 st->info = av_malloc(sizeof(*st->info));
4917 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4919 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4921 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4922 choose_sample_fmt(st, codec);
4923 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4924 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4927 avformat_close_input(&ic);
4931 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4932 AVFormatContext *oc)
4936 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4937 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
4938 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
4940 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
4945 ost->source_index = -1;
4946 ost->filter = ofilter;
4950 if (ost->stream_copy) {
4951 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4952 "which is fed from a complex filtergraph. Filtering and streamcopy "
4953 "cannot be used together.\n", ost->file_index, ost->index);
4957 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4958 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4961 avfilter_inout_free(&ofilter->out_tmp);
4964 static void opt_output_file(void *optctx, const char *filename)
4966 OptionsContext *o = optctx;
4967 AVFormatContext *oc;
4969 AVOutputFormat *file_oformat;
4973 if (configure_complex_filters() < 0) {
4974 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4978 if (!strcmp(filename, "-"))
4981 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4983 print_error(filename, err);
4986 file_oformat= oc->oformat;
4987 oc->interrupt_callback = int_cb;
4989 /* create streams for all unlabeled output pads */
4990 for (i = 0; i < nb_filtergraphs; i++) {
4991 FilterGraph *fg = filtergraphs[i];
4992 for (j = 0; j < fg->nb_outputs; j++) {
4993 OutputFilter *ofilter = fg->outputs[j];
4995 if (!ofilter->out_tmp || ofilter->out_tmp->name)
4998 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4999 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
5000 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
5001 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
5003 init_output_filter(ofilter, o, oc);
5007 if (!strcmp(file_oformat->name, "ffm") &&
5008 av_strstart(filename, "http:", NULL)) {
5010 /* special case for files sent to ffserver: we get the stream
5011 parameters from ffserver */
5012 int err = read_ffserver_streams(o, oc, filename);
5014 print_error(filename, err);
5017 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
5018 ost = output_streams[j];
5019 for (i = 0; i < nb_input_streams; i++) {
5020 ist = input_streams[i];
5021 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
5023 ost->source_index= i;
5025 ist->st->discard = AVDISCARD_NONE;
5030 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));
5034 } else if (!o->nb_stream_maps) {
5035 /* pick the "best" stream of each type */
5037 /* video: highest resolution */
5038 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
5039 int area = 0, idx = -1;
5040 for (i = 0; i < nb_input_streams; i++) {
5041 ist = input_streams[i];
5042 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
5043 ist->st->codec->width * ist->st->codec->height > area) {
5044 area = ist->st->codec->width * ist->st->codec->height;
5049 new_video_stream(o, oc, idx);
5052 /* audio: most channels */
5053 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
5054 int channels = 0, idx = -1;
5055 for (i = 0; i < nb_input_streams; i++) {
5056 ist = input_streams[i];
5057 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
5058 ist->st->codec->channels > channels) {
5059 channels = ist->st->codec->channels;
5064 new_audio_stream(o, oc, idx);
5067 /* subtitles: pick first */
5068 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
5069 for (i = 0; i < nb_input_streams; i++)
5070 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
5071 new_subtitle_stream(o, oc, i);
5075 /* do something with data? */
5077 for (i = 0; i < o->nb_stream_maps; i++) {
5078 StreamMap *map = &o->stream_maps[i];
5079 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5084 if (map->linklabel) {
5086 OutputFilter *ofilter = NULL;
5089 for (j = 0; j < nb_filtergraphs; j++) {
5090 fg = filtergraphs[j];
5091 for (k = 0; k < fg->nb_outputs; k++) {
5092 AVFilterInOut *out = fg->outputs[k]->out_tmp;
5093 if (out && !strcmp(out->name, map->linklabel)) {
5094 ofilter = fg->outputs[k];
5101 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5102 "in any defined filter graph.\n", map->linklabel);
5105 init_output_filter(ofilter, o, oc);
5107 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5108 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5110 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5112 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5114 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5117 switch (ist->st->codec->codec_type) {
5118 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
5119 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
5120 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
5121 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
5122 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5124 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5125 map->file_index, map->stream_index);
5133 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5134 AVDictionaryEntry *e;
5135 ost = output_streams[i];
5137 if ( ost->stream_copy
5138 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5139 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5140 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5144 /* handle attached files */
5145 for (i = 0; i < o->nb_attachments; i++) {
5147 uint8_t *attachment;
5151 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5152 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5156 if ((len = avio_size(pb)) <= 0) {
5157 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5161 if (!(attachment = av_malloc(len))) {
5162 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5166 avio_read(pb, attachment, len);
5168 ost = new_attachment_stream(o, oc, -1);
5169 ost->stream_copy = 0;
5170 ost->attachment_filename = o->attachments[i];
5171 ost->st->codec->extradata = attachment;
5172 ost->st->codec->extradata_size = len;
5174 p = strrchr(o->attachments[i], '/');
5175 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5179 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5180 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5183 output_files[nb_output_files - 1]->ctx = oc;
5184 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
5185 output_files[nb_output_files - 1]->recording_time = o->recording_time;
5186 if (o->recording_time != INT64_MAX)
5187 oc->duration = o->recording_time;
5188 output_files[nb_output_files - 1]->start_time = o->start_time;
5189 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5190 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5192 /* check filename in case of an image number is expected */
5193 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5194 if (!av_filename_number_test(oc->filename)) {
5195 print_error(oc->filename, AVERROR(EINVAL));
5200 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5201 /* test if it already exists to avoid losing precious files */
5202 assert_file_overwrite(filename);
5205 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5206 &oc->interrupt_callback,
5207 &output_files[nb_output_files - 1]->opts)) < 0) {
5208 print_error(filename, err);
5213 if (o->mux_preload) {
5215 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5216 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5218 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5221 for (i = 0; i < o->nb_metadata_map; i++) {
5223 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5225 if (in_file_index >= nb_input_files) {
5226 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5229 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5233 if (o->chapters_input_file >= nb_input_files) {
5234 if (o->chapters_input_file == INT_MAX) {
5235 /* copy chapters from the first input file that has them*/
5236 o->chapters_input_file = -1;
5237 for (i = 0; i < nb_input_files; i++)
5238 if (input_files[i]->ctx->nb_chapters) {
5239 o->chapters_input_file = i;
5243 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5244 o->chapters_input_file);
5248 if (o->chapters_input_file >= 0)
5249 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5250 !o->metadata_chapters_manual);
5252 /* copy global metadata by default */
5253 if (!o->metadata_global_manual && nb_input_files){
5254 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5255 AV_DICT_DONT_OVERWRITE);
5256 if(o->recording_time != INT64_MAX)
5257 av_dict_set(&oc->metadata, "duration", NULL, 0);
5259 if (!o->metadata_streams_manual)
5260 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5262 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
5264 ist = input_streams[output_streams[i]->source_index];
5265 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5268 /* process manually set metadata */
5269 for (i = 0; i < o->nb_metadata; i++) {
5272 const char *stream_spec;
5273 int index = 0, j, ret = 0;
5275 val = strchr(o->metadata[i].u.str, '=');
5277 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5278 o->metadata[i].u.str);
5283 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5285 for (j = 0; j < oc->nb_streams; j++) {
5286 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5287 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5291 printf("ret %d, stream_spec %s\n", ret, stream_spec);
5299 if (index < 0 || index >= oc->nb_chapters) {
5300 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5303 m = &oc->chapters[index]->metadata;
5306 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5309 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5313 reset_options(o, 0);
5316 /* same option as mencoder */
5317 static int opt_pass(const char *opt, const char *arg)
5319 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5323 static int64_t getmaxrss(void)
5325 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5326 struct rusage rusage;
5327 getrusage(RUSAGE_SELF, &rusage);
5328 return (int64_t)rusage.ru_maxrss * 1024;
5329 #elif HAVE_GETPROCESSMEMORYINFO
5331 PROCESS_MEMORY_COUNTERS memcounters;
5332 proc = GetCurrentProcess();
5333 memcounters.cb = sizeof(memcounters);
5334 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5335 return memcounters.PeakPagefileUsage;
5341 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5343 return parse_option(o, "q:a", arg, options);
5346 static void show_usage(void)
5348 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5349 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5350 av_log(NULL, AV_LOG_INFO, "\n");
5353 static int opt_help(const char *opt, const char *arg)
5355 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5356 av_log_set_callback(log_callback_help);
5358 show_help_options(options, "Main options:\n",
5359 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5360 show_help_options(options, "\nAdvanced options:\n",
5361 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5363 show_help_options(options, "\nVideo options:\n",
5364 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5366 show_help_options(options, "\nAdvanced Video options:\n",
5367 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5368 OPT_VIDEO | OPT_EXPERT);
5369 show_help_options(options, "\nAudio options:\n",
5370 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5372 show_help_options(options, "\nAdvanced Audio options:\n",
5373 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5374 OPT_AUDIO | OPT_EXPERT);
5375 show_help_options(options, "\nSubtitle options:\n",
5376 OPT_SUBTITLE | OPT_GRAB,
5378 show_help_options(options, "\nAudio/Video grab options:\n",
5382 show_help_children(avcodec_get_class(), flags);
5383 show_help_children(avformat_get_class(), flags);
5384 show_help_children(sws_get_class(), flags);
5389 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5391 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5392 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5394 if (!strncmp(arg, "pal-", 4)) {
5397 } else if (!strncmp(arg, "ntsc-", 5)) {
5400 } else if (!strncmp(arg, "film-", 5)) {
5404 /* Try to determine PAL/NTSC by peeking in the input files */
5405 if (nb_input_files) {
5407 for (j = 0; j < nb_input_files; j++) {
5408 for (i = 0; i < input_files[j]->nb_streams; i++) {
5409 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5410 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5412 fr = c->time_base.den * 1000 / c->time_base.num;
5416 } else if ((fr == 29970) || (fr == 23976)) {
5421 if (norm != UNKNOWN)
5425 if (norm != UNKNOWN)
5426 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5429 if (norm == UNKNOWN) {
5430 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5431 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5432 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5436 if (!strcmp(arg, "vcd")) {
5437 opt_video_codec(o, "c:v", "mpeg1video");
5438 opt_audio_codec(o, "c:a", "mp2");
5439 parse_option(o, "f", "vcd", options);
5441 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5442 parse_option(o, "r", frame_rates[norm], options);
5443 opt_default("g", norm == PAL ? "15" : "18");
5445 opt_default("b:v", "1150000");
5446 opt_default("maxrate", "1150000");
5447 opt_default("minrate", "1150000");
5448 opt_default("bufsize", "327680"); // 40*1024*8;
5450 opt_default("b:a", "224000");
5451 parse_option(o, "ar", "44100", options);
5452 parse_option(o, "ac", "2", options);
5454 opt_default("packetsize", "2324");
5455 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5457 /* We have to offset the PTS, so that it is consistent with the SCR.
5458 SCR starts at 36000, but the first two packs contain only padding
5459 and the first pack from the other stream, respectively, may also have
5460 been written before.
5461 So the real data starts at SCR 36000+3*1200. */
5462 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5463 } else if (!strcmp(arg, "svcd")) {
5465 opt_video_codec(o, "c:v", "mpeg2video");
5466 opt_audio_codec(o, "c:a", "mp2");
5467 parse_option(o, "f", "svcd", options);
5469 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5470 parse_option(o, "r", frame_rates[norm], options);
5471 parse_option(o, "pix_fmt", "yuv420p", options);
5472 opt_default("g", norm == PAL ? "15" : "18");
5474 opt_default("b:v", "2040000");
5475 opt_default("maxrate", "2516000");
5476 opt_default("minrate", "0"); // 1145000;
5477 opt_default("bufsize", "1835008"); // 224*1024*8;
5478 opt_default("scan_offset", "1");
5481 opt_default("b:a", "224000");
5482 parse_option(o, "ar", "44100", options);
5484 opt_default("packetsize", "2324");
5486 } else if (!strcmp(arg, "dvd")) {
5488 opt_video_codec(o, "c:v", "mpeg2video");
5489 opt_audio_codec(o, "c:a", "ac3");
5490 parse_option(o, "f", "dvd", options);
5492 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5493 parse_option(o, "r", frame_rates[norm], options);
5494 parse_option(o, "pix_fmt", "yuv420p", options);
5495 opt_default("g", norm == PAL ? "15" : "18");
5497 opt_default("b:v", "6000000");
5498 opt_default("maxrate", "9000000");
5499 opt_default("minrate", "0"); // 1500000;
5500 opt_default("bufsize", "1835008"); // 224*1024*8;
5502 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5503 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5505 opt_default("b:a", "448000");
5506 parse_option(o, "ar", "48000", options);
5508 } else if (!strncmp(arg, "dv", 2)) {
5510 parse_option(o, "f", "dv", options);
5512 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5513 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5514 norm == PAL ? "yuv420p" : "yuv411p", options);
5515 parse_option(o, "r", frame_rates[norm], options);
5517 parse_option(o, "ar", "48000", options);
5518 parse_option(o, "ac", "2", options);
5521 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5522 return AVERROR(EINVAL);
5527 static int opt_vstats_file(const char *opt, const char *arg)
5529 av_free (vstats_filename);
5530 vstats_filename = av_strdup (arg);
5534 static int opt_vstats(const char *opt, const char *arg)
5537 time_t today2 = time(NULL);
5538 struct tm *today = localtime(&today2);
5540 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5542 return opt_vstats_file(opt, filename);
5545 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5547 return parse_option(o, "frames:v", arg, options);
5550 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5552 return parse_option(o, "frames:a", arg, options);
5555 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5557 return parse_option(o, "frames:d", arg, options);
5560 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5563 char filename[1000], line[1000], tmp_line[1000];
5564 const char *codec_name = *opt == 'v' ? video_codec_name :
5565 *opt == 'a' ? audio_codec_name :
5566 subtitle_codec_name;
5568 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5569 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5570 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5572 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5576 while (fgets(line, sizeof(line), f)) {
5577 char *key = tmp_line, *value, *endptr;
5579 if (strcspn(line, "#\n\r") == 0)
5581 strcpy(tmp_line, line);
5582 if (!av_strtok(key, "=", &value) ||
5583 !av_strtok(value, "\r\n", &endptr)) {
5584 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5587 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
5589 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
5590 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
5591 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
5592 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
5593 else if (opt_default(key, value) < 0) {
5594 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
5595 filename, line, key, value);
5605 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5609 static int opt_passlogfile(const char *opt, const char *arg)
5611 pass_logfilename_prefix = arg;
5612 #if CONFIG_LIBX264_ENCODER
5613 return opt_default(opt, arg);
5619 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5621 char *s = av_asprintf("%s:%c", opt + 1, *opt);
5622 int ret = parse_option(o, s, arg, options);
5627 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5629 if(!strcmp(opt, "b")){
5630 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5631 return parse_option(o, "b:v", arg, options);
5633 return opt_default(opt, arg);
5636 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5640 if(!strcmp(opt, "qscale")){
5641 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5642 return parse_option(o, "q:v", arg, options);
5644 s = av_asprintf("q%s", opt + 6);
5645 ret = parse_option(o, s, arg, options);
5650 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5652 if(!strcmp(opt, "profile")){
5653 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5654 return parse_option(o, "profile:v", arg, options);
5656 return opt_default(opt, arg);
5659 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5661 return parse_option(o, "filter:v", arg, options);
5664 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
5666 return parse_option(o, "filter:a", arg, options);
5669 static int opt_vsync(const char *opt, const char *arg)
5671 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
5672 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
5673 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5674 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
5676 if (video_sync_method == VSYNC_AUTO)
5677 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5681 static int opt_deinterlace(const char *opt, const char *arg)
5683 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5688 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5690 int idx = locate_option(argc, argv, options, "cpuflags");
5691 if (idx && argv[idx + 1])
5692 opt_cpuflags("cpuflags", argv[idx + 1]);
5695 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5697 char layout_str[32];
5700 int ret, channels, ac_str_size;
5703 layout = av_get_channel_layout(arg);
5705 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5706 return AVERROR(EINVAL);
5708 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5709 ret = opt_default(opt, layout_str);
5713 /* set 'ac' option based on channel layout */
5714 channels = av_get_channel_layout_nb_channels(layout);
5715 snprintf(layout_str, sizeof(layout_str), "%d", channels);
5716 stream_str = strchr(opt, ':');
5717 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5718 ac_str = av_mallocz(ac_str_size);
5720 return AVERROR(ENOMEM);
5721 av_strlcpy(ac_str, "ac", 3);
5723 av_strlcat(ac_str, stream_str, ac_str_size);
5724 ret = parse_option(o, ac_str, layout_str, options);
5730 static int opt_filter_complex(const char *opt, const char *arg)
5732 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5733 &nb_filtergraphs, nb_filtergraphs + 1);
5734 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5735 return AVERROR(ENOMEM);
5736 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
5737 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5741 #define OFFSET(x) offsetof(OptionsContext, x)
5742 static const OptionDef options[] = {
5744 #include "cmdutils_common_opts.h"
5745 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5746 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5747 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5748 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5749 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5750 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5751 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5752 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5753 { "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]" },
5754 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5755 "outfile[,metadata]:infile[,metadata]" },
5756 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
5757 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5758 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5759 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5760 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5761 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5762 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5763 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5764 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5765 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5766 "add timings for benchmarking" },
5767 { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5768 "add timings for each task" },
5769 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5770 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5771 "dump each input packet" },
5772 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5773 "when dumping packets, also dump the payload" },
5774 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5775 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5776 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5777 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5778 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5779 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
5780 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
5781 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5782 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5783 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5784 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5785 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5786 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5787 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5788 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5789 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5790 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5791 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5792 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5793 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5794 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5795 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5796 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5799 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5800 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5801 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5802 { "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" },
5803 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5804 { "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" },
5805 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5806 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5807 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5808 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5809 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5810 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5811 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5812 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5813 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5814 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5815 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5816 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5817 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5818 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5819 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5820 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5821 "use same quantizer as source (implies VBR)" },
5822 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5823 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5824 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5825 "this option is deprecated, use the yadif filter instead" },
5826 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5827 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5828 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5829 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5830 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5831 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5832 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5833 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5834 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5835 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5836 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5837 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5838 { "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" },
5839 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5842 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5843 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5844 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5845 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5846 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5847 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5848 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5849 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5850 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5851 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5852 { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
5854 /* subtitle options */
5855 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5856 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5857 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5860 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5861 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5862 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5865 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5866 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5868 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5869 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5870 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5872 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5873 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5874 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5875 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5876 /* data codec support */
5877 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5878 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5880 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5884 int main(int argc, char **argv)
5886 OptionsContext o = { 0 };
5889 reset_options(&o, 0);
5891 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5892 parse_loglevel(argc, argv, options);
5894 if(argc>1 && !strcmp(argv[1], "-d")){
5896 av_log_set_callback(log_callback_null);
5901 avcodec_register_all();
5903 avdevice_register_all();
5905 avfilter_register_all();
5907 avformat_network_init();
5909 show_banner(argc, argv, options);
5913 parse_cpuflags(argc, argv, options);
5916 parse_options(&o, argc, argv, options, opt_output_file);
5918 if (nb_output_files <= 0 && nb_input_files == 0) {
5920 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5924 /* file converter / grab */
5925 if (nb_output_files <= 0) {
5926 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5930 if (nb_input_files == 0) {
5931 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5935 current_time = ti = getutime();
5936 if (transcode() < 0)
5938 ti = getutime() - ti;
5940 int maxrss = getmaxrss() / 1024;
5941 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);