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 "libavutil/opt.h"
39 #include "libavutil/audioconvert.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/samplefmt.h"
42 #include "libavutil/colorspace.h"
43 #include "libavutil/fifo.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/dict.h"
46 #include "libavutil/mathematics.h"
47 #include "libavutil/pixdesc.h"
48 #include "libavutil/avstring.h"
49 #include "libavutil/libm.h"
50 #include "libavutil/imgutils.h"
51 #include "libavutil/timestamp.h"
52 #include "libavformat/os_support.h"
53 #include "libswresample/swresample.h"
55 #include "libavformat/ffm.h" // not public API
57 # include "libavfilter/avcodec.h"
58 # include "libavfilter/avfilter.h"
59 # include "libavfilter/avfiltergraph.h"
60 # include "libavfilter/buffersink.h"
61 # include "libavfilter/buffersrc.h"
63 #if HAVE_SYS_RESOURCE_H
64 #include <sys/types.h>
66 #include <sys/resource.h>
67 #elif HAVE_GETPROCESSTIMES
70 #if HAVE_GETPROCESSMEMORYINFO
76 #include <sys/select.h>
81 #include <sys/ioctl.h>
91 #include "libavutil/avassert.h"
94 #define VSYNC_PASSTHROUGH 0
97 #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 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 AVBitStreamFilterContext *bitstream_filters;
282 AVFrame *filtered_frame;
285 AVRational frame_rate;
289 float frame_aspect_ratio;
292 /* forced key frames */
293 int64_t *forced_kf_pts;
299 OutputFilter *filter;
303 int64_t swr_dither_method;
304 double swr_dither_scale;
306 int is_past_recording_time;
308 const char *attachment_filename;
309 int copy_initial_nonkeyframes;
311 enum PixelFormat pix_fmts[2];
318 /* init terminal so that we can grab keys */
319 static struct termios oldtty;
320 static int restore_tty;
323 typedef struct OutputFile {
324 AVFormatContext *ctx;
326 int ost_index; /* index of the first stream in output_streams */
327 int64_t recording_time; /* desired length of the resulting file in microseconds */
328 int64_t start_time; /* start time in microseconds */
329 uint64_t limit_filesize; /* filesize limit expressed in bytes */
332 static InputStream **input_streams = NULL;
333 static int nb_input_streams = 0;
334 static InputFile **input_files = NULL;
335 static int nb_input_files = 0;
337 static OutputStream **output_streams = NULL;
338 static int nb_output_streams = 0;
339 static OutputFile **output_files = NULL;
340 static int nb_output_files = 0;
342 static FilterGraph **filtergraphs;
345 typedef struct OptionsContext {
346 /* input/output options */
350 SpecifierOpt *codec_names;
352 SpecifierOpt *audio_channels;
353 int nb_audio_channels;
354 SpecifierOpt *audio_sample_rate;
355 int nb_audio_sample_rate;
356 SpecifierOpt *frame_rates;
358 SpecifierOpt *frame_sizes;
360 SpecifierOpt *frame_pix_fmts;
361 int nb_frame_pix_fmts;
364 int64_t input_ts_offset;
367 SpecifierOpt *ts_scale;
369 SpecifierOpt *dump_attachment;
370 int nb_dump_attachment;
373 StreamMap *stream_maps;
375 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
376 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
377 int metadata_global_manual;
378 int metadata_streams_manual;
379 int metadata_chapters_manual;
380 const char **attachments;
383 int chapters_input_file;
385 int64_t recording_time;
386 uint64_t limit_filesize;
392 int subtitle_disable;
395 /* indexed by output file stream index */
399 SpecifierOpt *metadata;
401 SpecifierOpt *max_frames;
403 SpecifierOpt *bitstream_filters;
404 int nb_bitstream_filters;
405 SpecifierOpt *codec_tags;
407 SpecifierOpt *sample_fmts;
409 SpecifierOpt *qscale;
411 SpecifierOpt *forced_key_frames;
412 int nb_forced_key_frames;
413 SpecifierOpt *force_fps;
415 SpecifierOpt *frame_aspect_ratios;
416 int nb_frame_aspect_ratios;
417 SpecifierOpt *rc_overrides;
419 SpecifierOpt *intra_matrices;
420 int nb_intra_matrices;
421 SpecifierOpt *inter_matrices;
422 int nb_inter_matrices;
423 SpecifierOpt *top_field_first;
424 int nb_top_field_first;
425 SpecifierOpt *metadata_map;
427 SpecifierOpt *presets;
429 SpecifierOpt *copy_initial_nonkeyframes;
430 int nb_copy_initial_nonkeyframes;
431 SpecifierOpt *filters;
435 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
438 for (i = 0; i < o->nb_ ## name; i++) {\
439 char *spec = o->name[i].specifier;\
440 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
441 outvar = o->name[i].u.type;\
447 static int64_t getutime(void)
450 struct rusage rusage;
452 getrusage(RUSAGE_SELF, &rusage);
453 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
454 #elif HAVE_GETPROCESSTIMES
457 proc = GetCurrentProcess();
458 GetProcessTimes(proc, &c, &e, &k, &u);
459 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
465 static void update_benchmark(const char *fmt, ...)
467 if (do_benchmark_all) {
468 int64_t t = getutime();
474 vsnprintf(buf, sizeof(buf), fmt, va);
476 printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
482 static void reset_options(OptionsContext *o, int is_input)
484 const OptionDef *po = options;
485 OptionsContext bak= *o;
488 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
490 void *dst = (uint8_t*)o + po->u.off;
492 if (po->flags & OPT_SPEC) {
493 SpecifierOpt **so = dst;
494 int i, *count = (int*)(so + 1);
495 for (i = 0; i < *count; i++) {
496 av_freep(&(*so)[i].specifier);
497 if (po->flags & OPT_STRING)
498 av_freep(&(*so)[i].u.str);
502 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
507 for (i = 0; i < o->nb_stream_maps; i++)
508 av_freep(&o->stream_maps[i].linklabel);
509 av_freep(&o->stream_maps);
510 av_freep(&o->audio_channel_maps);
511 av_freep(&o->streamid_map);
513 memset(o, 0, sizeof(*o));
515 if(is_input) o->recording_time = bak.recording_time;
516 else o->recording_time = INT64_MAX;
517 o->mux_max_delay = 0.7;
518 o->limit_filesize = UINT64_MAX;
519 o->chapters_input_file = INT_MAX;
525 static int alloc_buffer(InputStream *ist, AVCodecContext *s, FrameBuffer **pbuf)
527 FrameBuffer *buf = av_mallocz(sizeof(*buf));
529 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
530 int h_chroma_shift, v_chroma_shift;
531 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
532 int w = s->width, h = s->height;
535 return AVERROR(ENOMEM);
537 avcodec_align_dimensions(s, &w, &h);
539 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
544 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
545 s->pix_fmt, 32)) < 0) {
549 /* XXX this shouldn't be needed, but some tests break without this line
550 * those decoders are buggy and need to be fixed.
551 * the following tests fail:
552 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
554 memset(buf->base[0], 128, ret);
556 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
557 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
558 const int h_shift = i==0 ? 0 : h_chroma_shift;
559 const int v_shift = i==0 ? 0 : v_chroma_shift;
560 if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1] || !buf->base[i])
561 buf->data[i] = buf->base[i];
563 buf->data[i] = buf->base[i] +
564 FFALIGN((buf->linesize[i]*edge >> v_shift) +
565 (pixel_size*edge >> h_shift), 32);
569 buf->pix_fmt = s->pix_fmt;
576 static void free_buffer_pool(InputStream *ist)
578 FrameBuffer *buf = ist->buffer_pool;
580 ist->buffer_pool = buf->next;
581 av_freep(&buf->base[0]);
583 buf = ist->buffer_pool;
587 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
589 av_assert0(buf->refcount > 0);
591 if (!buf->refcount) {
593 for(tmp= ist->buffer_pool; tmp; tmp= tmp->next)
594 av_assert1(tmp != buf);
595 buf->next = ist->buffer_pool;
596 ist->buffer_pool = buf;
600 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
602 InputStream *ist = s->opaque;
606 if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0)
609 if (!ist->buffer_pool && (ret = alloc_buffer(ist, s, &ist->buffer_pool)) < 0)
612 buf = ist->buffer_pool;
613 ist->buffer_pool = buf->next;
615 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
616 av_freep(&buf->base[0]);
618 if ((ret = alloc_buffer(ist, s, &buf)) < 0)
621 av_assert0(!buf->refcount);
625 frame->type = FF_BUFFER_TYPE_USER;
626 frame->extended_data = frame->data;
627 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
628 frame->width = buf->w;
629 frame->height = buf->h;
630 frame->format = buf->pix_fmt;
631 frame->sample_aspect_ratio = s->sample_aspect_ratio;
633 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
634 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
635 frame->data[i] = buf->data[i];
636 frame->linesize[i] = buf->linesize[i];
642 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
644 InputStream *ist = s->opaque;
645 FrameBuffer *buf = frame->opaque;
648 if(frame->type!=FF_BUFFER_TYPE_USER)
649 return avcodec_default_release_buffer(s, frame);
651 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
652 frame->data[i] = NULL;
654 unref_buffer(ist, buf);
657 static void filter_release_buffer(AVFilterBuffer *fb)
659 FrameBuffer *buf = fb->priv;
661 unref_buffer(buf->ist, buf);
664 static enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target)
666 if (codec && codec->pix_fmts) {
667 const enum PixelFormat *p = codec->pix_fmts;
668 int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0;
669 enum PixelFormat best= PIX_FMT_NONE;
670 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
671 if (st->codec->codec_id == CODEC_ID_MJPEG) {
672 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
673 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
674 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
675 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
678 for (; *p != PIX_FMT_NONE; p++) {
679 best= avcodec_find_best_pix_fmt2(best, *p, target, has_alpha, NULL);
683 if (*p == PIX_FMT_NONE) {
684 if (target != PIX_FMT_NONE)
685 av_log(NULL, AV_LOG_WARNING,
686 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
687 av_pix_fmt_descriptors[target].name,
689 av_pix_fmt_descriptors[best].name);
696 static char *choose_pix_fmts(OutputStream *ost)
698 if (ost->keep_pix_fmt) {
700 avfilter_graph_set_auto_convert(ost->filter->graph->graph,
701 AVFILTER_AUTO_CONVERT_NONE);
702 if (ost->st->codec->pix_fmt == PIX_FMT_NONE)
704 ost->pix_fmts[0] = ost->st->codec->pix_fmt;
705 return ost->pix_fmts;
707 if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
708 return av_strdup(av_get_pix_fmt_name(choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt)));
709 } else if (ost->enc->pix_fmts) {
710 const enum PixelFormat *p;
711 AVIOContext *s = NULL;
715 if (avio_open_dyn_buf(&s) < 0)
718 p = ost->enc->pix_fmts;
719 if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
720 if (ost->st->codec->codec_id == CODEC_ID_MJPEG) {
721 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
722 } else if (ost->st->codec->codec_id == CODEC_ID_LJPEG) {
723 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
724 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
728 for (; *p != PIX_FMT_NONE; p++) {
729 const char *name = av_get_pix_fmt_name(*p);
730 avio_printf(s, "%s:", name);
732 len = avio_close_dyn_buf(s, &ret);
740 * Define a function for building a string containing a list of
743 #define DEF_CHOOSE_FORMAT(type, var, supported_list, none, get_name, separator) \
744 static char *choose_ ## var ## s(OutputStream *ost) \
746 if (ost->st->codec->var != none) { \
747 get_name(ost->st->codec->var); \
748 return av_strdup(name); \
749 } else if (ost->enc->supported_list) { \
751 AVIOContext *s = NULL; \
755 if (avio_open_dyn_buf(&s) < 0) \
758 for (p = ost->enc->supported_list; *p != none; p++) { \
760 avio_printf(s, "%s" separator, name); \
762 len = avio_close_dyn_buf(s, &ret); \
769 #define GET_PIX_FMT_NAME(pix_fmt)\
770 const char *name = av_get_pix_fmt_name(pix_fmt);
772 // DEF_CHOOSE_FORMAT(enum PixelFormat, pix_fmt, pix_fmts, PIX_FMT_NONE,
773 // GET_PIX_FMT_NAME, ":")
775 #define GET_SAMPLE_FMT_NAME(sample_fmt)\
776 const char *name = av_get_sample_fmt_name(sample_fmt)
778 DEF_CHOOSE_FORMAT(enum AVSampleFormat, sample_fmt, sample_fmts,
779 AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME, ",")
781 #define GET_SAMPLE_RATE_NAME(rate)\
783 snprintf(name, sizeof(name), "%d", rate);
785 DEF_CHOOSE_FORMAT(int, sample_rate, supported_samplerates, 0,
786 GET_SAMPLE_RATE_NAME, ",")
788 #define GET_CH_LAYOUT_NAME(ch_layout)\
790 snprintf(name, sizeof(name), "0x%"PRIx64, ch_layout);
792 DEF_CHOOSE_FORMAT(uint64_t, channel_layout, channel_layouts, 0,
793 GET_CH_LAYOUT_NAME, ",")
795 static int configure_audio_filters(FilterGraph *fg, AVFilterContext **in_filter,
796 AVFilterContext **out_filter)
798 InputStream *ist = fg->inputs[0]->ist;
799 OutputStream *ost = fg->outputs[0]->ost;
800 AVCodecContext *codec = ost->st->codec;
801 AVCodecContext *icodec = ist->st->codec;
802 char *sample_fmts, *sample_rates, *channel_layouts;
806 avfilter_graph_free(&fg->graph);
807 if (!(fg->graph = avfilter_graph_alloc()))
808 return AVERROR(ENOMEM);
811 snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s:"
812 "channel_layout=0x%"PRIx64, ist->st->time_base.num,
814 snprintf(args, sizeof(args), "%d/%d:%d:%s:"
815 "0x%"PRIx64, ist->st->time_base.num,
817 ist->st->time_base.den, icodec->sample_rate,
818 av_get_sample_fmt_name(icodec->sample_fmt), icodec->channel_layout);
819 ret = avfilter_graph_create_filter(&fg->inputs[0]->filter,
820 avfilter_get_by_name("abuffer"),
821 "src", args, NULL, fg->graph);
825 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter,
826 avfilter_get_by_name("abuffersink_old"),
827 "out", NULL, NULL, fg->graph);
831 *in_filter = fg->inputs[0]->filter;
832 *out_filter = fg->outputs[0]->filter;
834 if (codec->channels && !codec->channel_layout)
835 codec->channel_layout = av_get_default_channel_layout(codec->channels);
837 sample_fmts = choose_sample_fmts(ost);
838 sample_rates = choose_sample_rates(ost);
839 channel_layouts = choose_channel_layouts(ost);
840 if (sample_fmts || sample_rates || channel_layouts) {
841 AVFilterContext *format;
846 len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:",
849 len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:",
852 len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:",
856 av_freep(&sample_fmts);
857 av_freep(&sample_rates);
858 av_freep(&channel_layouts);
860 ret = avfilter_graph_create_filter(&format,
861 avfilter_get_by_name("aformat"),
862 "aformat", args, NULL, fg->graph);
866 ret = avfilter_link(format, 0, fg->outputs[0]->filter, 0);
870 *out_filter = format;
873 if (audio_volume != 256) {
874 AVFilterContext *volume;
877 snprintf(args, sizeof(args), "%lf", audio_volume / 256.);
878 av_log(NULL, AV_LOG_WARNING, "-vol has been deprecated. Used the "
879 "volume audio filter instead (-af volume=%s).\n", args);
881 ret = avfilter_graph_create_filter(&volume,
882 avfilter_get_by_name("volume"),
883 "volume", args, NULL, fg->graph);
887 ret = avfilter_link(*in_filter, 0, volume, 0);
897 static int configure_video_filters(FilterGraph *fg, AVFilterContext **in_filter,
898 AVFilterContext **out_filter)
900 InputStream *ist = fg->inputs[0]->ist;
901 OutputStream *ost = fg->outputs[0]->ost;
902 AVFilterContext *filter;
903 AVCodecContext *codec = ost->st->codec;
904 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
906 AVRational sample_aspect_ratio;
910 if (ist->st->sample_aspect_ratio.num) {
911 sample_aspect_ratio = ist->st->sample_aspect_ratio;
913 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
915 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,
916 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
917 sample_aspect_ratio.num, sample_aspect_ratio.den, SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
919 ret = avfilter_graph_create_filter(&fg->inputs[0]->filter,
920 avfilter_get_by_name("buffer"),
921 "src", args, NULL, fg->graph);
925 #if FF_API_OLD_VSINK_API
926 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter,
927 avfilter_get_by_name("buffersink"),
928 "out", NULL, NULL, fg->graph);
930 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter,
931 avfilter_get_by_name("buffersink"),
932 "out", NULL, buffersink_params, fg->graph);
934 av_freep(&buffersink_params);
938 *in_filter = fg->inputs[0]->filter;
939 *out_filter = fg->outputs[0]->filter;
941 if (codec->width || codec->height) {
942 snprintf(args, 255, "%d:%d:flags=0x%X",
945 (unsigned)ost->sws_flags);
946 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
947 NULL, args, NULL, fg->graph)) < 0)
949 if ((ret = avfilter_link(*in_filter, 0, filter, 0)) < 0)
954 if ((pix_fmts = choose_pix_fmts(ost))) {
955 if ((ret = avfilter_graph_create_filter(&filter,
956 avfilter_get_by_name("format"),
957 "format", pix_fmts, NULL,
960 if ((ret = avfilter_link(filter, 0, *out_filter, 0)) < 0)
963 *out_filter = filter;
967 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
968 fg->graph->scale_sws_opts = av_strdup(args);
973 static int configure_simple_filtergraph(FilterGraph *fg)
975 OutputStream *ost = fg->outputs[0]->ost;
976 AVFilterContext *in_filter, *out_filter;
979 avfilter_graph_free(&fg->graph);
980 fg->graph = avfilter_graph_alloc();
982 return AVERROR(ENOMEM);
984 switch (ost->st->codec->codec_type) {
985 case AVMEDIA_TYPE_VIDEO:
986 ret = configure_video_filters(fg, &in_filter, &out_filter);
988 case AVMEDIA_TYPE_AUDIO:
989 ret = configure_audio_filters(fg, &in_filter, &out_filter);
991 default: av_assert0(0);
997 AVFilterInOut *outputs = avfilter_inout_alloc();
998 AVFilterInOut *inputs = avfilter_inout_alloc();
1000 outputs->name = av_strdup("in");
1001 outputs->filter_ctx = in_filter;
1002 outputs->pad_idx = 0;
1003 outputs->next = NULL;
1005 inputs->name = av_strdup("out");
1006 inputs->filter_ctx = out_filter;
1007 inputs->pad_idx = 0;
1008 inputs->next = NULL;
1010 if ((ret = avfilter_graph_parse(fg->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
1012 av_freep(&ost->avfilter);
1014 if ((ret = avfilter_link(in_filter, 0, out_filter, 0)) < 0)
1018 if (ost->keep_pix_fmt)
1019 avfilter_graph_set_auto_convert(fg->graph,
1020 AVFILTER_AUTO_CONVERT_NONE);
1022 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1025 ost->filter = fg->outputs[0];
1030 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
1032 FilterGraph *fg = av_mallocz(sizeof(*fg));
1036 fg->index = nb_filtergraphs;
1038 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
1039 fg->nb_outputs + 1);
1040 if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
1042 fg->outputs[0]->ost = ost;
1043 fg->outputs[0]->graph = fg;
1045 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
1047 if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
1049 fg->inputs[0]->ist = ist;
1050 fg->inputs[0]->graph = fg;
1052 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
1053 &ist->nb_filters, ist->nb_filters + 1);
1054 ist->filters[ist->nb_filters - 1] = fg->inputs[0];
1056 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
1057 &nb_filtergraphs, nb_filtergraphs + 1);
1058 filtergraphs[nb_filtergraphs - 1] = fg;
1063 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
1065 InputStream *ist = NULL;
1066 enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
1069 // TODO: support other filter types
1070 if (type != AVMEDIA_TYPE_VIDEO) {
1071 av_log(NULL, AV_LOG_FATAL, "Only video filters supported currently.\n");
1077 AVStream *st = NULL;
1079 int file_idx = strtol(in->name, &p, 0);
1081 if (file_idx < 0 || file_idx >= nb_input_files) {
1082 av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n",
1083 file_idx, fg->graph_desc);
1086 s = input_files[file_idx]->ctx;
1088 for (i = 0; i < s->nb_streams; i++) {
1089 if (s->streams[i]->codec->codec_type != type)
1091 if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
1097 av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
1098 "matches no streams.\n", p, fg->graph_desc);
1101 ist = input_streams[input_files[file_idx]->ist_index + st->index];
1103 /* find the first unused stream of corresponding type */
1104 for (i = 0; i < nb_input_streams; i++) {
1105 ist = input_streams[i];
1106 if (ist->st->codec->codec_type == type && ist->discard)
1109 if (i == nb_input_streams) {
1110 av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
1111 "unlabeled input pad %d on filter %s", in->pad_idx,
1112 in->filter_ctx->name);
1117 ist->decoding_needed = 1;
1118 ist->st->discard = AVDISCARD_NONE;
1120 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
1121 &fg->nb_inputs, fg->nb_inputs + 1);
1122 if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
1124 fg->inputs[fg->nb_inputs - 1]->ist = ist;
1125 fg->inputs[fg->nb_inputs - 1]->graph = fg;
1127 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
1128 &ist->nb_filters, ist->nb_filters + 1);
1129 ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
1132 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
1135 AVCodecContext *codec = ofilter->ost->st->codec;
1136 AVFilterContext *last_filter = out->filter_ctx;
1137 int pad_idx = out->pad_idx;
1139 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
1141 #if FF_API_OLD_VSINK_API
1142 ret = avfilter_graph_create_filter(&ofilter->filter,
1143 avfilter_get_by_name("buffersink"),
1144 "out", NULL, NULL, fg->graph);
1146 ret = avfilter_graph_create_filter(&ofilter->filter,
1147 avfilter_get_by_name("buffersink"),
1148 "out", NULL, buffersink_params, fg->graph);
1150 av_freep(&buffersink_params);
1155 if (codec->width || codec->height) {
1157 AVFilterContext *filter;
1159 snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
1162 (unsigned)ofilter->ost->sws_flags);
1163 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
1164 NULL, args, NULL, fg->graph)) < 0)
1166 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
1169 last_filter = filter;
1173 if ((pix_fmts = choose_pix_fmts(ofilter->ost))) {
1174 AVFilterContext *filter;
1175 if ((ret = avfilter_graph_create_filter(&filter,
1176 avfilter_get_by_name("format"),
1177 "format", pix_fmts, NULL,
1180 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
1183 last_filter = filter;
1185 av_freep(&pix_fmts);
1188 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
1194 static int configure_complex_filter(FilterGraph *fg)
1196 AVFilterInOut *inputs, *outputs, *cur;
1197 int ret, i, init = !fg->graph;
1199 avfilter_graph_free(&fg->graph);
1200 if (!(fg->graph = avfilter_graph_alloc()))
1201 return AVERROR(ENOMEM);
1203 if ((ret = avfilter_graph_parse2(fg->graph, fg->graph_desc, &inputs, &outputs)) < 0)
1206 for (cur = inputs; init && cur; cur = cur->next)
1207 init_input_filter(fg, cur);
1209 for (cur = inputs, i = 0; cur; cur = cur->next, i++) {
1210 InputFilter *ifilter = fg->inputs[i];
1211 InputStream *ist = ifilter->ist;
1215 sar = ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1216 ist->st->codec->sample_aspect_ratio;
1217 snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
1218 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
1221 if ((ret = avfilter_graph_create_filter(&ifilter->filter,
1222 avfilter_get_by_name("buffer"), cur->name,
1223 args, NULL, fg->graph)) < 0)
1225 if ((ret = avfilter_link(ifilter->filter, 0,
1226 cur->filter_ctx, cur->pad_idx)) < 0)
1229 avfilter_inout_free(&inputs);
1232 /* we already know the mappings between lavfi outputs and output streams,
1233 * so we can finish the setup */
1234 for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1235 configure_output_filter(fg, fg->outputs[i], cur);
1236 avfilter_inout_free(&outputs);
1238 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1241 /* wait until output mappings are processed */
1242 for (cur = outputs; cur;) {
1243 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1244 &fg->nb_outputs, fg->nb_outputs + 1);
1245 if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1247 fg->outputs[fg->nb_outputs - 1]->graph = fg;
1248 fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1250 fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1257 static int configure_complex_filters(void)
1261 for (i = 0; i < nb_filtergraphs; i++)
1262 if (!filtergraphs[i]->graph &&
1263 (ret = configure_complex_filter(filtergraphs[i])) < 0)
1268 static int configure_filtergraph(FilterGraph *fg)
1270 return fg->graph_desc ? configure_complex_filter(fg) :
1271 configure_simple_filtergraph(fg);
1274 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1277 for (i = 0; i < fg->nb_inputs; i++)
1278 if (fg->inputs[i]->ist == ist)
1283 static void term_exit(void)
1285 av_log(NULL, AV_LOG_QUIET, "%s", "");
1288 tcsetattr (0, TCSANOW, &oldtty);
1292 static volatile int received_sigterm = 0;
1294 static void sigterm_handler(int sig)
1296 received_sigterm = sig;
1297 received_nb_signals++;
1299 if(received_nb_signals > 3)
1303 static void term_init(void)
1309 if (tcgetattr (0, &tty) == 0) {
1314 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1315 |INLCR|IGNCR|ICRNL|IXON);
1316 tty.c_oflag |= OPOST;
1317 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1318 tty.c_cflag &= ~(CSIZE|PARENB);
1321 tty.c_cc[VTIME] = 0;
1323 tcsetattr (0, TCSANOW, &tty);
1325 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
1328 avformat_network_deinit();
1330 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
1331 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
1333 signal(SIGXCPU, sigterm_handler);
1337 /* read a key without blocking */
1338 static int read_key(void)
1350 n = select(1, &rfds, NULL, NULL, &tv);
1352 n = read(0, &ch, 1);
1359 # if HAVE_PEEKNAMEDPIPE
1361 static HANDLE input_handle;
1364 input_handle = GetStdHandle(STD_INPUT_HANDLE);
1365 is_pipe = !GetConsoleMode(input_handle, &dw);
1368 if (stdin->_cnt > 0) {
1373 /* When running under a GUI, you will end here. */
1374 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
1391 static int decode_interrupt_cb(void *ctx)
1393 return received_nb_signals > 1;
1396 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1398 void av_noreturn exit_program(int ret)
1402 for (i = 0; i < nb_filtergraphs; i++) {
1403 avfilter_graph_free(&filtergraphs[i]->graph);
1404 for (j = 0; j < filtergraphs[i]->nb_inputs; j++)
1405 av_freep(&filtergraphs[i]->inputs[j]);
1406 av_freep(&filtergraphs[i]->inputs);
1407 for (j = 0; j < filtergraphs[i]->nb_outputs; j++)
1408 av_freep(&filtergraphs[i]->outputs[j]);
1409 av_freep(&filtergraphs[i]->outputs);
1410 av_freep(&filtergraphs[i]);
1412 av_freep(&filtergraphs);
1415 for (i = 0; i < nb_output_files; i++) {
1416 AVFormatContext *s = output_files[i]->ctx;
1417 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1419 avformat_free_context(s);
1420 av_dict_free(&output_files[i]->opts);
1421 av_freep(&output_files[i]);
1423 for (i = 0; i < nb_output_streams; i++) {
1424 AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1426 AVBitStreamFilterContext *next = bsfc->next;
1427 av_bitstream_filter_close(bsfc);
1430 output_streams[i]->bitstream_filters = NULL;
1432 av_freep(&output_streams[i]->filtered_frame);
1433 av_freep(&output_streams[i]);
1435 for (i = 0; i < nb_input_files; i++) {
1436 avformat_close_input(&input_files[i]->ctx);
1437 av_freep(&input_files[i]);
1439 for (i = 0; i < nb_input_streams; i++) {
1440 av_freep(&input_streams[i]->decoded_frame);
1441 av_dict_free(&input_streams[i]->opts);
1442 free_buffer_pool(input_streams[i]);
1443 av_freep(&input_streams[i]->filters);
1444 av_freep(&input_streams[i]);
1448 fclose(vstats_file);
1449 av_free(vstats_filename);
1451 av_freep(&input_streams);
1452 av_freep(&input_files);
1453 av_freep(&output_streams);
1454 av_freep(&output_files);
1459 avformat_network_deinit();
1461 if (received_sigterm) {
1462 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1463 (int) received_sigterm);
1467 exit(ret); /* not all OS-es handle main() return value */
1470 static void assert_avoptions(AVDictionary *m)
1472 AVDictionaryEntry *t;
1473 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1474 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1479 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1481 const char *codec_string = encoder ? "encoder" : "decoder";
1483 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1484 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1485 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1486 "results.\nAdd '-strict experimental' if you want to use it.\n",
1487 codec_string, c->codec->name);
1488 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1489 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1490 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1491 codec_string, codec->name);
1496 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
1498 if (codec && codec->sample_fmts) {
1499 const enum AVSampleFormat *p = codec->sample_fmts;
1500 for (; *p != -1; p++) {
1501 if (*p == st->codec->sample_fmt)
1505 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
1506 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
1507 if(av_get_sample_fmt_name(st->codec->sample_fmt))
1508 av_log(NULL, AV_LOG_WARNING,
1509 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
1510 av_get_sample_fmt_name(st->codec->sample_fmt),
1512 av_get_sample_fmt_name(codec->sample_fmts[0]));
1513 st->codec->sample_fmt = codec->sample_fmts[0];
1519 get_sync_ipts(const OutputStream *ost, int64_t pts)
1521 OutputFile *of = output_files[ost->file_index];
1522 return (double)(pts - of->start_time) / AV_TIME_BASE;
1525 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1527 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1528 AVCodecContext *avctx = ost->st->codec;
1531 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1532 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1533 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1535 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
1536 int64_t max = ost->st->cur_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
1537 if (ost->st->cur_dts && ost->st->cur_dts != AV_NOPTS_VALUE && max > pkt->dts) {
1538 av_log(s, max - pkt->dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG, "Audio timestamp %"PRId64" < %"PRId64" invalid, cliping\n", pkt->dts, max);
1539 pkt->pts = pkt->dts = max;
1544 * Audio encoders may split the packets -- #frames in != #packets out.
1545 * But there is no reordering, so we can limit the number of output packets
1546 * by simply dropping them here.
1547 * Counting encoded video frames needs to be done separately because of
1548 * reordering, see do_video_out()
1550 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1551 if (ost->frame_number >= ost->max_frames) {
1552 av_free_packet(pkt);
1555 ost->frame_number++;
1559 AVPacket new_pkt = *pkt;
1560 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1561 &new_pkt.data, &new_pkt.size,
1562 pkt->data, pkt->size,
1563 pkt->flags & AV_PKT_FLAG_KEY);
1565 av_free_packet(pkt);
1566 new_pkt.destruct = av_destruct_packet;
1568 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1569 bsfc->filter->name, pkt->stream_index,
1570 avctx->codec ? avctx->codec->name : "copy");
1580 pkt->stream_index = ost->index;
1581 ret = av_interleaved_write_frame(s, pkt);
1583 print_error("av_interleaved_write_frame()", ret);
1588 // static int check_recording_time(OutputStream *ost)
1590 // OutputFile *of = output_files[ost->file_index];
1592 // if (of->recording_time != INT64_MAX &&
1593 // av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
1594 // AV_TIME_BASE_Q) >= 0) {
1595 // ost->is_past_recording_time = 1;
1601 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1604 AVCodecContext *enc = ost->st->codec;
1608 av_init_packet(&pkt);
1612 if (!check_recording_time(ost))
1615 if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
1616 frame->pts = ost->sync_opts;
1617 ost->sync_opts = frame->pts + frame->nb_samples;
1619 av_assert0(pkt.size || !pkt.data);
1620 update_benchmark(NULL);
1621 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1622 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1625 update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
1628 if (pkt.pts != AV_NOPTS_VALUE)
1629 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1630 if (pkt.dts != AV_NOPTS_VALUE) {
1631 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1633 if (pkt.duration > 0)
1634 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1637 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1638 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1639 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1640 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1643 write_frame(s, &pkt, ost);
1645 audio_size += pkt.size;
1646 av_free_packet(&pkt);
1650 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1652 AVCodecContext *dec;
1653 AVPicture *picture2;
1654 AVPicture picture_tmp;
1657 dec = ist->st->codec;
1659 /* deinterlace : must be done before any resize */
1660 if (do_deinterlace) {
1663 /* create temporary picture */
1664 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1665 buf = av_malloc(size);
1669 picture2 = &picture_tmp;
1670 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1672 if (avpicture_deinterlace(picture2, picture,
1673 dec->pix_fmt, dec->width, dec->height) < 0) {
1674 /* if error, do not deinterlace */
1675 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1684 if (picture != picture2)
1685 *picture = *picture2;
1689 static void do_subtitle_out(AVFormatContext *s,
1695 static uint8_t *subtitle_out = NULL;
1696 int subtitle_out_max_size = 1024 * 1024;
1697 int subtitle_out_size, nb, i;
1698 AVCodecContext *enc;
1701 if (pts == AV_NOPTS_VALUE) {
1702 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1708 enc = ost->st->codec;
1710 if (!subtitle_out) {
1711 subtitle_out = av_malloc(subtitle_out_max_size);
1714 /* Note: DVB subtitle need one packet to draw them and one other
1715 packet to clear them */
1716 /* XXX: signal it in the codec context ? */
1717 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1722 for (i = 0; i < nb; i++) {
1723 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1725 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1726 // start_display_time is required to be 0
1727 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1728 sub->end_display_time -= sub->start_display_time;
1729 sub->start_display_time = 0;
1730 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1731 subtitle_out_max_size, sub);
1732 if (subtitle_out_size < 0) {
1733 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1737 av_init_packet(&pkt);
1738 pkt.data = subtitle_out;
1739 pkt.size = subtitle_out_size;
1740 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1741 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1742 /* XXX: the pts correction is handled here. Maybe handling
1743 it in the codec would be better */
1745 pkt.pts += 90 * sub->start_display_time;
1747 pkt.pts += 90 * sub->end_display_time;
1749 write_frame(s, &pkt, ost);
1753 static double psnr(double d)
1755 return -10.0 * log(d) / log(10.0);
1758 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1761 AVCodecContext *enc;
1763 double ti1, bitrate, avg_bitrate;
1765 /* this is executed just the first time do_video_stats is called */
1767 vstats_file = fopen(vstats_filename, "w");
1774 enc = ost->st->codec;
1775 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1776 frame_number = ost->frame_number;
1777 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1778 if (enc->flags&CODEC_FLAG_PSNR)
1779 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1781 fprintf(vstats_file,"f_size= %6d ", frame_size);
1782 /* compute pts value */
1783 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1787 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1788 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1789 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1790 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1791 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1796 static void do_video_out(AVFormatContext *s, OutputStream *ost,
1797 AVFrame *in_picture, float quality)
1799 int nb_frames, i, ret, format_video_sync;
1800 AVCodecContext *enc;
1801 double sync_ipts, delta;
1802 double duration = 0;
1804 InputStream *ist = NULL;
1806 if (ost->source_index >= 0)
1807 ist = input_streams[ost->source_index];
1809 enc = ost->st->codec;
1811 if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1812 duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));
1814 sync_ipts = get_sync_ipts(ost, in_picture->pts) / av_q2d(enc->time_base);
1815 delta = sync_ipts - ost->sync_opts + duration;
1817 /* by default, we output a single frame */
1820 format_video_sync = video_sync_method;
1821 if (format_video_sync == VSYNC_AUTO)
1822 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1824 switch (format_video_sync) {
1826 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1829 else if (delta > 1.1)
1830 nb_frames = lrintf(delta);
1835 else if (delta > 0.6)
1836 ost->sync_opts = lrint(sync_ipts);
1839 case VSYNC_PASSTHROUGH:
1840 ost->sync_opts = lrint(sync_ipts);
1846 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1847 if (nb_frames == 0) {
1849 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1851 } else if (nb_frames > 1) {
1852 nb_frames_dup += nb_frames - 1;
1853 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1856 /* duplicates frame if needed */
1857 for (i = 0; i < nb_frames; i++) {
1859 av_init_packet(&pkt);
1863 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1864 enc->codec->id == CODEC_ID_RAWVIDEO) {
1865 /* raw pictures are written as AVPicture structure to
1866 avoid any copies. We support temporarily the older
1868 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1869 enc->coded_frame->top_field_first = in_picture->top_field_first;
1870 pkt.data = (uint8_t *)in_picture;
1871 pkt.size = sizeof(AVPicture);
1872 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1873 pkt.flags |= AV_PKT_FLAG_KEY;
1875 write_frame(s, &pkt, ost);
1878 AVFrame big_picture;
1880 big_picture = *in_picture;
1881 /* better than nothing: use input picture interlaced
1883 big_picture.interlaced_frame = in_picture->interlaced_frame;
1884 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1885 if (ost->top_field_first == -1)
1886 big_picture.top_field_first = in_picture->top_field_first;
1888 big_picture.top_field_first = !!ost->top_field_first;
1891 /* handles same_quant here. This is not correct because it may
1892 not be a global option */
1893 big_picture.quality = quality;
1894 if (!enc->me_threshold)
1895 big_picture.pict_type = 0;
1896 big_picture.pts = ost->sync_opts;
1897 if (ost->forced_kf_index < ost->forced_kf_count &&
1898 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1899 big_picture.pict_type = AV_PICTURE_TYPE_I;
1900 ost->forced_kf_index++;
1902 update_benchmark(NULL);
1903 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
1904 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1906 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1911 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
1912 pkt.pts = ost->sync_opts;
1914 if (pkt.pts != AV_NOPTS_VALUE)
1915 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1916 if (pkt.dts != AV_NOPTS_VALUE)
1917 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1920 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1921 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1922 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1923 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1926 write_frame(s, &pkt, ost);
1927 frame_size = pkt.size;
1928 video_size += pkt.size;
1929 av_free_packet(&pkt);
1931 /* if two pass, output log */
1932 if (ost->logfile && enc->stats_out) {
1933 fprintf(ost->logfile, "%s", enc->stats_out);
1939 * For video, number of frames in == number of packets out.
1940 * But there may be reordering, so we can't throw away frames on encoder
1941 * flush, we need to limit them here, before they go into encoder.
1943 ost->frame_number++;
1945 if (vstats_filename && frame_size)
1946 do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
1949 /* check for new output on any of the filtergraphs */
1950 static int poll_filters(void)
1952 AVFilterBufferRef *picref;
1953 AVFrame *filtered_frame = NULL;
1954 int i, ret, ret_all;
1955 unsigned nb_success, nb_eof;
1959 /* Reap all buffers present in the buffer sinks */
1960 for (i = 0; i < nb_output_streams; i++) {
1961 OutputStream *ost = output_streams[i];
1962 OutputFile *of = output_files[ost->file_index];
1965 if (!ost->filter || ost->is_past_recording_time)
1968 if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
1969 return AVERROR(ENOMEM);
1971 avcodec_get_frame_defaults(ost->filtered_frame);
1972 filtered_frame = ost->filtered_frame;
1975 AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base;
1976 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
1977 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
1978 ret = av_buffersink_read_samples(ost->filter->filter, &picref,
1979 ost->st->codec->frame_size);
1982 ret = av_buffersink_read(ost->filter->filter, &picref);
1984 ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
1985 AV_BUFFERSINK_FLAG_NO_REQUEST);
1988 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1990 av_strerror(ret, buf, sizeof(buf));
1991 av_log(NULL, AV_LOG_WARNING,
1992 "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
1996 if (ost->enc->type == AVMEDIA_TYPE_VIDEO)
1997 filtered_frame->pts = frame_pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1998 else if (picref->pts != AV_NOPTS_VALUE)
1999 filtered_frame->pts = frame_pts = av_rescale_q(picref->pts,
2000 ost->filter->filter->inputs[0]->time_base,
2001 ost->st->codec->time_base) -
2002 av_rescale_q(of->start_time,
2004 ost->st->codec->time_base);
2005 //if (ost->source_index >= 0)
2006 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
2008 if (of->start_time && filtered_frame->pts < of->start_time)
2011 switch (ost->filter->filter->inputs[0]->type) {
2012 case AVMEDIA_TYPE_VIDEO:
2013 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);
2014 filtered_frame->pts = frame_pts;
2015 if (!ost->frame_aspect_ratio)
2016 ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
2018 do_video_out(of->ctx, ost, filtered_frame,
2019 same_quant ? ost->last_quality :
2020 ost->st->codec->global_quality);
2022 case AVMEDIA_TYPE_AUDIO:
2023 avfilter_copy_buf_props(filtered_frame, picref);
2024 filtered_frame->pts = frame_pts;
2025 do_audio_out(of->ctx, ost, filtered_frame);
2028 // TODO support subtitle filters
2032 avfilter_unref_buffer(picref);
2035 /* Request frames through all the graphs */
2036 ret_all = nb_success = nb_eof = 0;
2037 for (i = 0; i < nb_filtergraphs; i++) {
2038 ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
2041 } else if (ret == AVERROR_EOF) {
2043 } else if (ret != AVERROR(EAGAIN)) {
2045 av_strerror(ret, buf, sizeof(buf));
2046 av_log(NULL, AV_LOG_WARNING,
2047 "Error in request_frame(): %s\n", buf);
2053 /* Try again if anything succeeded */
2055 return nb_eof == nb_filtergraphs ? AVERROR_EOF : ret_all;
2058 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
2062 AVFormatContext *oc;
2064 AVCodecContext *enc;
2065 int frame_number, vid, i;
2067 int64_t pts = INT64_MAX;
2068 static int64_t last_time = -1;
2069 static int qp_histogram[52];
2070 int hours, mins, secs, us;
2072 if (!print_stats && !is_last_report)
2075 if (!is_last_report) {
2076 if (last_time == -1) {
2077 last_time = cur_time;
2080 if ((cur_time - last_time) < 500000)
2082 last_time = cur_time;
2086 oc = output_files[0]->ctx;
2088 total_size = avio_size(oc->pb);
2089 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
2090 total_size = avio_tell(oc->pb);
2097 for (i = 0; i < nb_output_streams; i++) {
2099 ost = output_streams[i];
2100 enc = ost->st->codec;
2101 if (!ost->stream_copy && enc->coded_frame)
2102 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
2103 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2104 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
2106 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2107 float fps, t = (cur_time-timer_start) / 1000000.0;
2109 frame_number = ost->frame_number;
2110 fps = t > 1 ? frame_number / t : 0;
2111 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
2112 frame_number, fps < 9.95, fps, q);
2114 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
2118 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
2120 for (j = 0; j < 32; j++)
2121 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
2123 if (enc->flags&CODEC_FLAG_PSNR) {
2125 double error, error_sum = 0;
2126 double scale, scale_sum = 0;
2127 char type[3] = { 'Y','U','V' };
2128 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
2129 for (j = 0; j < 3; j++) {
2130 if (is_last_report) {
2131 error = enc->error[j];
2132 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
2134 error = enc->coded_frame->error[j];
2135 scale = enc->width * enc->height * 255.0 * 255.0;
2141 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
2143 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
2147 /* compute min output value */
2148 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
2149 ost->st->time_base, AV_TIME_BASE_Q));
2152 secs = pts / AV_TIME_BASE;
2153 us = pts % AV_TIME_BASE;
2159 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
2161 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2162 "size=%8.0fkB time=", total_size / 1024.0);
2163 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2164 "%02d:%02d:%02d.%02d ", hours, mins, secs,
2165 (100 * us) / AV_TIME_BASE);
2166 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2167 "bitrate=%6.1fkbits/s", bitrate);
2169 if (nb_frames_dup || nb_frames_drop)
2170 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
2171 nb_frames_dup, nb_frames_drop);
2173 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
2177 if (is_last_report) {
2178 int64_t raw= audio_size + video_size + extra_size;
2179 av_log(NULL, AV_LOG_INFO, "\n");
2180 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
2181 video_size / 1024.0,
2182 audio_size / 1024.0,
2183 extra_size / 1024.0,
2184 100.0 * (total_size - raw) / raw
2186 if(video_size + audio_size + extra_size == 0){
2187 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
2192 static void flush_encoders(void)
2196 for (i = 0; i < nb_output_streams; i++) {
2197 OutputStream *ost = output_streams[i];
2198 AVCodecContext *enc = ost->st->codec;
2199 AVFormatContext *os = output_files[ost->file_index]->ctx;
2200 int stop_encoding = 0;
2202 if (!ost->encoding_needed)
2205 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
2207 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
2211 int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
2215 switch (ost->st->codec->codec_type) {
2216 case AVMEDIA_TYPE_AUDIO:
2217 encode = avcodec_encode_audio2;
2221 case AVMEDIA_TYPE_VIDEO:
2222 encode = avcodec_encode_video2;
2233 av_init_packet(&pkt);
2237 update_benchmark(NULL);
2238 ret = encode(enc, &pkt, NULL, &got_packet);
2239 update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index);
2241 av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
2245 if (ost->logfile && enc->stats_out) {
2246 fprintf(ost->logfile, "%s", enc->stats_out);
2252 if (pkt.pts != AV_NOPTS_VALUE)
2253 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2254 if (pkt.dts != AV_NOPTS_VALUE)
2255 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2256 write_frame(os, &pkt, ost);
2266 * Check whether a packet from ist should be written into ost at this time
2268 static int check_output_constraints(InputStream *ist, OutputStream *ost)
2270 OutputFile *of = output_files[ost->file_index];
2271 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
2273 if (ost->source_index != ist_index)
2276 if (of->start_time && ist->pts < of->start_time)
2279 if (of->recording_time != INT64_MAX &&
2280 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
2281 (AVRational){ 1, 1000000 }) >= 0) {
2282 ost->is_past_recording_time = 1;
2289 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2291 OutputFile *of = output_files[ost->file_index];
2292 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
2296 av_init_packet(&opkt);
2298 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2299 !ost->copy_initial_nonkeyframes)
2302 /* force the input stream PTS */
2303 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2304 audio_size += pkt->size;
2305 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2306 video_size += pkt->size;
2310 if (pkt->pts != AV_NOPTS_VALUE)
2311 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
2313 opkt.pts = AV_NOPTS_VALUE;
2315 if (pkt->dts == AV_NOPTS_VALUE)
2316 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
2318 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
2319 opkt.dts -= ost_tb_start_time;
2321 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
2322 opkt.flags = pkt->flags;
2324 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2325 if ( ost->st->codec->codec_id != CODEC_ID_H264
2326 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
2327 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
2328 && ost->st->codec->codec_id != CODEC_ID_VC1
2330 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
2331 opkt.destruct = av_destruct_packet;
2333 opkt.data = pkt->data;
2334 opkt.size = pkt->size;
2336 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2337 /* store AVPicture in AVPacket, as expected by the output format */
2338 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2339 opkt.data = (uint8_t *)&pict;
2340 opkt.size = sizeof(AVPicture);
2341 opkt.flags |= AV_PKT_FLAG_KEY;
2344 write_frame(of->ctx, &opkt, ost);
2345 ost->st->codec->frame_number++;
2346 av_free_packet(&opkt);
2349 static void rate_emu_sleep(InputStream *ist)
2351 if (input_files[ist->file_index]->rate_emu) {
2352 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2353 int64_t now = av_gettime() - ist->start;
2359 static int guess_input_channel_layout(InputStream *ist)
2361 AVCodecContext *dec = ist->st->codec;
2363 if (!dec->channel_layout) {
2364 char layout_name[256];
2366 dec->channel_layout = av_get_default_channel_layout(dec->channels);
2367 if (!dec->channel_layout)
2369 av_get_channel_layout_string(layout_name, sizeof(layout_name),
2370 dec->channels, dec->channel_layout);
2371 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2372 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2377 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2379 AVFrame *decoded_frame;
2380 AVCodecContext *avctx = ist->st->codec;
2381 int i, ret, resample_changed;
2383 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2384 return AVERROR(ENOMEM);
2386 avcodec_get_frame_defaults(ist->decoded_frame);
2387 decoded_frame = ist->decoded_frame;
2389 update_benchmark(NULL);
2390 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2391 update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2395 if (avctx->sample_rate <= 0) {
2396 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2397 return AVERROR_INVALIDDATA;
2401 /* no audio frame */
2403 for (i = 0; i < ist->nb_filters; i++)
2405 av_buffersrc_buffer(ist->filters[i]->filter, NULL);
2407 av_buffersrc_add_ref(ist->filters[i]->filter, NULL, 0);
2412 /* if the decoder provides a pts, use it instead of the last packet pts.
2413 the decoder could be delaying output by a packet or more. */
2414 if (decoded_frame->pts != AV_NOPTS_VALUE)
2415 ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2416 else if (pkt->pts != AV_NOPTS_VALUE) {
2417 decoded_frame->pts = pkt->pts;
2418 pkt->pts = AV_NOPTS_VALUE;
2420 decoded_frame->pts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2424 /* increment next_dts to use for the case where the input stream does not
2425 have timestamps or there are multiple frames in the packet */
2426 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2428 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2432 rate_emu_sleep(ist);
2434 resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
2435 ist->resample_channels != avctx->channels ||
2436 ist->resample_channel_layout != decoded_frame->channel_layout ||
2437 ist->resample_sample_rate != decoded_frame->sample_rate;
2438 if (resample_changed) {
2439 char layout1[64], layout2[64];
2441 if (!guess_input_channel_layout(ist)) {
2442 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
2443 "layout for Input Stream #%d.%d\n", ist->file_index,
2447 decoded_frame->channel_layout = avctx->channel_layout;
2449 av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
2450 ist->resample_channel_layout);
2451 av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
2452 decoded_frame->channel_layout);
2454 av_log(NULL, AV_LOG_INFO,
2455 "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",
2456 ist->file_index, ist->st->index,
2457 ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt),
2458 ist->resample_channels, layout1,
2459 decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2460 avctx->channels, layout2);
2462 ist->resample_sample_fmt = decoded_frame->format;
2463 ist->resample_sample_rate = decoded_frame->sample_rate;
2464 ist->resample_channel_layout = decoded_frame->channel_layout;
2465 ist->resample_channels = avctx->channels;
2467 for (i = 0; i < nb_filtergraphs; i++)
2468 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2469 configure_filtergraph(filtergraphs[i]) < 0) {
2470 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2475 for (i = 0; i < ist->nb_filters; i++) {
2477 av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
2479 av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0);
2486 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
2488 AVFrame *decoded_frame;
2489 void *buffer_to_free = NULL;
2490 int i, ret = 0, resample_changed;
2491 int64_t best_effort_timestamp;
2492 AVRational *frame_sample_aspect;
2495 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2496 return AVERROR(ENOMEM);
2498 avcodec_get_frame_defaults(ist->decoded_frame);
2499 decoded_frame = ist->decoded_frame;
2500 pkt->pts = *pkt_pts;
2501 pkt->dts = ist->dts;
2502 *pkt_pts = AV_NOPTS_VALUE;
2504 update_benchmark(NULL);
2505 ret = avcodec_decode_video2(ist->st->codec,
2506 decoded_frame, got_output, pkt);
2507 update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2511 quality = same_quant ? decoded_frame->quality : 0;
2513 /* no picture yet */
2515 for (i = 0; i < ist->nb_filters; i++)
2517 av_buffersrc_buffer(ist->filters[i]->filter, NULL);
2519 av_buffersrc_add_ref(ist->filters[i]->filter, NULL, 0);
2524 best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2525 if(best_effort_timestamp != AV_NOPTS_VALUE)
2526 ist->next_pts = ist->pts = decoded_frame->pts = best_effort_timestamp;
2530 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2532 rate_emu_sleep(ist);
2534 if (ist->st->sample_aspect_ratio.num)
2535 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2537 resample_changed = ist->resample_width != decoded_frame->width ||
2538 ist->resample_height != decoded_frame->height ||
2539 ist->resample_pix_fmt != decoded_frame->format;
2540 if (resample_changed) {
2541 av_log(NULL, AV_LOG_INFO,
2542 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2543 ist->file_index, ist->st->index,
2544 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2545 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2547 ist->resample_width = decoded_frame->width;
2548 ist->resample_height = decoded_frame->height;
2549 ist->resample_pix_fmt = decoded_frame->format;
2551 for (i = 0; i < nb_filtergraphs; i++)
2552 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2553 configure_filtergraph(filtergraphs[i]) < 0) {
2554 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2559 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2560 for (i = 0; i < ist->nb_filters; i++) {
2561 int changed = ist->st->codec->width != ist->filters[i]->filter->outputs[0]->w
2562 || ist->st->codec->height != ist->filters[i]->filter->outputs[0]->h
2563 || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2564 // XXX what an ugly hack
2565 if (ist->filters[i]->graph->nb_outputs == 1)
2566 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2568 if (!frame_sample_aspect->num)
2569 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2570 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2571 FrameBuffer *buf = decoded_frame->opaque;
2572 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2573 decoded_frame->data, decoded_frame->linesize,
2574 AV_PERM_READ | AV_PERM_PRESERVE,
2575 ist->st->codec->width, ist->st->codec->height,
2576 ist->st->codec->pix_fmt);
2578 avfilter_copy_frame_props(fb, decoded_frame);
2579 fb->buf->priv = buf;
2580 fb->buf->free = filter_release_buffer;
2582 av_assert0(buf->refcount>0);
2585 av_buffersrc_buffer(ist->filters[i]->filter, fb);
2587 if(av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame)<0) {
2589 av_buffersrc_add_ref(ist->filters[i]->filter, fb,
2590 AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
2591 AV_BUFFERSRC_FLAG_NO_COPY);
2593 if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0)<0) {
2595 av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2601 av_free(buffer_to_free);
2605 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2607 AVSubtitle subtitle;
2608 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2609 &subtitle, got_output, pkt);
2615 rate_emu_sleep(ist);
2617 for (i = 0; i < nb_output_streams; i++) {
2618 OutputStream *ost = output_streams[i];
2620 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2623 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2626 avsubtitle_free(&subtitle);
2630 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2631 static int output_packet(InputStream *ist, const AVPacket *pkt)
2635 int64_t pkt_pts = AV_NOPTS_VALUE;
2638 if (!ist->saw_first_ts) {
2639 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;
2641 if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2642 ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2643 ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2645 ist->saw_first_ts = 1;
2648 if (ist->next_dts == AV_NOPTS_VALUE)
2649 ist->next_dts = ist->dts;
2650 if (ist->next_pts == AV_NOPTS_VALUE)
2651 ist->next_pts = ist->pts;
2655 av_init_packet(&avpkt);
2663 if (pkt->dts != AV_NOPTS_VALUE) {
2664 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2665 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2666 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2668 if(pkt->pts != AV_NOPTS_VALUE)
2669 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2671 // while we have more to decode or while the decoder did output something on EOF
2672 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2676 ist->pts = ist->next_pts;
2677 ist->dts = ist->next_dts;
2679 if (avpkt.size && avpkt.size != pkt->size) {
2680 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2681 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2682 ist->showed_multi_packet_warning = 1;
2685 switch (ist->st->codec->codec_type) {
2686 case AVMEDIA_TYPE_AUDIO:
2687 ret = transcode_audio (ist, &avpkt, &got_output);
2689 case AVMEDIA_TYPE_VIDEO:
2690 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
2691 if (avpkt.duration) {
2692 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2693 } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2694 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2695 duration = ((int64_t)AV_TIME_BASE *
2696 ist->st->codec->time_base.num * ticks) /
2697 ist->st->codec->time_base.den;
2701 if(ist->dts != AV_NOPTS_VALUE && duration) {
2702 ist->next_dts += duration;
2704 ist->next_dts = AV_NOPTS_VALUE;
2707 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2709 case AVMEDIA_TYPE_SUBTITLE:
2710 ret = transcode_subtitles(ist, &avpkt, &got_output);
2720 avpkt.pts= AV_NOPTS_VALUE;
2722 // touch data and size only if not EOF
2724 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2734 /* handle stream copy */
2735 if (!ist->decoding_needed) {
2736 rate_emu_sleep(ist);
2737 ist->dts = ist->next_dts;
2738 switch (ist->st->codec->codec_type) {
2739 case AVMEDIA_TYPE_AUDIO:
2740 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2741 ist->st->codec->sample_rate;
2743 case AVMEDIA_TYPE_VIDEO:
2744 if (pkt->duration) {
2745 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2746 } else if(ist->st->codec->time_base.num != 0) {
2747 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2748 ist->next_dts += ((int64_t)AV_TIME_BASE *
2749 ist->st->codec->time_base.num * ticks) /
2750 ist->st->codec->time_base.den;
2754 ist->pts = ist->dts;
2755 ist->next_pts = ist->next_dts;
2757 for (i = 0; pkt && i < nb_output_streams; i++) {
2758 OutputStream *ost = output_streams[i];
2760 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2763 do_streamcopy(ist, ost, pkt);
2769 static void print_sdp(void)
2773 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2777 for (i = 0; i < nb_output_files; i++)
2778 avc[i] = output_files[i]->ctx;
2780 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2781 printf("SDP:\n%s\n", sdp);
2786 static int init_input_stream(int ist_index, char *error, int error_len)
2789 InputStream *ist = input_streams[ist_index];
2791 if (ist->decoding_needed) {
2792 AVCodec *codec = ist->dec;
2794 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2795 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2796 return AVERROR(EINVAL);
2799 ist->dr1 = (codec->capabilities & CODEC_CAP_DR1) && !do_deinterlace;
2800 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2801 ist->st->codec->get_buffer = codec_get_buffer;
2802 ist->st->codec->release_buffer = codec_release_buffer;
2803 ist->st->codec->opaque = ist;
2806 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2807 av_dict_set(&ist->opts, "threads", "auto", 0);
2808 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2809 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2810 ist->file_index, ist->st->index);
2811 return AVERROR(EINVAL);
2813 assert_codec_experimental(ist->st->codec, 0);
2814 assert_avoptions(ist->opts);
2817 ist->next_pts = AV_NOPTS_VALUE;
2818 ist->next_dts = AV_NOPTS_VALUE;
2824 static InputStream *get_input_stream(OutputStream *ost)
2826 if (ost->source_index >= 0)
2827 return input_streams[ost->source_index];
2830 FilterGraph *fg = ost->filter->graph;
2833 for (i = 0; i < fg->nb_inputs; i++)
2834 if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2835 return fg->inputs[i]->ist;
2841 static int transcode_init(void)
2843 int ret = 0, i, j, k;
2844 AVFormatContext *oc;
2845 AVCodecContext *codec, *icodec;
2851 /* init framerate emulation */
2852 for (i = 0; i < nb_input_files; i++) {
2853 InputFile *ifile = input_files[i];
2854 if (ifile->rate_emu)
2855 for (j = 0; j < ifile->nb_streams; j++)
2856 input_streams[j + ifile->ist_index]->start = av_gettime();
2859 /* output stream init */
2860 for (i = 0; i < nb_output_files; i++) {
2861 oc = output_files[i]->ctx;
2862 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2863 av_dump_format(oc, i, oc->filename, 1);
2864 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2865 return AVERROR(EINVAL);
2869 /* init complex filtergraphs */
2870 for (i = 0; i < nb_filtergraphs; i++)
2871 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2874 /* for each output stream, we compute the right encoding parameters */
2875 for (i = 0; i < nb_output_streams; i++) {
2876 ost = output_streams[i];
2877 oc = output_files[ost->file_index]->ctx;
2878 ist = get_input_stream(ost);
2880 if (ost->attachment_filename)
2883 codec = ost->st->codec;
2886 icodec = ist->st->codec;
2888 ost->st->disposition = ist->st->disposition;
2889 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2890 codec->chroma_sample_location = icodec->chroma_sample_location;
2893 if (ost->stream_copy) {
2894 uint64_t extra_size;
2896 av_assert0(ist && !ost->filter);
2898 extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2900 if (extra_size > INT_MAX) {
2901 return AVERROR(EINVAL);
2904 /* if stream_copy is selected, no need to decode or encode */
2905 codec->codec_id = icodec->codec_id;
2906 codec->codec_type = icodec->codec_type;
2908 if (!codec->codec_tag) {
2909 if (!oc->oformat->codec_tag ||
2910 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2911 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2912 codec->codec_tag = icodec->codec_tag;
2915 codec->bit_rate = icodec->bit_rate;
2916 codec->rc_max_rate = icodec->rc_max_rate;
2917 codec->rc_buffer_size = icodec->rc_buffer_size;
2918 codec->field_order = icodec->field_order;
2919 codec->extradata = av_mallocz(extra_size);
2920 if (!codec->extradata) {
2921 return AVERROR(ENOMEM);
2923 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2924 codec->extradata_size= icodec->extradata_size;
2925 codec->bits_per_coded_sample = icodec->bits_per_coded_sample;
2927 codec->time_base = ist->st->time_base;
2929 * Avi is a special case here because it supports variable fps but
2930 * having the fps and timebase differe significantly adds quite some
2933 if(!strcmp(oc->oformat->name, "avi")) {
2934 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2935 && av_q2d(ist->st->time_base) < 1.0/500
2937 codec->time_base = icodec->time_base;
2938 codec->time_base.num *= icodec->ticks_per_frame;
2939 codec->time_base.den *= 2;
2940 codec->ticks_per_frame = 2;
2942 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2943 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2944 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2946 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2947 && av_q2d(ist->st->time_base) < 1.0/500
2949 codec->time_base = icodec->time_base;
2950 codec->time_base.num *= icodec->ticks_per_frame;
2953 av_reduce(&codec->time_base.num, &codec->time_base.den,
2954 codec->time_base.num, codec->time_base.den, INT_MAX);
2956 switch (codec->codec_type) {
2957 case AVMEDIA_TYPE_AUDIO:
2958 if (audio_volume != 256) {
2959 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2962 codec->channel_layout = icodec->channel_layout;
2963 codec->sample_rate = icodec->sample_rate;
2964 codec->channels = icodec->channels;
2965 codec->frame_size = icodec->frame_size;
2966 codec->audio_service_type = icodec->audio_service_type;
2967 codec->block_align = icodec->block_align;
2968 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2969 codec->block_align= 0;
2970 if(codec->codec_id == CODEC_ID_AC3)
2971 codec->block_align= 0;
2973 case AVMEDIA_TYPE_VIDEO:
2974 codec->pix_fmt = icodec->pix_fmt;
2975 codec->width = icodec->width;
2976 codec->height = icodec->height;
2977 codec->has_b_frames = icodec->has_b_frames;
2978 if (!codec->sample_aspect_ratio.num) {
2979 codec->sample_aspect_ratio =
2980 ost->st->sample_aspect_ratio =
2981 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2982 ist->st->codec->sample_aspect_ratio.num ?
2983 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2985 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2987 case AVMEDIA_TYPE_SUBTITLE:
2988 codec->width = icodec->width;
2989 codec->height = icodec->height;
2991 case AVMEDIA_TYPE_DATA:
2992 case AVMEDIA_TYPE_ATTACHMENT:
2999 ost->enc = avcodec_find_encoder(codec->codec_id);
3001 /* should only happen when a default codec is not present. */
3002 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3003 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3004 ret = AVERROR(EINVAL);
3009 ist->decoding_needed = 1;
3010 ost->encoding_needed = 1;
3013 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3014 codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
3016 fg = init_simple_filtergraph(ist, ost);
3017 if (configure_simple_filtergraph(fg)) {
3018 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3023 switch (codec->codec_type) {
3024 case AVMEDIA_TYPE_AUDIO:
3025 codec->sample_fmt = ost->filter->filter->inputs[0]->format;
3026 codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
3027 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3028 codec->channels = av_get_channel_layout_nb_channels(codec->channel_layout);
3029 codec->time_base = (AVRational){ 1, codec->sample_rate };
3031 case AVMEDIA_TYPE_VIDEO:
3032 if (ist && !ost->frame_rate.num)
3033 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
3034 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3035 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3036 ost->frame_rate = ost->enc->supported_framerates[idx];
3038 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3039 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3040 && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3041 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3042 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3044 for (j = 0; j < ost->forced_kf_count; j++)
3045 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3049 codec->width = ost->filter->filter->inputs[0]->w;
3050 codec->height = ost->filter->filter->inputs[0]->h;
3051 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3052 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3053 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3054 ost->filter->filter->inputs[0]->sample_aspect_ratio;
3055 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3057 if (codec->width != icodec->width ||
3058 codec->height != icodec->height ||
3059 codec->pix_fmt != icodec->pix_fmt) {
3060 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3064 case AVMEDIA_TYPE_SUBTITLE:
3065 codec->time_base = (AVRational){1, 1000};
3072 if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3073 char logfilename[1024];
3076 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3077 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3079 if (!strcmp(ost->enc->name, "libx264")) {
3080 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3082 if (codec->flags & CODEC_FLAG_PASS2) {
3084 size_t logbuffer_size;
3085 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3086 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3090 codec->stats_in = logbuffer;
3092 if (codec->flags & CODEC_FLAG_PASS1) {
3093 f = fopen(logfilename, "wb");
3095 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3096 logfilename, strerror(errno));
3106 /* open each encoder */
3107 for (i = 0; i < nb_output_streams; i++) {
3108 ost = output_streams[i];
3109 if (ost->encoding_needed) {
3110 AVCodec *codec = ost->enc;
3111 AVCodecContext *dec = NULL;
3113 if ((ist = get_input_stream(ost)))
3114 dec = ist->st->codec;
3115 if (dec && dec->subtitle_header) {
3116 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3117 if (!ost->st->codec->subtitle_header) {
3118 ret = AVERROR(ENOMEM);
3121 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3122 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3124 if (!av_dict_get(ost->opts, "threads", NULL, 0))
3125 av_dict_set(&ost->opts, "threads", "auto", 0);
3126 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3127 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3128 ost->file_index, ost->index);
3129 ret = AVERROR(EINVAL);
3132 assert_codec_experimental(ost->st->codec, 1);
3133 assert_avoptions(ost->opts);
3134 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3135 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3136 " It takes bits/s as argument, not kbits/s\n");
3137 extra_size += ost->st->codec->extradata_size;
3139 if (ost->st->codec->me_threshold)
3140 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3144 /* init input streams */
3145 for (i = 0; i < nb_input_streams; i++)
3146 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3149 /* discard unused programs */
3150 for (i = 0; i < nb_input_files; i++) {
3151 InputFile *ifile = input_files[i];
3152 for (j = 0; j < ifile->ctx->nb_programs; j++) {
3153 AVProgram *p = ifile->ctx->programs[j];
3154 int discard = AVDISCARD_ALL;
3156 for (k = 0; k < p->nb_stream_indexes; k++)
3157 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3158 discard = AVDISCARD_DEFAULT;
3161 p->discard = discard;
3165 /* open files and write file headers */
3166 for (i = 0; i < nb_output_files; i++) {
3167 oc = output_files[i]->ctx;
3168 oc->interrupt_callback = int_cb;
3169 if (avformat_write_header(oc, &output_files[i]->opts) < 0) {
3170 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
3171 ret = AVERROR(EINVAL);
3174 // assert_avoptions(output_files[i]->opts);
3175 if (strcmp(oc->oformat->name, "rtp")) {
3181 /* dump the file output parameters - cannot be done before in case
3183 for (i = 0; i < nb_output_files; i++) {
3184 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3187 /* dump the stream mapping */
3188 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3189 for (i = 0; i < nb_input_streams; i++) {
3190 ist = input_streams[i];
3192 for (j = 0; j < ist->nb_filters; j++) {
3193 AVFilterLink *link = ist->filters[j]->filter->outputs[0];
3194 if (ist->filters[j]->graph->graph_desc) {
3195 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
3196 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3197 link->dst->filter->name);
3198 if (link->dst->input_count > 1)
3199 av_log(NULL, AV_LOG_INFO, ":%s", link->dstpad->name);
3200 if (nb_filtergraphs > 1)
3201 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3202 av_log(NULL, AV_LOG_INFO, "\n");
3207 for (i = 0; i < nb_output_streams; i++) {
3208 ost = output_streams[i];
3210 if (ost->attachment_filename) {
3211 /* an attached file */
3212 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
3213 ost->attachment_filename, ost->file_index, ost->index);
3217 if (ost->filter && ost->filter->graph->graph_desc) {
3218 /* output from a complex graph */
3219 AVFilterLink *link = ost->filter->filter->inputs[0];
3220 av_log(NULL, AV_LOG_INFO, " %s", link->src->filter->name);
3221 if (link->src->output_count > 1)
3222 av_log(NULL, AV_LOG_INFO, ":%s", link->srcpad->name);
3223 if (nb_filtergraphs > 1)
3224 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3226 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3227 ost->index, ost->enc ? ost->enc->name : "?");
3231 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
3232 input_streams[ost->source_index]->file_index,
3233 input_streams[ost->source_index]->st->index,
3236 if (ost->sync_ist != input_streams[ost->source_index])
3237 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3238 ost->sync_ist->file_index,
3239 ost->sync_ist->st->index);
3240 if (ost->stream_copy)
3241 av_log(NULL, AV_LOG_INFO, " (copy)");
3243 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3244 input_streams[ost->source_index]->dec->name : "?",
3245 ost->enc ? ost->enc->name : "?");
3246 av_log(NULL, AV_LOG_INFO, "\n");
3250 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3262 * The following code is the main loop of the file converter
3264 static int transcode(void)
3267 AVFormatContext *is, *os;
3271 int no_packet_count = 0;
3272 int64_t timer_start;
3275 if (!(no_packet = av_mallocz(nb_input_files)))
3278 ret = transcode_init();
3283 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3286 timer_start = av_gettime();
3288 for (; received_sigterm == 0;) {
3289 int file_index, ist_index, past_recording_time = 1;
3292 int64_t cur_time= av_gettime();
3294 ipts_min = INT64_MAX;
3295 /* if 'q' pressed, exits */
3297 static int64_t last_time;
3298 if (received_nb_signals)
3300 /* read_key() returns 0 on EOF */
3301 if(cur_time - last_time >= 100000 && !run_as_daemon){
3303 last_time = cur_time;
3308 if (key == '+') av_log_set_level(av_log_get_level()+10);
3309 if (key == '-') av_log_set_level(av_log_get_level()-10);
3310 if (key == 's') qp_hist ^= 1;
3313 do_hex_dump = do_pkt_dump = 0;
3314 } else if(do_pkt_dump){
3318 av_log_set_level(AV_LOG_DEBUG);
3320 if (key == 'c' || key == 'C'){
3321 char buf[4096], target[64], command[256], arg[256] = {0};
3324 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3326 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3331 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3332 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3333 target, time, command, arg);
3334 for (i = 0; i < nb_filtergraphs; i++) {
3335 FilterGraph *fg = filtergraphs[i];
3338 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3339 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3340 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3342 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3347 av_log(NULL, AV_LOG_ERROR,
3348 "Parse error, at least 3 arguments were expected, "
3349 "only %d given in string '%s'\n", n, buf);
3352 if (key == 'd' || key == 'D'){
3355 debug = input_streams[0]->st->codec->debug<<1;
3356 if(!debug) debug = 1;
3357 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3360 if(scanf("%d", &debug)!=1)
3361 fprintf(stderr,"error parsing debug value\n");
3362 for(i=0;i<nb_input_streams;i++) {
3363 input_streams[i]->st->codec->debug = debug;
3365 for(i=0;i<nb_output_streams;i++) {
3366 ost = output_streams[i];
3367 ost->st->codec->debug = debug;
3369 if(debug) av_log_set_level(AV_LOG_DEBUG);
3370 fprintf(stderr,"debug=%d\n", debug);
3373 fprintf(stderr, "key function\n"
3374 "? show this help\n"
3375 "+ increase verbosity\n"
3376 "- decrease verbosity\n"
3377 "c Send command to filtergraph\n"
3378 "D cycle through available debug modes\n"
3379 "h dump packets/hex press to cycle through the 3 states\n"
3381 "s Show QP histogram\n"
3386 /* check if there's any stream where output is still needed */
3387 for (i = 0; i < nb_output_streams; i++) {
3389 ost = output_streams[i];
3390 of = output_files[ost->file_index];
3391 os = output_files[ost->file_index]->ctx;
3392 if (ost->is_past_recording_time ||
3393 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3395 if (ost->frame_number >= ost->max_frames) {
3397 for (j = 0; j < of->ctx->nb_streams; j++)
3398 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3401 past_recording_time = 0;
3403 if (past_recording_time)
3406 /* select the stream that we must read now by looking at the
3407 smallest output pts */
3409 for (i = 0; i < nb_input_streams; i++) {
3411 ist = input_streams[i];
3413 if (ist->discard || no_packet[ist->file_index])
3415 if (!input_files[ist->file_index]->eof_reached) {
3416 if (ipts < ipts_min) {
3418 file_index = ist->file_index;
3422 /* if none, if is finished */
3423 if (file_index < 0) {
3424 if (no_packet_count) {
3425 no_packet_count = 0;
3426 memset(no_packet, 0, nb_input_files);
3433 /* read a frame from it and output it in the fifo */
3434 is = input_files[file_index]->ctx;
3435 ret = av_read_frame(is, &pkt);
3436 if (ret == AVERROR(EAGAIN)) {
3437 no_packet[file_index] = 1;
3442 input_files[file_index]->eof_reached = 1;
3444 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3445 ist = input_streams[input_files[file_index]->ist_index + i];
3446 if (ist->decoding_needed)
3447 output_packet(ist, NULL);
3456 no_packet_count = 0;
3457 memset(no_packet, 0, nb_input_files);
3460 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3461 is->streams[pkt.stream_index]);
3463 /* the following test is needed in case new streams appear
3464 dynamically in stream : we ignore them */
3465 if (pkt.stream_index >= input_files[file_index]->nb_streams)
3466 goto discard_packet;
3467 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3468 ist = input_streams[ist_index];
3470 goto discard_packet;
3472 if (pkt.dts != AV_NOPTS_VALUE)
3473 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3474 if (pkt.pts != AV_NOPTS_VALUE)
3475 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3477 if (pkt.pts != AV_NOPTS_VALUE)
3478 pkt.pts *= ist->ts_scale;
3479 if (pkt.dts != AV_NOPTS_VALUE)
3480 pkt.dts *= ist->ts_scale;
3483 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3484 "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",
3485 ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3486 av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &ist->st->time_base),
3487 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3488 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3489 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3490 input_files[ist->file_index]->ts_offset);
3493 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3494 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3495 int64_t delta = pkt_dts - ist->next_dts;
3496 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3497 if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3498 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3499 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3500 pkt_dts+1<ist->pts){
3501 input_files[ist->file_index]->ts_offset -= delta;
3502 av_log(NULL, AV_LOG_DEBUG,
3503 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3504 delta, input_files[ist->file_index]->ts_offset);
3505 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3506 if (pkt.pts != AV_NOPTS_VALUE)
3507 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3510 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3511 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3512 pkt_dts+1<ist->pts){
3513 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3514 pkt.dts = AV_NOPTS_VALUE;
3516 if (pkt.pts != AV_NOPTS_VALUE){
3517 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3518 delta = pkt_pts - ist->next_dts;
3519 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3520 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3521 pkt_pts+1<ist->pts) {
3522 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3523 pkt.pts = AV_NOPTS_VALUE;
3529 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3530 if (output_packet(ist, &pkt) < 0 ||
3531 ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3532 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3533 ist->file_index, ist->st->index);
3536 av_free_packet(&pkt);
3541 av_free_packet(&pkt);
3543 /* dump report by using the output first video and audio streams */
3544 print_report(0, timer_start, cur_time);
3547 /* at the end of stream, we must flush the decoder buffers */
3548 for (i = 0; i < nb_input_streams; i++) {
3549 ist = input_streams[i];
3550 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3551 output_packet(ist, NULL);
3559 /* write the trailer if needed and close file */
3560 for (i = 0; i < nb_output_files; i++) {
3561 os = output_files[i]->ctx;
3562 av_write_trailer(os);
3565 /* dump report by using the first video and audio streams */
3566 print_report(1, timer_start, av_gettime());
3568 /* close each encoder */
3569 for (i = 0; i < nb_output_streams; i++) {
3570 ost = output_streams[i];
3571 if (ost->encoding_needed) {
3572 av_freep(&ost->st->codec->stats_in);
3573 avcodec_close(ost->st->codec);
3577 /* close each decoder */
3578 for (i = 0; i < nb_input_streams; i++) {
3579 ist = input_streams[i];
3580 if (ist->decoding_needed) {
3581 avcodec_close(ist->st->codec);
3589 av_freep(&no_packet);
3591 if (output_streams) {
3592 for (i = 0; i < nb_output_streams; i++) {
3593 ost = output_streams[i];
3595 if (ost->stream_copy)
3596 av_freep(&ost->st->codec->extradata);
3598 fclose(ost->logfile);
3599 ost->logfile = NULL;
3601 av_freep(&ost->st->codec->subtitle_header);
3602 av_free(ost->forced_kf_pts);
3603 av_dict_free(&ost->opts);
3610 static int opt_frame_crop(const char *opt, const char *arg)
3612 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3613 return AVERROR(EINVAL);
3616 static int opt_pad(const char *opt, const char *arg)
3618 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3622 static int opt_video_channel(const char *opt, const char *arg)
3624 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3625 return opt_default("channel", arg);
3628 static int opt_video_standard(const char *opt, const char *arg)
3630 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3631 return opt_default("standard", arg);
3634 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3636 audio_codec_name = arg;
3637 return parse_option(o, "codec:a", arg, options);
3640 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3642 video_codec_name = arg;
3643 return parse_option(o, "codec:v", arg, options);
3646 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3648 subtitle_codec_name = arg;
3649 return parse_option(o, "codec:s", arg, options);
3652 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3654 return parse_option(o, "codec:d", arg, options);
3657 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3659 StreamMap *m = NULL;
3660 int i, negative = 0, file_idx;
3661 int sync_file_idx = -1, sync_stream_idx = 0;
3669 map = av_strdup(arg);
3671 /* parse sync stream first, just pick first matching stream */
3672 if (sync = strchr(map, ',')) {
3674 sync_file_idx = strtol(sync + 1, &sync, 0);
3675 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3676 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3681 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3682 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3683 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3684 sync_stream_idx = i;
3687 if (i == input_files[sync_file_idx]->nb_streams) {
3688 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3689 "match any streams.\n", arg);
3695 if (map[0] == '[') {
3696 /* this mapping refers to lavfi output */
3697 const char *c = map + 1;
3698 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3699 &o->nb_stream_maps, o->nb_stream_maps + 1);
3700 m = &o->stream_maps[o->nb_stream_maps - 1];
3701 m->linklabel = av_get_token(&c, "]");
3702 if (!m->linklabel) {
3703 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3707 file_idx = strtol(map, &p, 0);
3708 if (file_idx >= nb_input_files || file_idx < 0) {
3709 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3713 /* disable some already defined maps */
3714 for (i = 0; i < o->nb_stream_maps; i++) {
3715 m = &o->stream_maps[i];
3716 if (file_idx == m->file_index &&
3717 check_stream_specifier(input_files[m->file_index]->ctx,
3718 input_files[m->file_index]->ctx->streams[m->stream_index],
3719 *p == ':' ? p + 1 : p) > 0)
3723 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3724 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3725 *p == ':' ? p + 1 : p) <= 0)
3727 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3728 &o->nb_stream_maps, o->nb_stream_maps + 1);
3729 m = &o->stream_maps[o->nb_stream_maps - 1];
3731 m->file_index = file_idx;
3732 m->stream_index = i;
3734 if (sync_file_idx >= 0) {
3735 m->sync_file_index = sync_file_idx;
3736 m->sync_stream_index = sync_stream_idx;
3738 m->sync_file_index = file_idx;
3739 m->sync_stream_index = i;
3745 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3753 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3755 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3756 &o->nb_attachments, o->nb_attachments + 1);
3757 o->attachments[o->nb_attachments - 1] = arg;
3761 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3767 o->audio_channel_maps =
3768 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3769 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3770 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3772 /* muted channel syntax */
3773 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3774 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3775 m->file_idx = m->stream_idx = -1;
3777 m->ofile_idx = m->ostream_idx = -1;
3782 n = sscanf(arg, "%d.%d.%d:%d.%d",
3783 &m->file_idx, &m->stream_idx, &m->channel_idx,
3784 &m->ofile_idx, &m->ostream_idx);
3786 if (n != 3 && n != 5) {
3787 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3788 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3792 if (n != 5) // only file.stream.channel specified
3793 m->ofile_idx = m->ostream_idx = -1;
3796 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3797 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3801 if (m->stream_idx < 0 ||
3802 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
3803 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3804 m->file_idx, m->stream_idx);
3807 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
3808 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3809 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3810 m->file_idx, m->stream_idx);
3813 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3814 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3815 m->file_idx, m->stream_idx, m->channel_idx);
3822 * Parse a metadata specifier in arg.
3823 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3824 * @param index for type c/p, chapter/program index is written here
3825 * @param stream_spec for type s, the stream specifier is written here
3827 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3835 if (*(++arg) && *arg != ':') {
3836 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3839 *stream_spec = *arg == ':' ? arg + 1 : "";
3843 if (*(++arg) == ':')
3844 *index = strtol(++arg, NULL, 0);
3847 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3854 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3856 AVDictionary **meta_in = NULL;
3857 AVDictionary **meta_out = NULL;
3859 char type_in, type_out;
3860 const char *istream_spec = NULL, *ostream_spec = NULL;
3861 int idx_in = 0, idx_out = 0;
3863 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3864 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3867 if (type_out == 'g' || !*outspec)
3868 o->metadata_global_manual = 1;
3869 if (type_out == 's' || !*outspec)
3870 o->metadata_streams_manual = 1;
3871 if (type_out == 'c' || !*outspec)
3872 o->metadata_chapters_manual = 1;
3876 if (type_in == 'g' || type_out == 'g')
3877 o->metadata_global_manual = 1;
3878 if (type_in == 's' || type_out == 's')
3879 o->metadata_streams_manual = 1;
3880 if (type_in == 'c' || type_out == 'c')
3881 o->metadata_chapters_manual = 1;
3883 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3884 if ((index) < 0 || (index) >= (nb_elems)) {\
3885 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3890 #define SET_DICT(type, meta, context, index)\
3893 meta = &context->metadata;\
3896 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3897 meta = &context->chapters[index]->metadata;\
3900 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3901 meta = &context->programs[index]->metadata;\
3905 SET_DICT(type_in, meta_in, ic, idx_in);
3906 SET_DICT(type_out, meta_out, oc, idx_out);
3908 /* for input streams choose first matching stream */
3909 if (type_in == 's') {
3910 for (i = 0; i < ic->nb_streams; i++) {
3911 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3912 meta_in = &ic->streams[i]->metadata;
3918 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3923 if (type_out == 's') {
3924 for (i = 0; i < oc->nb_streams; i++) {
3925 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3926 meta_out = &oc->streams[i]->metadata;
3927 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3932 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3937 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3940 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3941 struct tm time = *gmtime((time_t*)&recording_timestamp);
3942 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3943 parse_option(o, "metadata", buf, options);
3945 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3946 "tag instead.\n", opt);
3950 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3952 const char *codec_string = encoder ? "encoder" : "decoder";
3956 avcodec_find_encoder_by_name(name) :
3957 avcodec_find_decoder_by_name(name);
3959 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3962 if (codec->type != type) {
3963 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3969 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3971 char *codec_name = NULL;
3973 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3975 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3976 st->codec->codec_id = codec->id;
3979 return avcodec_find_decoder(st->codec->codec_id);
3983 * Add all the streams from the given input file to the global
3984 * list of input streams.
3986 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3989 char *next, *codec_tag = NULL;
3991 for (i = 0; i < ic->nb_streams; i++) {
3992 AVStream *st = ic->streams[i];
3993 AVCodecContext *dec = st->codec;
3994 InputStream *ist = av_mallocz(sizeof(*ist));
3999 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4000 input_streams[nb_input_streams - 1] = ist;
4003 ist->file_index = nb_input_files;
4005 st->discard = AVDISCARD_ALL;
4006 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
4008 ist->ts_scale = 1.0;
4009 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4011 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4013 uint32_t tag = strtol(codec_tag, &next, 0);
4015 tag = AV_RL32(codec_tag);
4016 st->codec->codec_tag = tag;
4019 ist->dec = choose_decoder(o, ic, st);
4021 switch (dec->codec_type) {
4022 case AVMEDIA_TYPE_VIDEO:
4024 ist->dec = avcodec_find_decoder(dec->codec_id);
4026 dec->flags |= CODEC_FLAG_EMU_EDGE;
4029 ist->resample_height = dec->height;
4030 ist->resample_width = dec->width;
4031 ist->resample_pix_fmt = dec->pix_fmt;
4034 case AVMEDIA_TYPE_AUDIO:
4035 guess_input_channel_layout(ist);
4037 ist->resample_sample_fmt = dec->sample_fmt;
4038 ist->resample_sample_rate = dec->sample_rate;
4039 ist->resample_channels = dec->channels;
4040 ist->resample_channel_layout = dec->channel_layout;
4043 case AVMEDIA_TYPE_DATA:
4044 case AVMEDIA_TYPE_SUBTITLE:
4046 ist->dec = avcodec_find_decoder(dec->codec_id);
4048 case AVMEDIA_TYPE_ATTACHMENT:
4049 case AVMEDIA_TYPE_UNKNOWN:
4057 static void assert_file_overwrite(const char *filename)
4059 if ((!file_overwrite || no_file_overwrite) &&
4060 (strchr(filename, ':') == NULL || filename[1] == ':' ||
4061 av_strstart(filename, "file:", NULL))) {
4062 if (avio_check(filename, 0) == 0) {
4063 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
4064 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4067 signal(SIGINT, SIG_DFL);
4068 if (!read_yesno()) {
4069 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4075 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4082 static void dump_attachment(AVStream *st, const char *filename)
4085 AVIOContext *out = NULL;
4086 AVDictionaryEntry *e;
4088 if (!st->codec->extradata_size) {
4089 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4090 nb_input_files - 1, st->index);
4093 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4094 filename = e->value;
4096 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4097 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4101 assert_file_overwrite(filename);
4103 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4104 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4109 avio_write(out, st->codec->extradata, st->codec->extradata_size);
4114 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4116 AVFormatContext *ic;
4117 AVInputFormat *file_iformat = NULL;
4121 AVDictionary **opts;
4122 int orig_nb_streams; // number of streams before avformat_find_stream_info
4125 if (!(file_iformat = av_find_input_format(o->format))) {
4126 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4131 if (!strcmp(filename, "-"))
4134 using_stdin |= !strncmp(filename, "pipe:", 5) ||
4135 !strcmp(filename, "/dev/stdin");
4137 /* get default parameters from command line */
4138 ic = avformat_alloc_context();
4140 print_error(filename, AVERROR(ENOMEM));
4143 if (o->nb_audio_sample_rate) {
4144 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4145 av_dict_set(&format_opts, "sample_rate", buf, 0);
4147 if (o->nb_audio_channels) {
4148 /* because we set audio_channels based on both the "ac" and
4149 * "channel_layout" options, we need to check that the specified
4150 * demuxer actually has the "channels" option before setting it */
4151 if (file_iformat && file_iformat->priv_class &&
4152 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4153 AV_OPT_SEARCH_FAKE_OBJ)) {
4154 snprintf(buf, sizeof(buf), "%d",
4155 o->audio_channels[o->nb_audio_channels - 1].u.i);
4156 av_dict_set(&format_opts, "channels", buf, 0);
4159 if (o->nb_frame_rates) {
4160 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4162 if (o->nb_frame_sizes) {
4163 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4165 if (o->nb_frame_pix_fmts)
4166 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4168 ic->video_codec_id = video_codec_name ?
4169 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
4170 ic->audio_codec_id = audio_codec_name ?
4171 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
4172 ic->subtitle_codec_id= subtitle_codec_name ?
4173 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4174 ic->flags |= AVFMT_FLAG_NONBLOCK;
4175 ic->interrupt_callback = int_cb;
4177 /* open the input file with generic avformat function */
4178 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4180 print_error(filename, err);
4183 assert_avoptions(format_opts);
4185 /* apply forced codec ids */
4186 for (i = 0; i < ic->nb_streams; i++)
4187 choose_decoder(o, ic, ic->streams[i]);
4189 /* Set AVCodecContext options for avformat_find_stream_info */
4190 opts = setup_find_stream_info_opts(ic, codec_opts);
4191 orig_nb_streams = ic->nb_streams;
4193 /* If not enough info to get the stream parameters, we decode the
4194 first frames to get it. (used in mpeg case for example) */
4195 ret = avformat_find_stream_info(ic, opts);
4197 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4198 avformat_close_input(&ic);
4202 timestamp = o->start_time;
4203 /* add the stream start time */
4204 if (ic->start_time != AV_NOPTS_VALUE)
4205 timestamp += ic->start_time;
4207 /* if seeking requested, we execute it */
4208 if (o->start_time != 0) {
4209 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4211 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4212 filename, (double)timestamp / AV_TIME_BASE);
4216 /* update the current parameters so that they match the one of the input stream */
4217 add_input_streams(o, ic);
4219 /* dump the file content */
4220 av_dump_format(ic, nb_input_files, filename, 0);
4222 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4223 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4226 input_files[nb_input_files - 1]->ctx = ic;
4227 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
4228 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4229 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4230 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
4232 for (i = 0; i < o->nb_dump_attachment; i++) {
4235 for (j = 0; j < ic->nb_streams; j++) {
4236 AVStream *st = ic->streams[j];
4238 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4239 dump_attachment(st, o->dump_attachment[i].u.str);
4243 for (i = 0; i < orig_nb_streams; i++)
4244 av_dict_free(&opts[i]);
4247 reset_options(o, 1);
4251 static void parse_forced_key_frames(char *kf, OutputStream *ost)
4256 for (p = kf; *p; p++)
4259 ost->forced_kf_count = n;
4260 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
4261 if (!ost->forced_kf_pts) {
4262 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
4266 for (i = 0; i < n; i++) {
4267 char *next = strchr(p, ',');
4268 if (next) *next++ = 0;
4269 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
4274 static uint8_t *get_line(AVIOContext *s)
4280 if (avio_open_dyn_buf(&line) < 0) {
4281 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4285 while ((c = avio_r8(s)) && c != '\n')
4288 avio_close_dyn_buf(line, &buf);
4293 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4296 char filename[1000];
4297 const char *base[3] = { getenv("AVCONV_DATADIR"),
4302 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4306 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4307 i != 1 ? "" : "/.avconv", codec_name, preset_name);
4308 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4311 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4312 i != 1 ? "" : "/.avconv", preset_name);
4313 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4319 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4321 char *codec_name = NULL;
4323 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4325 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4326 NULL, ost->st->codec->codec_type);
4327 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4328 } else if (!strcmp(codec_name, "copy"))
4329 ost->stream_copy = 1;
4331 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4332 ost->st->codec->codec_id = ost->enc->id;
4336 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4339 AVStream *st = avformat_new_stream(oc, NULL);
4340 int idx = oc->nb_streams - 1, ret = 0;
4341 char *bsf = NULL, *next, *codec_tag = NULL;
4342 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4344 char *buf = NULL, *arg = NULL, *preset = NULL;
4345 AVIOContext *s = NULL;
4348 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4352 if (oc->nb_streams - 1 < o->nb_streamid_map)
4353 st->id = o->streamid_map[oc->nb_streams - 1];
4355 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4356 nb_output_streams + 1);
4357 if (!(ost = av_mallocz(sizeof(*ost))))
4359 output_streams[nb_output_streams - 1] = ost;
4361 ost->file_index = nb_output_files;
4364 st->codec->codec_type = type;
4365 choose_encoder(o, oc, ost);
4367 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
4370 avcodec_get_context_defaults3(st->codec, ost->enc);
4371 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4373 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4374 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4377 if (!buf[0] || buf[0] == '#') {
4381 if (!(arg = strchr(buf, '='))) {
4382 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4386 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4388 } while (!s->eof_reached);
4392 av_log(NULL, AV_LOG_FATAL,
4393 "Preset %s specified for stream %d:%d, but could not be opened.\n",
4394 preset, ost->file_index, ost->index);
4398 ost->max_frames = INT64_MAX;
4399 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4401 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4403 if (next = strchr(bsf, ','))
4405 if (!(bsfc = av_bitstream_filter_init(bsf))) {
4406 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4410 bsfc_prev->next = bsfc;
4412 ost->bitstream_filters = bsfc;
4418 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4420 uint32_t tag = strtol(codec_tag, &next, 0);
4422 tag = AV_RL32(codec_tag);
4423 st->codec->codec_tag = tag;
4426 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4427 if (qscale >= 0 || same_quant) {
4428 st->codec->flags |= CODEC_FLAG_QSCALE;
4429 st->codec->global_quality = FF_QP2LAMBDA * qscale;
4432 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4433 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4435 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4436 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4437 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4439 ost->source_index = source_index;
4440 if (source_index >= 0) {
4441 ost->sync_ist = input_streams[source_index];
4442 input_streams[source_index]->discard = 0;
4443 input_streams[source_index]->st->discard = AVDISCARD_NONE;
4446 ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
4451 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4454 const char *p = str;
4461 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4468 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4472 AVCodecContext *video_enc;
4474 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4476 video_enc = st->codec;
4478 if (!ost->stream_copy) {
4479 const char *p = NULL;
4480 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
4481 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4482 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
4485 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4486 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4487 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4491 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4492 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4493 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4497 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4498 if (frame_aspect_ratio) {
4500 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4501 q.num <= 0 || q.den <= 0) {
4502 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4505 ost->frame_aspect_ratio = av_q2d(q);
4508 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4509 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4510 if (frame_pix_fmt && *frame_pix_fmt == '+') {
4511 ost->keep_pix_fmt = 1;
4512 if (!*++frame_pix_fmt)
4513 frame_pix_fmt = NULL;
4515 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4516 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4519 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4522 video_enc->gop_size = 0;
4523 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4525 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4526 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4529 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4531 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4533 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4534 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4537 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4540 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4541 for (i = 0; p; i++) {
4543 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4545 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4548 /* FIXME realloc failure */
4549 video_enc->rc_override =
4550 av_realloc(video_enc->rc_override,
4551 sizeof(RcOverride) * (i + 1));
4552 video_enc->rc_override[i].start_frame = start;
4553 video_enc->rc_override[i].end_frame = end;
4555 video_enc->rc_override[i].qscale = q;
4556 video_enc->rc_override[i].quality_factor = 1.0;
4559 video_enc->rc_override[i].qscale = 0;
4560 video_enc->rc_override[i].quality_factor = -q/100.0;
4565 video_enc->rc_override_count = i;
4566 if (!video_enc->rc_initial_buffer_occupancy)
4567 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4568 video_enc->intra_dc_precision = intra_dc_precision - 8;
4571 video_enc->flags|= CODEC_FLAG_PSNR;
4576 video_enc->flags |= CODEC_FLAG_PASS1;
4579 video_enc->flags |= CODEC_FLAG_PASS2;
4583 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4584 if (forced_key_frames)
4585 parse_forced_key_frames(forced_key_frames, ost);
4587 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4589 ost->top_field_first = -1;
4590 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4592 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4594 ost->avfilter = av_strdup(filters);
4596 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4602 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4607 AVCodecContext *audio_enc;
4609 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4612 audio_enc = st->codec;
4613 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4615 if (!ost->stream_copy) {
4616 char *sample_fmt = NULL, *filters = NULL;
4618 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4620 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4622 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4623 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4627 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4629 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4631 ost->avfilter = av_strdup(filters);
4637 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4641 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4642 if (!ost->stream_copy) {
4643 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4650 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4652 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4653 ost->stream_copy = 1;
4657 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4661 AVCodecContext *subtitle_enc;
4663 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4665 subtitle_enc = st->codec;
4667 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4669 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4674 /* arg format is "output-stream-index:streamid-value". */
4675 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4681 av_strlcpy(idx_str, arg, sizeof(idx_str));
4682 p = strchr(idx_str, ':');
4684 av_log(NULL, AV_LOG_FATAL,
4685 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4690 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4691 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4692 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4696 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4698 AVFormatContext *is = ifile->ctx;
4699 AVFormatContext *os = ofile->ctx;
4702 for (i = 0; i < is->nb_chapters; i++) {
4703 AVChapter *in_ch = is->chapters[i], *out_ch;
4704 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4705 AV_TIME_BASE_Q, in_ch->time_base);
4706 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4707 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4710 if (in_ch->end < ts_off)
4712 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4715 out_ch = av_mallocz(sizeof(AVChapter));
4717 return AVERROR(ENOMEM);
4719 out_ch->id = in_ch->id;
4720 out_ch->time_base = in_ch->time_base;
4721 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4722 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4725 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4728 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4730 return AVERROR(ENOMEM);
4731 os->chapters[os->nb_chapters - 1] = out_ch;
4736 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4739 AVFormatContext *ic = avformat_alloc_context();
4741 ic->interrupt_callback = int_cb;
4742 err = avformat_open_input(&ic, filename, NULL, NULL);
4745 /* copy stream format */
4746 for(i=0;i<ic->nb_streams;i++) {
4750 AVCodecContext *avctx;
4752 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4753 ost = new_output_stream(o, s, codec->type, -1);
4758 // FIXME: a more elegant solution is needed
4759 memcpy(st, ic->streams[i], sizeof(AVStream));
4761 st->info = av_malloc(sizeof(*st->info));
4762 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4764 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4766 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4767 choose_sample_fmt(st, codec);
4768 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4769 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4772 avformat_close_input(&ic);
4776 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4777 AVFormatContext *oc)
4781 if (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type != AVMEDIA_TYPE_VIDEO) {
4782 av_log(NULL, AV_LOG_FATAL, "Only video filters are supported currently.\n");
4786 ost = new_video_stream(o, oc, -1);
4787 ost->source_index = -1;
4788 ost->filter = ofilter;
4792 if (ost->stream_copy) {
4793 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4794 "which is fed from a complex filtergraph. Filtering and streamcopy "
4795 "cannot be used together.\n", ost->file_index, ost->index);
4799 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4800 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4803 avfilter_inout_free(&ofilter->out_tmp);
4806 static void opt_output_file(void *optctx, const char *filename)
4808 OptionsContext *o = optctx;
4809 AVFormatContext *oc;
4811 AVOutputFormat *file_oformat;
4815 if (configure_complex_filters() < 0) {
4816 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4820 if (!strcmp(filename, "-"))
4823 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4825 print_error(filename, err);
4828 file_oformat= oc->oformat;
4829 oc->interrupt_callback = int_cb;
4831 /* create streams for all unlabeled output pads */
4832 for (i = 0; i < nb_filtergraphs; i++) {
4833 FilterGraph *fg = filtergraphs[i];
4834 for (j = 0; j < fg->nb_outputs; j++) {
4835 OutputFilter *ofilter = fg->outputs[j];
4837 if (!ofilter->out_tmp || ofilter->out_tmp->name)
4840 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4841 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
4842 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
4843 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
4845 init_output_filter(ofilter, o, oc);
4849 if (!strcmp(file_oformat->name, "ffm") &&
4850 av_strstart(filename, "http:", NULL)) {
4852 /* special case for files sent to ffserver: we get the stream
4853 parameters from ffserver */
4854 int err = read_ffserver_streams(o, oc, filename);
4856 print_error(filename, err);
4859 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4860 ost = output_streams[j];
4861 for (i = 0; i < nb_input_streams; i++) {
4862 ist = input_streams[i];
4863 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4865 ost->source_index= i;
4867 ist->st->discard = AVDISCARD_NONE;
4872 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));
4876 } else if (!o->nb_stream_maps) {
4877 /* pick the "best" stream of each type */
4879 /* video: highest resolution */
4880 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4881 int area = 0, idx = -1;
4882 for (i = 0; i < nb_input_streams; i++) {
4883 ist = input_streams[i];
4884 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4885 ist->st->codec->width * ist->st->codec->height > area) {
4886 area = ist->st->codec->width * ist->st->codec->height;
4891 new_video_stream(o, oc, idx);
4894 /* audio: most channels */
4895 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4896 int channels = 0, idx = -1;
4897 for (i = 0; i < nb_input_streams; i++) {
4898 ist = input_streams[i];
4899 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4900 ist->st->codec->channels > channels) {
4901 channels = ist->st->codec->channels;
4906 new_audio_stream(o, oc, idx);
4909 /* subtitles: pick first */
4910 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4911 for (i = 0; i < nb_input_streams; i++)
4912 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4913 new_subtitle_stream(o, oc, i);
4917 /* do something with data? */
4919 for (i = 0; i < o->nb_stream_maps; i++) {
4920 StreamMap *map = &o->stream_maps[i];
4921 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
4926 if (map->linklabel) {
4928 OutputFilter *ofilter = NULL;
4931 for (j = 0; j < nb_filtergraphs; j++) {
4932 fg = filtergraphs[j];
4933 for (k = 0; k < fg->nb_outputs; k++) {
4934 AVFilterInOut *out = fg->outputs[k]->out_tmp;
4935 if (out && !strcmp(out->name, map->linklabel)) {
4936 ofilter = fg->outputs[k];
4943 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
4944 "in any defined filter graph.\n", map->linklabel);
4947 init_output_filter(ofilter, o, oc);
4949 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
4950 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4952 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4954 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4956 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4959 switch (ist->st->codec->codec_type) {
4960 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
4961 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
4962 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
4963 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
4964 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
4966 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4967 map->file_index, map->stream_index);
4975 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
4976 AVDictionaryEntry *e;
4977 ost = output_streams[i];
4979 if ( ost->stream_copy
4980 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
4981 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
4982 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
4986 /* handle attached files */
4987 for (i = 0; i < o->nb_attachments; i++) {
4989 uint8_t *attachment;
4993 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4994 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4998 if ((len = avio_size(pb)) <= 0) {
4999 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5003 if (!(attachment = av_malloc(len))) {
5004 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5008 avio_read(pb, attachment, len);
5010 ost = new_attachment_stream(o, oc, -1);
5011 ost->stream_copy = 0;
5012 ost->attachment_filename = o->attachments[i];
5013 ost->st->codec->extradata = attachment;
5014 ost->st->codec->extradata_size = len;
5016 p = strrchr(o->attachments[i], '/');
5017 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5021 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5022 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5025 output_files[nb_output_files - 1]->ctx = oc;
5026 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
5027 output_files[nb_output_files - 1]->recording_time = o->recording_time;
5028 if (o->recording_time != INT64_MAX)
5029 oc->duration = o->recording_time;
5030 output_files[nb_output_files - 1]->start_time = o->start_time;
5031 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5032 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5034 /* check filename in case of an image number is expected */
5035 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5036 if (!av_filename_number_test(oc->filename)) {
5037 print_error(oc->filename, AVERROR(EINVAL));
5042 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5043 /* test if it already exists to avoid losing precious files */
5044 assert_file_overwrite(filename);
5047 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5048 &oc->interrupt_callback,
5049 &output_files[nb_output_files - 1]->opts)) < 0) {
5050 print_error(filename, err);
5055 if (o->mux_preload) {
5057 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5058 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5060 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5063 for (i = 0; i < o->nb_metadata_map; i++) {
5065 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5067 if (in_file_index >= nb_input_files) {
5068 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5071 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5075 if (o->chapters_input_file >= nb_input_files) {
5076 if (o->chapters_input_file == INT_MAX) {
5077 /* copy chapters from the first input file that has them*/
5078 o->chapters_input_file = -1;
5079 for (i = 0; i < nb_input_files; i++)
5080 if (input_files[i]->ctx->nb_chapters) {
5081 o->chapters_input_file = i;
5085 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5086 o->chapters_input_file);
5090 if (o->chapters_input_file >= 0)
5091 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5092 !o->metadata_chapters_manual);
5094 /* copy global metadata by default */
5095 if (!o->metadata_global_manual && nb_input_files){
5096 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5097 AV_DICT_DONT_OVERWRITE);
5098 if(o->recording_time != INT64_MAX)
5099 av_dict_set(&oc->metadata, "duration", NULL, 0);
5101 if (!o->metadata_streams_manual)
5102 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5104 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
5106 ist = input_streams[output_streams[i]->source_index];
5107 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5110 /* process manually set metadata */
5111 for (i = 0; i < o->nb_metadata; i++) {
5114 const char *stream_spec;
5115 int index = 0, j, ret = 0;
5117 val = strchr(o->metadata[i].u.str, '=');
5119 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5120 o->metadata[i].u.str);
5125 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5127 for (j = 0; j < oc->nb_streams; j++) {
5128 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5129 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5133 printf("ret %d, stream_spec %s\n", ret, stream_spec);
5141 if (index < 0 || index >= oc->nb_chapters) {
5142 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5145 m = &oc->chapters[index]->metadata;
5148 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5151 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5155 reset_options(o, 0);
5158 /* same option as mencoder */
5159 static int opt_pass(const char *opt, const char *arg)
5161 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5165 static int64_t getmaxrss(void)
5167 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5168 struct rusage rusage;
5169 getrusage(RUSAGE_SELF, &rusage);
5170 return (int64_t)rusage.ru_maxrss * 1024;
5171 #elif HAVE_GETPROCESSMEMORYINFO
5173 PROCESS_MEMORY_COUNTERS memcounters;
5174 proc = GetCurrentProcess();
5175 memcounters.cb = sizeof(memcounters);
5176 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5177 return memcounters.PeakPagefileUsage;
5183 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5185 return parse_option(o, "q:a", arg, options);
5188 static void show_usage(void)
5190 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5191 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5192 av_log(NULL, AV_LOG_INFO, "\n");
5195 static int opt_help(const char *opt, const char *arg)
5197 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5198 av_log_set_callback(log_callback_help);
5200 show_help_options(options, "Main options:\n",
5201 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5202 show_help_options(options, "\nAdvanced options:\n",
5203 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5205 show_help_options(options, "\nVideo options:\n",
5206 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5208 show_help_options(options, "\nAdvanced Video options:\n",
5209 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5210 OPT_VIDEO | OPT_EXPERT);
5211 show_help_options(options, "\nAudio options:\n",
5212 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5214 show_help_options(options, "\nAdvanced Audio options:\n",
5215 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5216 OPT_AUDIO | OPT_EXPERT);
5217 show_help_options(options, "\nSubtitle options:\n",
5218 OPT_SUBTITLE | OPT_GRAB,
5220 show_help_options(options, "\nAudio/Video grab options:\n",
5224 show_help_children(avcodec_get_class(), flags);
5225 show_help_children(avformat_get_class(), flags);
5226 show_help_children(sws_get_class(), flags);
5231 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5233 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5234 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5236 if (!strncmp(arg, "pal-", 4)) {
5239 } else if (!strncmp(arg, "ntsc-", 5)) {
5242 } else if (!strncmp(arg, "film-", 5)) {
5246 /* Try to determine PAL/NTSC by peeking in the input files */
5247 if (nb_input_files) {
5249 for (j = 0; j < nb_input_files; j++) {
5250 for (i = 0; i < input_files[j]->nb_streams; i++) {
5251 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5252 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5254 fr = c->time_base.den * 1000 / c->time_base.num;
5258 } else if ((fr == 29970) || (fr == 23976)) {
5263 if (norm != UNKNOWN)
5267 if (norm != UNKNOWN)
5268 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5271 if (norm == UNKNOWN) {
5272 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5273 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5274 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5278 if (!strcmp(arg, "vcd")) {
5279 opt_video_codec(o, "c:v", "mpeg1video");
5280 opt_audio_codec(o, "c:a", "mp2");
5281 parse_option(o, "f", "vcd", options);
5283 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5284 parse_option(o, "r", frame_rates[norm], options);
5285 opt_default("g", norm == PAL ? "15" : "18");
5287 opt_default("b:v", "1150000");
5288 opt_default("maxrate", "1150000");
5289 opt_default("minrate", "1150000");
5290 opt_default("bufsize", "327680"); // 40*1024*8;
5292 opt_default("b:a", "224000");
5293 parse_option(o, "ar", "44100", options);
5294 parse_option(o, "ac", "2", options);
5296 opt_default("packetsize", "2324");
5297 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5299 /* We have to offset the PTS, so that it is consistent with the SCR.
5300 SCR starts at 36000, but the first two packs contain only padding
5301 and the first pack from the other stream, respectively, may also have
5302 been written before.
5303 So the real data starts at SCR 36000+3*1200. */
5304 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5305 } else if (!strcmp(arg, "svcd")) {
5307 opt_video_codec(o, "c:v", "mpeg2video");
5308 opt_audio_codec(o, "c:a", "mp2");
5309 parse_option(o, "f", "svcd", options);
5311 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5312 parse_option(o, "r", frame_rates[norm], options);
5313 parse_option(o, "pix_fmt", "yuv420p", options);
5314 opt_default("g", norm == PAL ? "15" : "18");
5316 opt_default("b:v", "2040000");
5317 opt_default("maxrate", "2516000");
5318 opt_default("minrate", "0"); // 1145000;
5319 opt_default("bufsize", "1835008"); // 224*1024*8;
5320 opt_default("scan_offset", "1");
5323 opt_default("b:a", "224000");
5324 parse_option(o, "ar", "44100", options);
5326 opt_default("packetsize", "2324");
5328 } else if (!strcmp(arg, "dvd")) {
5330 opt_video_codec(o, "c:v", "mpeg2video");
5331 opt_audio_codec(o, "c:a", "ac3");
5332 parse_option(o, "f", "dvd", options);
5334 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5335 parse_option(o, "r", frame_rates[norm], options);
5336 parse_option(o, "pix_fmt", "yuv420p", options);
5337 opt_default("g", norm == PAL ? "15" : "18");
5339 opt_default("b:v", "6000000");
5340 opt_default("maxrate", "9000000");
5341 opt_default("minrate", "0"); // 1500000;
5342 opt_default("bufsize", "1835008"); // 224*1024*8;
5344 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5345 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5347 opt_default("b:a", "448000");
5348 parse_option(o, "ar", "48000", options);
5350 } else if (!strncmp(arg, "dv", 2)) {
5352 parse_option(o, "f", "dv", options);
5354 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5355 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5356 norm == PAL ? "yuv420p" : "yuv411p", options);
5357 parse_option(o, "r", frame_rates[norm], options);
5359 parse_option(o, "ar", "48000", options);
5360 parse_option(o, "ac", "2", options);
5363 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5364 return AVERROR(EINVAL);
5369 static int opt_vstats_file(const char *opt, const char *arg)
5371 av_free (vstats_filename);
5372 vstats_filename = av_strdup (arg);
5376 static int opt_vstats(const char *opt, const char *arg)
5379 time_t today2 = time(NULL);
5380 struct tm *today = localtime(&today2);
5382 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5384 return opt_vstats_file(opt, filename);
5387 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5389 return parse_option(o, "frames:v", arg, options);
5392 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5394 return parse_option(o, "frames:a", arg, options);
5397 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5399 return parse_option(o, "frames:d", arg, options);
5402 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5405 char filename[1000], line[1000], tmp_line[1000];
5406 const char *codec_name = *opt == 'v' ? video_codec_name :
5407 *opt == 'a' ? audio_codec_name :
5408 subtitle_codec_name;
5410 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5411 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5412 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5414 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5418 while (fgets(line, sizeof(line), f)) {
5419 char *key = tmp_line, *value, *endptr;
5421 if (strcspn(line, "#\n\r") == 0)
5423 strcpy(tmp_line, line);
5424 if (!av_strtok(key, "=", &value) ||
5425 !av_strtok(value, "\r\n", &endptr)) {
5426 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5429 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
5431 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
5432 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
5433 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
5434 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
5435 else if (opt_default(key, value) < 0) {
5436 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
5437 filename, line, key, value);
5447 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5451 static int opt_passlogfile(const char *opt, const char *arg)
5453 pass_logfilename_prefix = arg;
5454 #if CONFIG_LIBX264_ENCODER
5455 return opt_default(opt, arg);
5461 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5463 char *s = av_asprintf("%s:%c", opt + 1, *opt);
5464 int ret = parse_option(o, s, arg, options);
5469 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5471 if(!strcmp(opt, "b")){
5472 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5473 return parse_option(o, "b:v", arg, options);
5475 return opt_default(opt, arg);
5478 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5482 if(!strcmp(opt, "qscale")){
5483 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5484 return parse_option(o, "q:v", arg, options);
5486 s = av_asprintf("q%s", opt + 6);
5487 ret = parse_option(o, s, arg, options);
5492 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5494 if(!strcmp(opt, "profile")){
5495 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5496 return parse_option(o, "profile:v", arg, options);
5498 return opt_default(opt, arg);
5501 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5503 return parse_option(o, "filter:v", arg, options);
5506 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
5508 return parse_option(o, "filter:a", arg, options);
5511 static int opt_vsync(const char *opt, const char *arg)
5513 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
5514 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
5515 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5516 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
5518 if (video_sync_method == VSYNC_AUTO)
5519 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5523 static int opt_deinterlace(const char *opt, const char *arg)
5525 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5530 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5532 int idx = locate_option(argc, argv, options, "cpuflags");
5533 if (idx && argv[idx + 1])
5534 opt_cpuflags("cpuflags", argv[idx + 1]);
5537 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5539 char layout_str[32];
5542 int ret, channels, ac_str_size;
5545 layout = av_get_channel_layout(arg);
5547 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5548 return AVERROR(EINVAL);
5550 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5551 ret = opt_default(opt, layout_str);
5555 /* set 'ac' option based on channel layout */
5556 channels = av_get_channel_layout_nb_channels(layout);
5557 snprintf(layout_str, sizeof(layout_str), "%d", channels);
5558 stream_str = strchr(opt, ':');
5559 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5560 ac_str = av_mallocz(ac_str_size);
5562 return AVERROR(ENOMEM);
5563 av_strlcpy(ac_str, "ac", 3);
5565 av_strlcat(ac_str, stream_str, ac_str_size);
5566 ret = parse_option(o, ac_str, layout_str, options);
5572 static int opt_filter_complex(const char *opt, const char *arg)
5574 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5575 &nb_filtergraphs, nb_filtergraphs + 1);
5576 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5577 return AVERROR(ENOMEM);
5578 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
5579 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5583 #define OFFSET(x) offsetof(OptionsContext, x)
5584 static const OptionDef options[] = {
5586 #include "cmdutils_common_opts.h"
5587 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5588 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5589 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5590 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5591 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5592 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5593 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5594 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5595 { "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]" },
5596 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5597 "outfile[,metadata]:infile[,metadata]" },
5598 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
5599 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5600 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5601 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5602 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5603 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5604 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5605 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5606 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5607 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5608 "add timings for benchmarking" },
5609 { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5610 "add timings for each task" },
5611 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5612 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5613 "dump each input packet" },
5614 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5615 "when dumping packets, also dump the payload" },
5616 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5617 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5618 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5619 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5620 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5621 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
5622 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
5623 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5624 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5625 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5626 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5627 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5628 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5629 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5630 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5631 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5632 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5633 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5634 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5635 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5636 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5637 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5638 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5641 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5642 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5643 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5644 { "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" },
5645 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5646 { "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" },
5647 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5648 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5649 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5650 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5651 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5652 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5653 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5654 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5655 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5656 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5657 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5658 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5659 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5660 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5661 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5662 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5663 "use same quantizer as source (implies VBR)" },
5664 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5665 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5666 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5667 "this option is deprecated, use the yadif filter instead" },
5668 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5669 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5670 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5671 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5672 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5673 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5674 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5675 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5676 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5677 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5678 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5679 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5680 { "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" },
5681 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5684 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5685 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5686 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5687 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5688 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5689 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5690 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5691 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5692 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5693 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5694 { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
5696 /* subtitle options */
5697 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5698 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5699 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5702 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5703 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5704 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5707 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5708 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5710 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5711 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5712 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5714 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5715 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5716 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5717 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5718 /* data codec support */
5719 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5720 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5722 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5726 int main(int argc, char **argv)
5728 OptionsContext o = { 0 };
5731 reset_options(&o, 0);
5733 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5734 parse_loglevel(argc, argv, options);
5736 if(argc>1 && !strcmp(argv[1], "-d")){
5738 av_log_set_callback(log_callback_null);
5743 avcodec_register_all();
5745 avdevice_register_all();
5747 avfilter_register_all();
5749 avformat_network_init();
5751 show_banner(argc, argv, options);
5755 parse_cpuflags(argc, argv, options);
5758 parse_options(&o, argc, argv, options, opt_output_file);
5760 if (nb_output_files <= 0 && nb_input_files == 0) {
5762 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5766 /* file converter / grab */
5767 if (nb_output_files <= 0) {
5768 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5772 if (nb_input_files == 0) {
5773 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5777 current_time = ti = getutime();
5778 if (transcode() < 0)
5780 ti = getutime() - ti;
5782 int maxrss = getmaxrss() / 1024;
5783 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);