2 * Copyright (c) 2000-2003 Fabrice Bellard
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * multimedia converter based on the FFmpeg libraries
35 #include "libavformat/avformat.h"
36 #include "libavdevice/avdevice.h"
37 #include "libswscale/swscale.h"
38 #include "libswresample/swresample.h"
39 #include "libavutil/opt.h"
40 #include "libavutil/audioconvert.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/samplefmt.h"
43 #include "libavutil/colorspace.h"
44 #include "libavutil/fifo.h"
45 #include "libavutil/intreadwrite.h"
46 #include "libavutil/dict.h"
47 #include "libavutil/mathematics.h"
48 #include "libavutil/pixdesc.h"
49 #include "libavutil/avstring.h"
50 #include "libavutil/libm.h"
51 #include "libavutil/imgutils.h"
52 #include "libavutil/timestamp.h"
53 #include "libavutil/bprint.h"
54 #include "libavformat/os_support.h"
56 #include "libavformat/ffm.h" // not public API
58 # include "libavfilter/avcodec.h"
59 # include "libavfilter/avfilter.h"
60 # include "libavfilter/avfiltergraph.h"
61 # include "libavfilter/buffersrc.h"
62 # include "libavfilter/buffersink.h"
64 #if HAVE_SYS_RESOURCE_H
65 #include <sys/types.h>
67 #include <sys/resource.h>
68 #elif HAVE_GETPROCESSTIMES
71 #if HAVE_GETPROCESSMEMORYINFO
77 #include <sys/select.h>
82 #include <sys/ioctl.h>
92 #include "libavutil/avassert.h"
95 #define VSYNC_PASSTHROUGH 0
98 #define VSYNC_DROP 0xff
102 const char program_name[] = "ffmpeg";
103 const int program_birth_year = 2000;
105 /* select an input stream for an output stream */
106 typedef struct StreamMap {
107 int disabled; /** 1 is this mapping is disabled by a negative map */
111 int sync_stream_index;
112 char *linklabel; /** name of an output link, for mapping lavfi outputs */
116 int file_idx, stream_idx, channel_idx; // input
117 int ofile_idx, ostream_idx; // output
120 static const OptionDef options[];
122 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
124 static int frame_bits_per_raw_sample = 0;
125 static int video_discard = 0;
126 static int same_quant = 0;
127 static int do_deinterlace = 0;
128 static int intra_dc_precision = 8;
129 static int qp_hist = 0;
130 static int intra_only = 0;
131 static const char *video_codec_name = NULL;
132 static const char *audio_codec_name = NULL;
133 static const char *subtitle_codec_name = NULL;
135 static int file_overwrite = 0;
136 static int no_file_overwrite = 0;
137 static int do_benchmark = 0;
138 static int do_benchmark_all = 0;
139 static int do_hex_dump = 0;
140 static int do_pkt_dump = 0;
141 static int do_psnr = 0;
142 static int do_pass = 0;
143 static const char *pass_logfilename_prefix;
144 static int video_sync_method = VSYNC_AUTO;
145 static int audio_sync_method = 0;
146 static float audio_drift_threshold = 0.1;
147 static int copy_ts = 0;
148 static int copy_tb = -1;
149 static int opt_shortest = 0;
150 static char *vstats_filename;
151 static FILE *vstats_file;
153 static int audio_volume = 256;
155 static int exit_on_error = 0;
156 static int using_stdin = 0;
157 static int run_as_daemon = 0;
158 static volatile int received_nb_signals = 0;
159 static int64_t video_size = 0;
160 static int64_t audio_size = 0;
161 static int64_t extra_size = 0;
162 static int nb_frames_dup = 0;
163 static int nb_frames_drop = 0;
164 static int input_sync;
166 static float dts_delta_threshold = 10;
167 static float dts_error_threshold = 3600*30;
169 static int print_stats = 1;
170 static int debug_ts = 0;
171 static int current_time;
173 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
175 typedef struct InputFilter {
176 AVFilterContext *filter;
177 struct InputStream *ist;
178 struct FilterGraph *graph;
182 typedef struct OutputFilter {
183 AVFilterContext *filter;
184 struct OutputStream *ost;
185 struct FilterGraph *graph;
188 /* temporary storage until stream maps are processed */
189 AVFilterInOut *out_tmp;
192 typedef struct FilterGraph {
194 const char *graph_desc;
196 AVFilterGraph *graph;
198 InputFilter **inputs;
200 OutputFilter **outputs;
204 typedef struct FrameBuffer {
210 enum PixelFormat pix_fmt;
213 struct InputStream *ist;
214 struct FrameBuffer *next;
217 typedef struct InputStream {
220 int discard; /* true if stream data should be discarded */
221 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
223 AVFrame *decoded_frame;
225 int64_t start; /* time when read started */
226 /* predicted dts of the next packet read for this stream or (when there are
227 * several frames in a packet) of the next frame in current packet */
229 /* dts of the last packet read for this stream */
232 int64_t next_pts; /* synthetic pts for the next decode frame */
233 int64_t pts; /* current pts of the decoded frame */
235 int is_start; /* is 1 at the start and after a discontinuity */
237 int showed_multi_packet_warning;
239 AVRational framerate; /* framerate forced with -r */
244 int resample_pix_fmt;
246 int resample_sample_fmt;
247 int resample_sample_rate;
248 int resample_channels;
249 uint64_t resample_channel_layout;
251 /* a pool of free buffers for decoded data */
252 FrameBuffer *buffer_pool;
255 /* decoded data from this stream goes into all those filters
256 * currently video and audio only */
257 InputFilter **filters;
261 typedef struct InputFile {
262 AVFormatContext *ctx;
263 int eof_reached; /* true if eof reached */
264 int ist_index; /* index of first stream in input_streams */
265 int buffer_size; /* current total buffer size */
267 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
268 from ctx.nb_streams if new streams appear during av_read_frame() */
272 typedef struct OutputStream {
273 int file_index; /* file index */
274 int index; /* stream index in the output file */
275 int source_index; /* InputStream index */
276 AVStream *st; /* stream in the output file */
277 int encoding_needed; /* true if encoding needed for this stream */
279 /* input pts and corresponding output pts
281 struct InputStream *sync_ist; /* input stream to sync against */
282 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
283 /* pts of the first frame encoded for this stream, used for limiting
286 AVBitStreamFilterContext *bitstream_filters;
289 AVFrame *filtered_frame;
292 AVRational frame_rate;
296 float frame_aspect_ratio;
299 /* forced key frames */
300 int64_t *forced_kf_pts;
305 int audio_channels_map[SWR_CH_MAX]; /* list of the channels id to pick from the source stream */
306 int audio_channels_mapped; /* number of channels in audio_channels_map */
310 OutputFilter *filter;
314 int64_t swr_dither_method;
315 double swr_dither_scale;
317 int is_past_recording_time;
319 const char *attachment_filename;
320 int copy_initial_nonkeyframes;
328 /* init terminal so that we can grab keys */
329 static struct termios oldtty;
330 static int restore_tty;
333 typedef struct OutputFile {
334 AVFormatContext *ctx;
336 int ost_index; /* index of the first stream in output_streams */
337 int64_t recording_time; /* desired length of the resulting file in microseconds */
338 int64_t start_time; /* start time in microseconds */
339 uint64_t limit_filesize; /* filesize limit expressed in bytes */
342 static InputStream **input_streams = NULL;
343 static int nb_input_streams = 0;
344 static InputFile **input_files = NULL;
345 static int nb_input_files = 0;
347 static OutputStream **output_streams = NULL;
348 static int nb_output_streams = 0;
349 static OutputFile **output_files = NULL;
350 static int nb_output_files = 0;
352 static FilterGraph **filtergraphs;
355 typedef struct OptionsContext {
356 /* input/output options */
360 SpecifierOpt *codec_names;
362 SpecifierOpt *audio_channels;
363 int nb_audio_channels;
364 SpecifierOpt *audio_sample_rate;
365 int nb_audio_sample_rate;
366 SpecifierOpt *frame_rates;
368 SpecifierOpt *frame_sizes;
370 SpecifierOpt *frame_pix_fmts;
371 int nb_frame_pix_fmts;
374 int64_t input_ts_offset;
377 SpecifierOpt *ts_scale;
379 SpecifierOpt *dump_attachment;
380 int nb_dump_attachment;
383 StreamMap *stream_maps;
385 AudioChannelMap *audio_channel_maps; /* one info entry per -map_channel */
386 int nb_audio_channel_maps; /* number of (valid) -map_channel settings */
387 int metadata_global_manual;
388 int metadata_streams_manual;
389 int metadata_chapters_manual;
390 const char **attachments;
393 int chapters_input_file;
395 int64_t recording_time;
396 uint64_t limit_filesize;
402 int subtitle_disable;
405 /* indexed by output file stream index */
409 SpecifierOpt *metadata;
411 SpecifierOpt *max_frames;
413 SpecifierOpt *bitstream_filters;
414 int nb_bitstream_filters;
415 SpecifierOpt *codec_tags;
417 SpecifierOpt *sample_fmts;
419 SpecifierOpt *qscale;
421 SpecifierOpt *forced_key_frames;
422 int nb_forced_key_frames;
423 SpecifierOpt *force_fps;
425 SpecifierOpt *frame_aspect_ratios;
426 int nb_frame_aspect_ratios;
427 SpecifierOpt *rc_overrides;
429 SpecifierOpt *intra_matrices;
430 int nb_intra_matrices;
431 SpecifierOpt *inter_matrices;
432 int nb_inter_matrices;
433 SpecifierOpt *top_field_first;
434 int nb_top_field_first;
435 SpecifierOpt *metadata_map;
437 SpecifierOpt *presets;
439 SpecifierOpt *copy_initial_nonkeyframes;
440 int nb_copy_initial_nonkeyframes;
441 SpecifierOpt *filters;
445 static void do_video_stats(AVFormatContext *os, OutputStream *ost, int frame_size);
447 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
450 for (i = 0; i < o->nb_ ## name; i++) {\
451 char *spec = o->name[i].specifier;\
452 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
453 outvar = o->name[i].u.type;\
459 static int64_t getutime(void)
462 struct rusage rusage;
464 getrusage(RUSAGE_SELF, &rusage);
465 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
466 #elif HAVE_GETPROCESSTIMES
469 proc = GetCurrentProcess();
470 GetProcessTimes(proc, &c, &e, &k, &u);
471 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
477 static void update_benchmark(const char *fmt, ...)
479 if (do_benchmark_all) {
480 int64_t t = getutime();
486 vsnprintf(buf, sizeof(buf), fmt, va);
488 printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
494 static void reset_options(OptionsContext *o, int is_input)
496 const OptionDef *po = options;
497 OptionsContext bak= *o;
500 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
502 void *dst = (uint8_t*)o + po->u.off;
504 if (po->flags & OPT_SPEC) {
505 SpecifierOpt **so = dst;
506 int i, *count = (int*)(so + 1);
507 for (i = 0; i < *count; i++) {
508 av_freep(&(*so)[i].specifier);
509 if (po->flags & OPT_STRING)
510 av_freep(&(*so)[i].u.str);
514 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
519 for (i = 0; i < o->nb_stream_maps; i++)
520 av_freep(&o->stream_maps[i].linklabel);
521 av_freep(&o->stream_maps);
522 av_freep(&o->audio_channel_maps);
523 av_freep(&o->streamid_map);
525 memset(o, 0, sizeof(*o));
527 if(is_input) o->recording_time = bak.recording_time;
528 else o->recording_time = INT64_MAX;
529 o->mux_max_delay = 0.7;
530 o->limit_filesize = UINT64_MAX;
531 o->chapters_input_file = INT_MAX;
537 static int alloc_buffer(InputStream *ist, AVCodecContext *s, FrameBuffer **pbuf)
539 FrameBuffer *buf = av_mallocz(sizeof(*buf));
541 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
542 int h_chroma_shift, v_chroma_shift;
543 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
544 int w = s->width, h = s->height;
547 return AVERROR(ENOMEM);
549 avcodec_align_dimensions(s, &w, &h);
551 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
556 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
557 s->pix_fmt, 32)) < 0) {
561 /* XXX this shouldn't be needed, but some tests break without this line
562 * those decoders are buggy and need to be fixed.
563 * the following tests fail:
564 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
566 memset(buf->base[0], 128, ret);
568 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
569 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
570 const int h_shift = i==0 ? 0 : h_chroma_shift;
571 const int v_shift = i==0 ? 0 : v_chroma_shift;
572 if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1] || !buf->base[i])
573 buf->data[i] = buf->base[i];
575 buf->data[i] = buf->base[i] +
576 FFALIGN((buf->linesize[i]*edge >> v_shift) +
577 (pixel_size*edge >> h_shift), 32);
581 buf->pix_fmt = s->pix_fmt;
588 static void free_buffer_pool(InputStream *ist)
590 FrameBuffer *buf = ist->buffer_pool;
592 ist->buffer_pool = buf->next;
593 av_freep(&buf->base[0]);
595 buf = ist->buffer_pool;
599 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
601 av_assert0(buf->refcount > 0);
603 if (!buf->refcount) {
605 for(tmp= ist->buffer_pool; tmp; tmp= tmp->next)
606 av_assert1(tmp != buf);
607 buf->next = ist->buffer_pool;
608 ist->buffer_pool = buf;
612 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
614 InputStream *ist = s->opaque;
618 if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0)
621 if (!ist->buffer_pool && (ret = alloc_buffer(ist, s, &ist->buffer_pool)) < 0)
624 buf = ist->buffer_pool;
625 ist->buffer_pool = buf->next;
627 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
628 av_freep(&buf->base[0]);
630 if ((ret = alloc_buffer(ist, s, &buf)) < 0)
633 av_assert0(!buf->refcount);
637 frame->type = FF_BUFFER_TYPE_USER;
638 frame->extended_data = frame->data;
639 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
640 frame->width = buf->w;
641 frame->height = buf->h;
642 frame->format = buf->pix_fmt;
643 frame->sample_aspect_ratio = s->sample_aspect_ratio;
645 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
646 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
647 frame->data[i] = buf->data[i];
648 frame->linesize[i] = buf->linesize[i];
654 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
656 InputStream *ist = s->opaque;
657 FrameBuffer *buf = frame->opaque;
660 if(frame->type!=FF_BUFFER_TYPE_USER)
661 return avcodec_default_release_buffer(s, frame);
663 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
664 frame->data[i] = NULL;
666 unref_buffer(ist, buf);
669 static void filter_release_buffer(AVFilterBuffer *fb)
671 FrameBuffer *buf = fb->priv;
673 unref_buffer(buf->ist, buf);
676 static enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target)
678 if (codec && codec->pix_fmts) {
679 const enum PixelFormat *p = codec->pix_fmts;
680 int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0;
681 enum PixelFormat best= PIX_FMT_NONE;
682 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
683 if (st->codec->codec_id == CODEC_ID_MJPEG) {
684 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
685 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
686 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
687 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
690 for (; *p != PIX_FMT_NONE; p++) {
691 best= avcodec_find_best_pix_fmt2(best, *p, target, has_alpha, NULL);
695 if (*p == PIX_FMT_NONE) {
696 if (target != PIX_FMT_NONE)
697 av_log(NULL, AV_LOG_WARNING,
698 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
699 av_pix_fmt_descriptors[target].name,
701 av_pix_fmt_descriptors[best].name);
708 static char *choose_pix_fmts(OutputStream *ost)
710 if (ost->keep_pix_fmt) {
712 avfilter_graph_set_auto_convert(ost->filter->graph->graph,
713 AVFILTER_AUTO_CONVERT_NONE);
714 if (ost->st->codec->pix_fmt == PIX_FMT_NONE)
716 return av_strdup(av_get_pix_fmt_name(ost->st->codec->pix_fmt));
718 if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
719 return av_strdup(av_get_pix_fmt_name(choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt)));
720 } else if (ost->enc && ost->enc->pix_fmts) {
721 const enum PixelFormat *p;
722 AVIOContext *s = NULL;
726 if (avio_open_dyn_buf(&s) < 0)
729 p = ost->enc->pix_fmts;
730 if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
731 if (ost->st->codec->codec_id == CODEC_ID_MJPEG) {
732 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
733 } else if (ost->st->codec->codec_id == CODEC_ID_LJPEG) {
734 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
735 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
739 for (; *p != PIX_FMT_NONE; p++) {
740 const char *name = av_get_pix_fmt_name(*p);
741 avio_printf(s, "%s:", name);
743 len = avio_close_dyn_buf(s, &ret);
751 * Define a function for building a string containing a list of
754 #define DEF_CHOOSE_FORMAT(type, var, supported_list, none, get_name, separator) \
755 static char *choose_ ## var ## s(OutputStream *ost) \
757 if (ost->st->codec->var != none) { \
758 get_name(ost->st->codec->var); \
759 return av_strdup(name); \
760 } else if (ost->enc->supported_list) { \
762 AVIOContext *s = NULL; \
766 if (avio_open_dyn_buf(&s) < 0) \
769 for (p = ost->enc->supported_list; *p != none; p++) { \
771 avio_printf(s, "%s" separator, name); \
773 len = avio_close_dyn_buf(s, &ret); \
780 #define GET_PIX_FMT_NAME(pix_fmt)\
781 const char *name = av_get_pix_fmt_name(pix_fmt);
783 // DEF_CHOOSE_FORMAT(enum PixelFormat, pix_fmt, pix_fmts, PIX_FMT_NONE,
784 // GET_PIX_FMT_NAME, ":")
786 #define GET_SAMPLE_FMT_NAME(sample_fmt)\
787 const char *name = av_get_sample_fmt_name(sample_fmt)
789 DEF_CHOOSE_FORMAT(enum AVSampleFormat, sample_fmt, sample_fmts,
790 AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME, ",")
792 #define GET_SAMPLE_RATE_NAME(rate)\
794 snprintf(name, sizeof(name), "%d", rate);
796 DEF_CHOOSE_FORMAT(int, sample_rate, supported_samplerates, 0,
797 GET_SAMPLE_RATE_NAME, ",")
799 #define GET_CH_LAYOUT_NAME(ch_layout)\
801 snprintf(name, sizeof(name), "0x%"PRIx64, ch_layout);
803 DEF_CHOOSE_FORMAT(uint64_t, channel_layout, channel_layouts, 0,
804 GET_CH_LAYOUT_NAME, ",")
806 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
808 FilterGraph *fg = av_mallocz(sizeof(*fg));
812 fg->index = nb_filtergraphs;
814 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
816 if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
818 fg->outputs[0]->ost = ost;
819 fg->outputs[0]->graph = fg;
821 ost->filter = fg->outputs[0];
823 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
825 if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
827 fg->inputs[0]->ist = ist;
828 fg->inputs[0]->graph = fg;
830 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
831 &ist->nb_filters, ist->nb_filters + 1);
832 ist->filters[ist->nb_filters - 1] = fg->inputs[0];
834 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
835 &nb_filtergraphs, nb_filtergraphs + 1);
836 filtergraphs[nb_filtergraphs - 1] = fg;
841 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
843 InputStream *ist = NULL;
844 enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
847 // TODO: support other filter types
848 if (type != AVMEDIA_TYPE_VIDEO && type != AVMEDIA_TYPE_AUDIO) {
849 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters supported "
858 int file_idx = strtol(in->name, &p, 0);
860 if (file_idx < 0 || file_idx >= nb_input_files) {
861 av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n",
862 file_idx, fg->graph_desc);
865 s = input_files[file_idx]->ctx;
867 for (i = 0; i < s->nb_streams; i++) {
868 if (s->streams[i]->codec->codec_type != type)
870 if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
876 av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
877 "matches no streams.\n", p, fg->graph_desc);
880 ist = input_streams[input_files[file_idx]->ist_index + st->index];
882 /* find the first unused stream of corresponding type */
883 for (i = 0; i < nb_input_streams; i++) {
884 ist = input_streams[i];
885 if (ist->st->codec->codec_type == type && ist->discard)
888 if (i == nb_input_streams) {
889 av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
890 "unlabeled input pad %d on filter %s", in->pad_idx,
891 in->filter_ctx->name);
896 ist->decoding_needed = 1;
897 ist->st->discard = AVDISCARD_NONE;
899 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
900 &fg->nb_inputs, fg->nb_inputs + 1);
901 if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
903 fg->inputs[fg->nb_inputs - 1]->ist = ist;
904 fg->inputs[fg->nb_inputs - 1]->graph = fg;
906 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
907 &ist->nb_filters, ist->nb_filters + 1);
908 ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
911 static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
914 OutputStream *ost = ofilter->ost;
915 AVCodecContext *codec = ost->st->codec;
916 AVFilterContext *last_filter = out->filter_ctx;
917 int pad_idx = out->pad_idx;
919 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
921 #if FF_API_OLD_VSINK_API
922 ret = avfilter_graph_create_filter(&ofilter->filter,
923 avfilter_get_by_name("buffersink"),
924 "out", NULL, NULL, fg->graph);
926 ret = avfilter_graph_create_filter(&ofilter->filter,
927 avfilter_get_by_name("buffersink"),
928 "out", NULL, buffersink_params, fg->graph);
930 av_freep(&buffersink_params);
935 if (codec->width || codec->height) {
937 AVFilterContext *filter;
939 snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
942 (unsigned)ost->sws_flags);
943 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
944 NULL, args, NULL, fg->graph)) < 0)
946 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
949 last_filter = filter;
953 if ((pix_fmts = choose_pix_fmts(ost))) {
954 AVFilterContext *filter;
955 if ((ret = avfilter_graph_create_filter(&filter,
956 avfilter_get_by_name("format"),
957 "format", pix_fmts, NULL,
960 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
963 last_filter = filter;
968 if (ost->frame_rate.num && 0) {
969 AVFilterContext *fps;
972 snprintf(args, sizeof(args), "fps=%d/%d", ost->frame_rate.num,
973 ost->frame_rate.den);
974 ret = avfilter_graph_create_filter(&fps, avfilter_get_by_name("fps"),
975 "fps", args, NULL, fg->graph);
979 ret = avfilter_link(last_filter, pad_idx, fps, 0);
986 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
992 static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
994 OutputStream *ost = ofilter->ost;
995 AVCodecContext *codec = ost->st->codec;
996 AVFilterContext *last_filter = out->filter_ctx;
997 int pad_idx = out->pad_idx;
998 char *sample_fmts, *sample_rates, *channel_layouts;
1001 ret = avfilter_graph_create_filter(&ofilter->filter,
1002 avfilter_get_by_name("abuffersink_old"),
1003 "out", NULL, NULL, fg->graph);
1007 #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \
1008 AVFilterContext *filt_ctx; \
1010 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
1011 "similarly to -af " filter_name "=%s.\n", arg); \
1013 ret = avfilter_graph_create_filter(&filt_ctx, \
1014 avfilter_get_by_name(filter_name), \
1015 filter_name, arg, NULL, fg->graph); \
1019 ret = avfilter_link(last_filter, pad_idx, filt_ctx, 0); \
1023 last_filter = filt_ctx; \
1026 if (ost->audio_channels_mapped) {
1029 av_bprint_init(&pan_buf, 256, 8192);
1030 av_bprintf(&pan_buf, "0x%"PRIx64,
1031 av_get_default_channel_layout(ost->audio_channels_mapped));
1032 for (i = 0; i < ost->audio_channels_mapped; i++)
1033 if (ost->audio_channels_map[i] != -1)
1034 av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
1036 AUTO_INSERT_FILTER("-map_channel", "pan", pan_buf.str);
1037 av_bprint_finalize(&pan_buf, NULL);
1040 if (codec->channels && !codec->channel_layout)
1041 codec->channel_layout = av_get_default_channel_layout(codec->channels);
1043 sample_fmts = choose_sample_fmts(ost);
1044 sample_rates = choose_sample_rates(ost);
1045 channel_layouts = choose_channel_layouts(ost);
1046 if (sample_fmts || sample_rates || channel_layouts) {
1047 AVFilterContext *format;
1052 len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:",
1055 len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:",
1057 if (channel_layouts)
1058 len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:",
1062 av_freep(&sample_fmts);
1063 av_freep(&sample_rates);
1064 av_freep(&channel_layouts);
1066 ret = avfilter_graph_create_filter(&format,
1067 avfilter_get_by_name("aformat"),
1068 "aformat", args, NULL, fg->graph);
1072 ret = avfilter_link(last_filter, pad_idx, format, 0);
1076 last_filter = format;
1080 if (audio_sync_method > 0 && 0) {
1081 char args[256] = {0};
1083 av_strlcatf(args, sizeof(args), "min_comp=0.001:min_hard_comp=%f", audio_drift_threshold);
1084 if (audio_sync_method > 1)
1085 av_strlcatf(args, sizeof(args), ":max_soft_comp=%d", -audio_sync_method);
1086 AUTO_INSERT_FILTER("-async", "aresample", args);
1089 if (audio_volume != 256) {
1092 snprintf(args, sizeof(args), "%f", audio_volume / 256.);
1093 AUTO_INSERT_FILTER("-vol", "volume", args);
1096 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
1102 #define DESCRIBE_FILTER_LINK(f, inout, in) \
1104 AVFilterContext *ctx = inout->filter_ctx; \
1105 AVFilterPad *pads = in ? ctx->input_pads : ctx->output_pads; \
1106 int nb_pads = in ? ctx->input_count : ctx->output_count; \
1109 if (avio_open_dyn_buf(&pb) < 0) \
1112 avio_printf(pb, "%s", ctx->filter->name); \
1114 avio_printf(pb, ":%s", pads[inout->pad_idx].name); \
1116 avio_close_dyn_buf(pb, &f->name); \
1119 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
1121 av_freep(&ofilter->name);
1122 DESCRIBE_FILTER_LINK(ofilter, out, 0);
1124 switch (out->filter_ctx->output_pads[out->pad_idx].type) {
1125 case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, ofilter, out);
1126 case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, ofilter, out);
1127 default: av_assert0(0);
1131 static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
1134 AVFilterContext *first_filter = in->filter_ctx;
1135 AVFilter *filter = avfilter_get_by_name("buffer");
1136 InputStream *ist = ifilter->ist;
1137 AVRational tb = ist->framerate.num ? (AVRational){ist->framerate.den,
1138 ist->framerate.num} :
1142 int pad_idx = in->pad_idx;
1145 sar = ist->st->sample_aspect_ratio.num ?
1146 ist->st->sample_aspect_ratio :
1147 ist->st->codec->sample_aspect_ratio;
1148 snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,
1149 ist->st->codec->height, ist->st->codec->pix_fmt,
1150 tb.num, tb.den, sar.num, sar.den,
1151 SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
1153 if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter, in->name,
1154 args, NULL, fg->graph)) < 0)
1157 if (ist->framerate.num) {
1158 AVFilterContext *setpts;
1160 if ((ret = avfilter_graph_create_filter(&setpts,
1161 avfilter_get_by_name("setpts"),
1162 "setpts", "N", NULL,
1166 if ((ret = avfilter_link(setpts, 0, first_filter, pad_idx)) < 0)
1169 first_filter = setpts;
1173 if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
1178 static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter,
1181 AVFilterContext *first_filter = in->filter_ctx;
1182 AVFilter *filter = avfilter_get_by_name("abuffer");
1183 InputStream *ist = ifilter->ist;
1184 int pad_idx = in->pad_idx;
1188 snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s"
1189 ":channel_layout=0x%"PRIx64,
1190 ist->st->time_base.num, ist->st->time_base.den,
1191 ist->st->codec->sample_rate,
1192 av_get_sample_fmt_name(ist->st->codec->sample_fmt),
1193 ist->st->codec->channel_layout);
1195 if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter,
1196 in->name, args, NULL,
1200 #define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg) do { \
1201 AVFilterContext *filt_ctx; \
1203 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
1204 "similarly to -af " filter_name "=%s.\n", arg); \
1206 ret = avfilter_graph_create_filter(&filt_ctx, \
1207 avfilter_get_by_name(filter_name), \
1208 filter_name, arg, NULL, fg->graph); \
1212 ret = avfilter_link(filt_ctx, 0, first_filter, pad_idx); \
1216 first_filter = filt_ctx; \
1219 if (audio_sync_method > 0) {
1220 char args[256] = {0};
1222 av_strlcatf(args, sizeof(args), "min_comp=0.001:min_hard_comp=%f", audio_drift_threshold);
1223 if (audio_sync_method > 1)
1224 av_strlcatf(args, sizeof(args), ":max_soft_comp=%f", audio_sync_method/(double)ist->st->codec->sample_rate);
1225 AUTO_INSERT_FILTER_INPUT("-async", "aresample", args);
1228 // if (ost->audio_channels_mapped) {
1230 // AVBPrint pan_buf;
1231 // av_bprint_init(&pan_buf, 256, 8192);
1232 // av_bprintf(&pan_buf, "0x%"PRIx64,
1233 // av_get_default_channel_layout(ost->audio_channels_mapped));
1234 // for (i = 0; i < ost->audio_channels_mapped; i++)
1235 // if (ost->audio_channels_map[i] != -1)
1236 // av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
1237 // AUTO_INSERT_FILTER_INPUT("-map_channel", "pan", pan_buf.str);
1238 // av_bprint_finalize(&pan_buf, NULL);
1241 if (audio_volume != 256) {
1244 snprintf(args, sizeof(args), "%f", audio_volume / 256.);
1245 AUTO_INSERT_FILTER_INPUT("-vol", "volume", args);
1247 if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
1253 static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter,
1256 av_freep(&ifilter->name);
1257 DESCRIBE_FILTER_LINK(ifilter, in, 1);
1259 switch (in->filter_ctx->input_pads[in->pad_idx].type) {
1260 case AVMEDIA_TYPE_VIDEO: return configure_input_video_filter(fg, ifilter, in);
1261 case AVMEDIA_TYPE_AUDIO: return configure_input_audio_filter(fg, ifilter, in);
1262 default: av_assert0(0);
1266 static int configure_filtergraph(FilterGraph *fg)
1268 AVFilterInOut *inputs, *outputs, *cur;
1269 int ret, i, init = !fg->graph, simple = !fg->graph_desc;
1270 const char *graph_desc = simple ? fg->outputs[0]->ost->avfilter :
1273 avfilter_graph_free(&fg->graph);
1274 if (!(fg->graph = avfilter_graph_alloc()))
1275 return AVERROR(ENOMEM);
1278 OutputStream *ost = fg->outputs[0]->ost;
1280 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
1281 fg->graph->scale_sws_opts = av_strdup(args);
1284 if ((ret = avfilter_graph_parse2(fg->graph, graph_desc, &inputs, &outputs)) < 0)
1287 if (simple && (!inputs || inputs->next || !outputs || outputs->next)) {
1288 av_log(NULL, AV_LOG_ERROR, "Simple filtergraph '%s' does not have "
1289 "exactly one input and output.\n", graph_desc);
1290 return AVERROR(EINVAL);
1293 for (cur = inputs; !simple && init && cur; cur = cur->next)
1294 init_input_filter(fg, cur);
1296 for (cur = inputs, i = 0; cur; cur = cur->next, i++)
1297 if ((ret = configure_input_filter(fg, fg->inputs[i], cur)) < 0)
1299 avfilter_inout_free(&inputs);
1301 if (!init || simple) {
1302 /* we already know the mappings between lavfi outputs and output streams,
1303 * so we can finish the setup */
1304 for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1305 configure_output_filter(fg, fg->outputs[i], cur);
1306 avfilter_inout_free(&outputs);
1308 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1311 /* wait until output mappings are processed */
1312 for (cur = outputs; cur;) {
1313 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1314 &fg->nb_outputs, fg->nb_outputs + 1);
1315 if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1317 fg->outputs[fg->nb_outputs - 1]->graph = fg;
1318 fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1320 fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1327 static int configure_complex_filters(void)
1331 for (i = 0; i < nb_filtergraphs; i++)
1332 if (!filtergraphs[i]->graph &&
1333 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1338 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1341 for (i = 0; i < fg->nb_inputs; i++)
1342 if (fg->inputs[i]->ist == ist)
1347 static void term_exit(void)
1349 av_log(NULL, AV_LOG_QUIET, "%s", "");
1352 tcsetattr (0, TCSANOW, &oldtty);
1356 static volatile int received_sigterm = 0;
1358 static void sigterm_handler(int sig)
1360 received_sigterm = sig;
1361 received_nb_signals++;
1363 if(received_nb_signals > 3)
1367 static void term_init(void)
1373 if (tcgetattr (0, &tty) == 0) {
1378 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1379 |INLCR|IGNCR|ICRNL|IXON);
1380 tty.c_oflag |= OPOST;
1381 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1382 tty.c_cflag &= ~(CSIZE|PARENB);
1385 tty.c_cc[VTIME] = 0;
1387 tcsetattr (0, TCSANOW, &tty);
1389 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
1392 avformat_network_deinit();
1394 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
1395 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
1397 signal(SIGXCPU, sigterm_handler);
1401 /* read a key without blocking */
1402 static int read_key(void)
1414 n = select(1, &rfds, NULL, NULL, &tv);
1416 n = read(0, &ch, 1);
1423 # if HAVE_PEEKNAMEDPIPE
1425 static HANDLE input_handle;
1428 input_handle = GetStdHandle(STD_INPUT_HANDLE);
1429 is_pipe = !GetConsoleMode(input_handle, &dw);
1432 if (stdin->_cnt > 0) {
1437 /* When running under a GUI, you will end here. */
1438 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
1455 static int decode_interrupt_cb(void *ctx)
1457 return received_nb_signals > 1;
1460 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1462 void av_noreturn exit_program(int ret)
1466 for (i = 0; i < nb_filtergraphs; i++) {
1467 avfilter_graph_free(&filtergraphs[i]->graph);
1468 for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
1469 av_freep(&filtergraphs[i]->inputs[j]->name);
1470 av_freep(&filtergraphs[i]->inputs[j]);
1472 av_freep(&filtergraphs[i]->inputs);
1473 for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
1474 av_freep(&filtergraphs[i]->outputs[j]->name);
1475 av_freep(&filtergraphs[i]->outputs[j]);
1477 av_freep(&filtergraphs[i]->outputs);
1478 av_freep(&filtergraphs[i]);
1480 av_freep(&filtergraphs);
1483 for (i = 0; i < nb_output_files; i++) {
1484 AVFormatContext *s = output_files[i]->ctx;
1485 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1487 avformat_free_context(s);
1488 av_dict_free(&output_files[i]->opts);
1489 av_freep(&output_files[i]);
1491 for (i = 0; i < nb_output_streams; i++) {
1492 AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1494 AVBitStreamFilterContext *next = bsfc->next;
1495 av_bitstream_filter_close(bsfc);
1498 output_streams[i]->bitstream_filters = NULL;
1500 av_freep(&output_streams[i]->filtered_frame);
1501 av_freep(&output_streams[i]->avfilter);
1502 av_freep(&output_streams[i]);
1504 for (i = 0; i < nb_input_files; i++) {
1505 avformat_close_input(&input_files[i]->ctx);
1506 av_freep(&input_files[i]);
1508 for (i = 0; i < nb_input_streams; i++) {
1509 av_freep(&input_streams[i]->decoded_frame);
1510 av_dict_free(&input_streams[i]->opts);
1511 free_buffer_pool(input_streams[i]);
1512 av_freep(&input_streams[i]->filters);
1513 av_freep(&input_streams[i]);
1517 fclose(vstats_file);
1518 av_free(vstats_filename);
1520 av_freep(&input_streams);
1521 av_freep(&input_files);
1522 av_freep(&output_streams);
1523 av_freep(&output_files);
1528 avformat_network_deinit();
1530 if (received_sigterm) {
1531 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1532 (int) received_sigterm);
1539 static void assert_avoptions(AVDictionary *m)
1541 AVDictionaryEntry *t;
1542 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1543 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1548 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1550 const char *codec_string = encoder ? "encoder" : "decoder";
1552 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1553 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1554 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1555 "results.\nAdd '-strict experimental' if you want to use it.\n",
1556 codec_string, c->codec->name);
1557 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1558 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1559 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1560 codec_string, codec->name);
1565 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
1567 if (codec && codec->sample_fmts) {
1568 const enum AVSampleFormat *p = codec->sample_fmts;
1569 for (; *p != -1; p++) {
1570 if (*p == st->codec->sample_fmt)
1574 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
1575 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
1576 if(av_get_sample_fmt_name(st->codec->sample_fmt))
1577 av_log(NULL, AV_LOG_WARNING,
1578 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
1579 av_get_sample_fmt_name(st->codec->sample_fmt),
1581 av_get_sample_fmt_name(codec->sample_fmts[0]));
1582 st->codec->sample_fmt = codec->sample_fmts[0];
1587 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1589 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1590 AVCodecContext *avctx = ost->st->codec;
1593 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1594 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1595 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1597 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
1598 int64_t max = ost->st->cur_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
1599 if (ost->st->cur_dts && ost->st->cur_dts != AV_NOPTS_VALUE && max > pkt->dts) {
1600 av_log(s, max - pkt->dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG, "Audio timestamp %"PRId64" < %"PRId64" invalid, cliping\n", pkt->dts, max);
1601 pkt->pts = pkt->dts = max;
1606 * Audio encoders may split the packets -- #frames in != #packets out.
1607 * But there is no reordering, so we can limit the number of output packets
1608 * by simply dropping them here.
1609 * Counting encoded video frames needs to be done separately because of
1610 * reordering, see do_video_out()
1612 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1613 if (ost->frame_number >= ost->max_frames) {
1614 av_free_packet(pkt);
1617 ost->frame_number++;
1621 AVPacket new_pkt = *pkt;
1622 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1623 &new_pkt.data, &new_pkt.size,
1624 pkt->data, pkt->size,
1625 pkt->flags & AV_PKT_FLAG_KEY);
1627 av_free_packet(pkt);
1628 new_pkt.destruct = av_destruct_packet;
1630 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1631 bsfc->filter->name, pkt->stream_index,
1632 avctx->codec ? avctx->codec->name : "copy");
1642 pkt->stream_index = ost->index;
1643 ret = av_interleaved_write_frame(s, pkt);
1645 print_error("av_interleaved_write_frame()", ret);
1650 static int check_recording_time(OutputStream *ost)
1652 OutputFile *of = output_files[ost->file_index];
1654 if (of->recording_time != INT64_MAX &&
1655 av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
1656 AV_TIME_BASE_Q) >= 0) {
1657 ost->is_past_recording_time = 1;
1663 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1666 AVCodecContext *enc = ost->st->codec;
1670 av_init_packet(&pkt);
1674 if (!check_recording_time(ost))
1677 if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
1678 frame->pts = ost->sync_opts;
1679 ost->sync_opts = frame->pts + frame->nb_samples;
1681 av_assert0(pkt.size || !pkt.data);
1682 update_benchmark(NULL);
1683 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1684 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1687 update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
1690 if (pkt.pts != AV_NOPTS_VALUE)
1691 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1692 if (pkt.dts != AV_NOPTS_VALUE)
1693 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1694 if (pkt.duration > 0)
1695 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1698 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1699 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1700 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1701 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1704 write_frame(s, &pkt, ost);
1706 audio_size += pkt.size;
1707 av_free_packet(&pkt);
1711 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1713 AVCodecContext *dec;
1714 AVPicture *picture2;
1715 AVPicture picture_tmp;
1718 dec = ist->st->codec;
1720 /* deinterlace : must be done before any resize */
1721 if (do_deinterlace) {
1724 /* create temporary picture */
1725 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1726 buf = av_malloc(size);
1730 picture2 = &picture_tmp;
1731 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1733 if (avpicture_deinterlace(picture2, picture,
1734 dec->pix_fmt, dec->width, dec->height) < 0) {
1735 /* if error, do not deinterlace */
1736 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1745 if (picture != picture2)
1746 *picture = *picture2;
1750 static void do_subtitle_out(AVFormatContext *s,
1756 static uint8_t *subtitle_out = NULL;
1757 int subtitle_out_max_size = 1024 * 1024;
1758 int subtitle_out_size, nb, i;
1759 AVCodecContext *enc;
1762 if (pts == AV_NOPTS_VALUE) {
1763 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1769 enc = ost->st->codec;
1771 if (!subtitle_out) {
1772 subtitle_out = av_malloc(subtitle_out_max_size);
1775 /* Note: DVB subtitle need one packet to draw them and one other
1776 packet to clear them */
1777 /* XXX: signal it in the codec context ? */
1778 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1783 for (i = 0; i < nb; i++) {
1784 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1786 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1787 // start_display_time is required to be 0
1788 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1789 sub->end_display_time -= sub->start_display_time;
1790 sub->start_display_time = 0;
1791 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1792 subtitle_out_max_size, sub);
1793 if (subtitle_out_size < 0) {
1794 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1798 av_init_packet(&pkt);
1799 pkt.data = subtitle_out;
1800 pkt.size = subtitle_out_size;
1801 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1802 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1803 /* XXX: the pts correction is handled here. Maybe handling
1804 it in the codec would be better */
1806 pkt.pts += 90 * sub->start_display_time;
1808 pkt.pts += 90 * sub->end_display_time;
1810 write_frame(s, &pkt, ost);
1814 static void do_video_out(AVFormatContext *s,
1816 AVFrame *in_picture,
1819 int ret, format_video_sync;
1821 AVCodecContext *enc = ost->st->codec;
1823 double sync_ipts, delta;
1824 double duration = 0;
1826 InputStream *ist = NULL;
1828 if (ost->source_index >= 0)
1829 ist = input_streams[ost->source_index];
1831 if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1832 duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));
1834 sync_ipts = in_picture->pts;
1835 delta = sync_ipts - ost->sync_opts + duration;
1837 /* by default, we output a single frame */
1840 format_video_sync = video_sync_method;
1841 if (format_video_sync == VSYNC_AUTO)
1842 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1844 switch (format_video_sync) {
1846 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1849 else if (delta > 1.1)
1850 nb_frames = lrintf(delta);
1855 else if (delta > 0.6)
1856 ost->sync_opts = lrint(sync_ipts);
1859 case VSYNC_PASSTHROUGH:
1860 ost->sync_opts = lrint(sync_ipts);
1866 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1867 if (nb_frames == 0) {
1869 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1871 } else if (nb_frames > 1) {
1872 nb_frames_dup += nb_frames - 1;
1873 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1878 av_init_packet(&pkt);
1882 in_picture->pts = ost->sync_opts;
1884 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1885 enc->codec->id == CODEC_ID_RAWVIDEO) {
1886 /* raw pictures are written as AVPicture structure to
1887 avoid any copies. We support temporarily the older
1889 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1890 enc->coded_frame->top_field_first = in_picture->top_field_first;
1891 pkt.data = (uint8_t *)in_picture;
1892 pkt.size = sizeof(AVPicture);
1893 pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
1894 pkt.flags |= AV_PKT_FLAG_KEY;
1896 write_frame(s, &pkt, ost);
1899 AVFrame big_picture;
1901 big_picture = *in_picture;
1902 /* better than nothing: use input picture interlaced
1904 big_picture.interlaced_frame = in_picture->interlaced_frame;
1905 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1906 if (ost->top_field_first == -1)
1907 big_picture.top_field_first = in_picture->top_field_first;
1909 big_picture.top_field_first = !!ost->top_field_first;
1912 /* handles same_quant here. This is not correct because it may
1913 not be a global option */
1914 big_picture.quality = quality;
1915 if (!enc->me_threshold)
1916 big_picture.pict_type = 0;
1917 if (ost->forced_kf_index < ost->forced_kf_count &&
1918 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1919 big_picture.pict_type = AV_PICTURE_TYPE_I;
1920 ost->forced_kf_index++;
1922 update_benchmark(NULL);
1923 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
1924 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1926 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1931 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
1932 pkt.pts = ost->sync_opts;
1934 if (pkt.pts != AV_NOPTS_VALUE)
1935 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1936 if (pkt.dts != AV_NOPTS_VALUE)
1937 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1940 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1941 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1942 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1943 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1946 write_frame(s, &pkt, ost);
1947 frame_size = pkt.size;
1948 video_size += pkt.size;
1949 av_free_packet(&pkt);
1951 /* if two pass, output log */
1952 if (ost->logfile && enc->stats_out) {
1953 fprintf(ost->logfile, "%s", enc->stats_out);
1959 * For video, number of frames in == number of packets out.
1960 * But there may be reordering, so we can't throw away frames on encoder
1961 * flush, we need to limit them here, before they go into encoder.
1963 ost->frame_number++;
1966 goto duplicate_frame;
1968 if (vstats_filename && frame_size)
1969 do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
1972 static double psnr(double d)
1974 return -10.0 * log(d) / log(10.0);
1977 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1980 AVCodecContext *enc;
1982 double ti1, bitrate, avg_bitrate;
1984 /* this is executed just the first time do_video_stats is called */
1986 vstats_file = fopen(vstats_filename, "w");
1993 enc = ost->st->codec;
1994 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1995 frame_number = ost->frame_number;
1996 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1997 if (enc->flags&CODEC_FLAG_PSNR)
1998 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
2000 fprintf(vstats_file,"f_size= %6d ", frame_size);
2001 /* compute pts value */
2002 ti1 = ost->sync_opts * av_q2d(enc->time_base);
2006 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
2007 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
2008 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
2009 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
2010 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
2014 /* check for new output on any of the filtergraphs */
2015 static int poll_filters(void)
2017 AVFilterBufferRef *picref;
2018 AVFrame *filtered_frame = NULL;
2019 int i, ret, ret_all;
2020 unsigned nb_success, nb_eof;
2024 /* Reap all buffers present in the buffer sinks */
2025 for (i = 0; i < nb_output_streams; i++) {
2026 OutputStream *ost = output_streams[i];
2027 OutputFile *of = output_files[ost->file_index];
2030 if (!ost->filter || ost->is_past_recording_time)
2033 if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
2034 return AVERROR(ENOMEM);
2036 avcodec_get_frame_defaults(ost->filtered_frame);
2037 filtered_frame = ost->filtered_frame;
2040 AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base;
2041 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2042 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
2043 ret = av_buffersink_read_samples(ost->filter->filter, &picref,
2044 ost->st->codec->frame_size);
2047 ret = av_buffersink_read(ost->filter->filter, &picref);
2049 ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
2050 AV_BUFFERSINK_FLAG_NO_REQUEST);
2053 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
2055 av_strerror(ret, buf, sizeof(buf));
2056 av_log(NULL, AV_LOG_WARNING,
2057 "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
2061 frame_pts = AV_NOPTS_VALUE;
2062 if (picref->pts != AV_NOPTS_VALUE) {
2063 filtered_frame->pts = frame_pts = av_rescale_q(picref->pts,
2064 ost->filter->filter->inputs[0]->time_base,
2065 ost->st->codec->time_base) -
2066 av_rescale_q(of->start_time,
2068 ost->st->codec->time_base);
2070 if (of->start_time && filtered_frame->pts < 0) {
2071 avfilter_unref_buffer(picref);
2075 //if (ost->source_index >= 0)
2076 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
2079 switch (ost->filter->filter->inputs[0]->type) {
2080 case AVMEDIA_TYPE_VIDEO:
2081 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);
2082 filtered_frame->pts = frame_pts;
2083 if (!ost->frame_aspect_ratio)
2084 ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
2086 do_video_out(of->ctx, ost, filtered_frame,
2087 same_quant ? ost->last_quality :
2088 ost->st->codec->global_quality);
2090 case AVMEDIA_TYPE_AUDIO:
2091 avfilter_copy_buf_props(filtered_frame, picref);
2092 filtered_frame->pts = frame_pts;
2093 do_audio_out(of->ctx, ost, filtered_frame);
2096 // TODO support subtitle filters
2100 avfilter_unref_buffer(picref);
2103 /* Request frames through all the graphs */
2104 ret_all = nb_success = nb_eof = 0;
2105 for (i = 0; i < nb_filtergraphs; i++) {
2106 ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
2109 } else if (ret == AVERROR_EOF) {
2111 } else if (ret != AVERROR(EAGAIN)) {
2113 av_strerror(ret, buf, sizeof(buf));
2114 av_log(NULL, AV_LOG_WARNING,
2115 "Error in request_frame(): %s\n", buf);
2121 /* Try again if anything succeeded */
2123 return nb_eof == nb_filtergraphs ? AVERROR_EOF : ret_all;
2126 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
2130 AVFormatContext *oc;
2132 AVCodecContext *enc;
2133 int frame_number, vid, i;
2135 int64_t pts = INT64_MAX;
2136 static int64_t last_time = -1;
2137 static int qp_histogram[52];
2138 int hours, mins, secs, us;
2140 if (!print_stats && !is_last_report)
2143 if (!is_last_report) {
2144 if (last_time == -1) {
2145 last_time = cur_time;
2148 if ((cur_time - last_time) < 500000)
2150 last_time = cur_time;
2154 oc = output_files[0]->ctx;
2156 total_size = avio_size(oc->pb);
2157 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
2158 total_size = avio_tell(oc->pb);
2165 for (i = 0; i < nb_output_streams; i++) {
2167 ost = output_streams[i];
2168 enc = ost->st->codec;
2169 if (!ost->stream_copy && enc->coded_frame)
2170 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
2171 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2172 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
2174 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2175 float fps, t = (cur_time-timer_start) / 1000000.0;
2177 frame_number = ost->frame_number;
2178 fps = t > 1 ? frame_number / t : 0;
2179 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
2180 frame_number, fps < 9.95, fps, q);
2182 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
2186 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
2188 for (j = 0; j < 32; j++)
2189 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
2191 if (enc->flags&CODEC_FLAG_PSNR) {
2193 double error, error_sum = 0;
2194 double scale, scale_sum = 0;
2195 char type[3] = { 'Y','U','V' };
2196 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
2197 for (j = 0; j < 3; j++) {
2198 if (is_last_report) {
2199 error = enc->error[j];
2200 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
2202 error = enc->coded_frame->error[j];
2203 scale = enc->width * enc->height * 255.0 * 255.0;
2209 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
2211 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
2215 /* compute min output value */
2216 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
2217 ost->st->time_base, AV_TIME_BASE_Q));
2220 secs = pts / AV_TIME_BASE;
2221 us = pts % AV_TIME_BASE;
2227 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
2229 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2230 "size=%8.0fkB time=", total_size / 1024.0);
2231 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2232 "%02d:%02d:%02d.%02d ", hours, mins, secs,
2233 (100 * us) / AV_TIME_BASE);
2234 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2235 "bitrate=%6.1fkbits/s", bitrate);
2237 if (nb_frames_dup || nb_frames_drop)
2238 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
2239 nb_frames_dup, nb_frames_drop);
2241 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
2245 if (is_last_report) {
2246 int64_t raw= audio_size + video_size + extra_size;
2247 av_log(NULL, AV_LOG_INFO, "\n");
2248 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
2249 video_size / 1024.0,
2250 audio_size / 1024.0,
2251 extra_size / 1024.0,
2252 100.0 * (total_size - raw) / raw
2254 if(video_size + audio_size + extra_size == 0){
2255 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
2260 static void flush_encoders(void)
2264 for (i = 0; i < nb_output_streams; i++) {
2265 OutputStream *ost = output_streams[i];
2266 AVCodecContext *enc = ost->st->codec;
2267 AVFormatContext *os = output_files[ost->file_index]->ctx;
2268 int stop_encoding = 0;
2270 if (!ost->encoding_needed)
2273 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
2275 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
2279 int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
2283 switch (ost->st->codec->codec_type) {
2284 case AVMEDIA_TYPE_AUDIO:
2285 encode = avcodec_encode_audio2;
2289 case AVMEDIA_TYPE_VIDEO:
2290 encode = avcodec_encode_video2;
2301 av_init_packet(&pkt);
2305 update_benchmark(NULL);
2306 ret = encode(enc, &pkt, NULL, &got_packet);
2307 update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index);
2309 av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
2313 if (ost->logfile && enc->stats_out) {
2314 fprintf(ost->logfile, "%s", enc->stats_out);
2320 if (pkt.pts != AV_NOPTS_VALUE)
2321 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2322 if (pkt.dts != AV_NOPTS_VALUE)
2323 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2324 write_frame(os, &pkt, ost);
2334 * Check whether a packet from ist should be written into ost at this time
2336 static int check_output_constraints(InputStream *ist, OutputStream *ost)
2338 OutputFile *of = output_files[ost->file_index];
2339 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
2341 if (ost->source_index != ist_index)
2344 if (of->start_time && ist->pts < of->start_time)
2347 if (of->recording_time != INT64_MAX &&
2348 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
2349 (AVRational){ 1, 1000000 }) >= 0) {
2350 ost->is_past_recording_time = 1;
2357 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2359 OutputFile *of = output_files[ost->file_index];
2360 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
2364 av_init_packet(&opkt);
2366 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2367 !ost->copy_initial_nonkeyframes)
2370 /* force the input stream PTS */
2371 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2372 audio_size += pkt->size;
2373 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2374 video_size += pkt->size;
2378 if (pkt->pts != AV_NOPTS_VALUE)
2379 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
2381 opkt.pts = AV_NOPTS_VALUE;
2383 if (pkt->dts == AV_NOPTS_VALUE)
2384 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
2386 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
2387 opkt.dts -= ost_tb_start_time;
2389 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
2390 opkt.flags = pkt->flags;
2392 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2393 if ( ost->st->codec->codec_id != CODEC_ID_H264
2394 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
2395 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
2396 && ost->st->codec->codec_id != CODEC_ID_VC1
2398 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
2399 opkt.destruct = av_destruct_packet;
2401 opkt.data = pkt->data;
2402 opkt.size = pkt->size;
2404 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2405 /* store AVPicture in AVPacket, as expected by the output format */
2406 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2407 opkt.data = (uint8_t *)&pict;
2408 opkt.size = sizeof(AVPicture);
2409 opkt.flags |= AV_PKT_FLAG_KEY;
2412 write_frame(of->ctx, &opkt, ost);
2413 ost->st->codec->frame_number++;
2414 av_free_packet(&opkt);
2417 static void rate_emu_sleep(InputStream *ist)
2419 if (input_files[ist->file_index]->rate_emu) {
2420 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2421 int64_t now = av_gettime() - ist->start;
2427 static int guess_input_channel_layout(InputStream *ist)
2429 AVCodecContext *dec = ist->st->codec;
2431 if (!dec->channel_layout) {
2432 char layout_name[256];
2434 dec->channel_layout = av_get_default_channel_layout(dec->channels);
2435 if (!dec->channel_layout)
2437 av_get_channel_layout_string(layout_name, sizeof(layout_name),
2438 dec->channels, dec->channel_layout);
2439 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2440 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2445 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2447 AVFrame *decoded_frame;
2448 AVCodecContext *avctx = ist->st->codec;
2449 int i, ret, resample_changed;
2451 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2452 return AVERROR(ENOMEM);
2454 avcodec_get_frame_defaults(ist->decoded_frame);
2455 decoded_frame = ist->decoded_frame;
2457 update_benchmark(NULL);
2458 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2459 update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2463 if (avctx->sample_rate <= 0) {
2464 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2465 return AVERROR_INVALIDDATA;
2469 /* no audio frame */
2471 for (i = 0; i < ist->nb_filters; i++)
2472 av_buffersrc_add_ref(ist->filters[i]->filter, NULL,
2473 AV_BUFFERSRC_FLAG_NO_COPY);
2477 /* if the decoder provides a pts, use it instead of the last packet pts.
2478 the decoder could be delaying output by a packet or more. */
2479 if (decoded_frame->pts != AV_NOPTS_VALUE)
2480 ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2481 else if (pkt->pts != AV_NOPTS_VALUE) {
2482 decoded_frame->pts = pkt->pts;
2483 pkt->pts = AV_NOPTS_VALUE;
2485 decoded_frame->pts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2489 /* increment next_dts to use for the case where the input stream does not
2490 have timestamps or there are multiple frames in the packet */
2491 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2493 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2497 rate_emu_sleep(ist);
2499 resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
2500 ist->resample_channels != avctx->channels ||
2501 ist->resample_channel_layout != decoded_frame->channel_layout ||
2502 ist->resample_sample_rate != decoded_frame->sample_rate;
2503 if (resample_changed) {
2504 char layout1[64], layout2[64];
2506 if (!guess_input_channel_layout(ist)) {
2507 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
2508 "layout for Input Stream #%d.%d\n", ist->file_index,
2512 decoded_frame->channel_layout = avctx->channel_layout;
2514 av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
2515 ist->resample_channel_layout);
2516 av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
2517 decoded_frame->channel_layout);
2519 av_log(NULL, AV_LOG_INFO,
2520 "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",
2521 ist->file_index, ist->st->index,
2522 ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt),
2523 ist->resample_channels, layout1,
2524 decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2525 avctx->channels, layout2);
2527 ist->resample_sample_fmt = decoded_frame->format;
2528 ist->resample_sample_rate = decoded_frame->sample_rate;
2529 ist->resample_channel_layout = decoded_frame->channel_layout;
2530 ist->resample_channels = avctx->channels;
2532 for (i = 0; i < nb_filtergraphs; i++)
2533 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2534 configure_filtergraph(filtergraphs[i]) < 0) {
2535 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2540 for (i = 0; i < ist->nb_filters; i++)
2541 av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0);
2546 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2548 AVFrame *decoded_frame;
2549 void *buffer_to_free = NULL;
2550 int i, ret = 0, resample_changed;
2551 int64_t best_effort_timestamp;
2552 AVRational *frame_sample_aspect;
2555 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2556 return AVERROR(ENOMEM);
2558 avcodec_get_frame_defaults(ist->decoded_frame);
2559 decoded_frame = ist->decoded_frame;
2560 pkt->dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2562 update_benchmark(NULL);
2563 ret = avcodec_decode_video2(ist->st->codec,
2564 decoded_frame, got_output, pkt);
2565 update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2569 quality = same_quant ? decoded_frame->quality : 0;
2571 /* no picture yet */
2573 for (i = 0; i < ist->nb_filters; i++)
2574 av_buffersrc_add_ref(ist->filters[i]->filter, NULL, AV_BUFFERSRC_FLAG_NO_COPY);
2578 if(ist->top_field_first>=0)
2579 decoded_frame->top_field_first = ist->top_field_first;
2581 best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2582 if(best_effort_timestamp != AV_NOPTS_VALUE)
2583 ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2586 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2588 rate_emu_sleep(ist);
2590 if (ist->st->sample_aspect_ratio.num)
2591 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2593 resample_changed = ist->resample_width != decoded_frame->width ||
2594 ist->resample_height != decoded_frame->height ||
2595 ist->resample_pix_fmt != decoded_frame->format;
2596 if (resample_changed) {
2597 av_log(NULL, AV_LOG_INFO,
2598 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2599 ist->file_index, ist->st->index,
2600 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2601 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2603 ist->resample_width = decoded_frame->width;
2604 ist->resample_height = decoded_frame->height;
2605 ist->resample_pix_fmt = decoded_frame->format;
2607 for (i = 0; i < nb_filtergraphs; i++)
2608 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2609 configure_filtergraph(filtergraphs[i]) < 0) {
2610 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2615 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2616 for (i = 0; i < ist->nb_filters; i++) {
2617 int changed = ist->st->codec->width != ist->filters[i]->filter->outputs[0]->w
2618 || ist->st->codec->height != ist->filters[i]->filter->outputs[0]->h
2619 || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2620 // XXX what an ugly hack
2621 if (ist->filters[i]->graph->nb_outputs == 1)
2622 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2624 if (!frame_sample_aspect->num)
2625 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2626 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2627 FrameBuffer *buf = decoded_frame->opaque;
2628 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2629 decoded_frame->data, decoded_frame->linesize,
2630 AV_PERM_READ | AV_PERM_PRESERVE,
2631 ist->st->codec->width, ist->st->codec->height,
2632 ist->st->codec->pix_fmt);
2634 avfilter_copy_frame_props(fb, decoded_frame);
2635 fb->buf->priv = buf;
2636 fb->buf->free = filter_release_buffer;
2638 av_assert0(buf->refcount>0);
2640 av_buffersrc_add_ref(ist->filters[i]->filter, fb,
2641 AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
2642 AV_BUFFERSRC_FLAG_NO_COPY);
2644 if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0)<0) {
2645 av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2651 av_free(buffer_to_free);
2655 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2657 AVSubtitle subtitle;
2658 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2659 &subtitle, got_output, pkt);
2665 rate_emu_sleep(ist);
2667 for (i = 0; i < nb_output_streams; i++) {
2668 OutputStream *ost = output_streams[i];
2670 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2673 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2676 avsubtitle_free(&subtitle);
2680 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2681 static int output_packet(InputStream *ist, const AVPacket *pkt)
2687 if (!ist->saw_first_ts) {
2688 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;
2690 if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2691 ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2692 ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2694 ist->saw_first_ts = 1;
2697 if (ist->next_dts == AV_NOPTS_VALUE)
2698 ist->next_dts = ist->dts;
2699 if (ist->next_pts == AV_NOPTS_VALUE)
2700 ist->next_pts = ist->pts;
2704 av_init_packet(&avpkt);
2712 if (pkt->dts != AV_NOPTS_VALUE) {
2713 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2714 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2715 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2718 // while we have more to decode or while the decoder did output something on EOF
2719 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2723 ist->pts = ist->next_pts;
2724 ist->dts = ist->next_dts;
2726 if (avpkt.size && avpkt.size != pkt->size) {
2727 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2728 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2729 ist->showed_multi_packet_warning = 1;
2732 switch (ist->st->codec->codec_type) {
2733 case AVMEDIA_TYPE_AUDIO:
2734 ret = decode_audio (ist, &avpkt, &got_output);
2736 case AVMEDIA_TYPE_VIDEO:
2737 ret = decode_video (ist, &avpkt, &got_output);
2738 if (avpkt.duration) {
2739 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2740 } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2741 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2742 duration = ((int64_t)AV_TIME_BASE *
2743 ist->st->codec->time_base.num * ticks) /
2744 ist->st->codec->time_base.den;
2748 if(ist->dts != AV_NOPTS_VALUE && duration) {
2749 ist->next_dts += duration;
2751 ist->next_dts = AV_NOPTS_VALUE;
2754 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2756 case AVMEDIA_TYPE_SUBTITLE:
2757 ret = transcode_subtitles(ist, &avpkt, &got_output);
2767 avpkt.pts= AV_NOPTS_VALUE;
2769 // touch data and size only if not EOF
2771 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2781 /* handle stream copy */
2782 if (!ist->decoding_needed) {
2783 rate_emu_sleep(ist);
2784 ist->dts = ist->next_dts;
2785 switch (ist->st->codec->codec_type) {
2786 case AVMEDIA_TYPE_AUDIO:
2787 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2788 ist->st->codec->sample_rate;
2790 case AVMEDIA_TYPE_VIDEO:
2791 if (pkt->duration) {
2792 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2793 } else if(ist->st->codec->time_base.num != 0) {
2794 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2795 ist->next_dts += ((int64_t)AV_TIME_BASE *
2796 ist->st->codec->time_base.num * ticks) /
2797 ist->st->codec->time_base.den;
2801 ist->pts = ist->dts;
2802 ist->next_pts = ist->next_dts;
2804 for (i = 0; pkt && i < nb_output_streams; i++) {
2805 OutputStream *ost = output_streams[i];
2807 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2810 do_streamcopy(ist, ost, pkt);
2816 static void print_sdp(void)
2820 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2824 for (i = 0; i < nb_output_files; i++)
2825 avc[i] = output_files[i]->ctx;
2827 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2828 printf("SDP:\n%s\n", sdp);
2833 static int init_input_stream(int ist_index, char *error, int error_len)
2835 InputStream *ist = input_streams[ist_index];
2837 if (ist->decoding_needed) {
2838 AVCodec *codec = ist->dec;
2840 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2841 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2842 return AVERROR(EINVAL);
2845 ist->dr1 = (codec->capabilities & CODEC_CAP_DR1) && !do_deinterlace;
2846 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2847 ist->st->codec->get_buffer = codec_get_buffer;
2848 ist->st->codec->release_buffer = codec_release_buffer;
2849 ist->st->codec->opaque = ist;
2852 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2853 av_dict_set(&ist->opts, "threads", "auto", 0);
2854 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2855 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2856 ist->file_index, ist->st->index);
2857 return AVERROR(EINVAL);
2859 assert_codec_experimental(ist->st->codec, 0);
2860 assert_avoptions(ist->opts);
2863 ist->next_pts = AV_NOPTS_VALUE;
2864 ist->next_dts = AV_NOPTS_VALUE;
2870 static InputStream *get_input_stream(OutputStream *ost)
2872 if (ost->source_index >= 0)
2873 return input_streams[ost->source_index];
2876 FilterGraph *fg = ost->filter->graph;
2879 for (i = 0; i < fg->nb_inputs; i++)
2880 if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2881 return fg->inputs[i]->ist;
2887 static int transcode_init(void)
2889 int ret = 0, i, j, k;
2890 AVFormatContext *oc;
2891 AVCodecContext *codec, *icodec;
2897 /* init framerate emulation */
2898 for (i = 0; i < nb_input_files; i++) {
2899 InputFile *ifile = input_files[i];
2900 if (ifile->rate_emu)
2901 for (j = 0; j < ifile->nb_streams; j++)
2902 input_streams[j + ifile->ist_index]->start = av_gettime();
2905 /* output stream init */
2906 for (i = 0; i < nb_output_files; i++) {
2907 oc = output_files[i]->ctx;
2908 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2909 av_dump_format(oc, i, oc->filename, 1);
2910 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2911 return AVERROR(EINVAL);
2915 /* init complex filtergraphs */
2916 for (i = 0; i < nb_filtergraphs; i++)
2917 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2920 /* for each output stream, we compute the right encoding parameters */
2921 for (i = 0; i < nb_output_streams; i++) {
2922 ost = output_streams[i];
2923 oc = output_files[ost->file_index]->ctx;
2924 ist = get_input_stream(ost);
2926 if (ost->attachment_filename)
2929 codec = ost->st->codec;
2932 icodec = ist->st->codec;
2934 ost->st->disposition = ist->st->disposition;
2935 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2936 codec->chroma_sample_location = icodec->chroma_sample_location;
2939 if (ost->stream_copy) {
2940 uint64_t extra_size;
2942 av_assert0(ist && !ost->filter);
2944 extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2946 if (extra_size > INT_MAX) {
2947 return AVERROR(EINVAL);
2950 /* if stream_copy is selected, no need to decode or encode */
2951 codec->codec_id = icodec->codec_id;
2952 codec->codec_type = icodec->codec_type;
2954 if (!codec->codec_tag) {
2955 if (!oc->oformat->codec_tag ||
2956 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2957 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2958 codec->codec_tag = icodec->codec_tag;
2961 codec->bit_rate = icodec->bit_rate;
2962 codec->rc_max_rate = icodec->rc_max_rate;
2963 codec->rc_buffer_size = icodec->rc_buffer_size;
2964 codec->field_order = icodec->field_order;
2965 codec->extradata = av_mallocz(extra_size);
2966 if (!codec->extradata) {
2967 return AVERROR(ENOMEM);
2969 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2970 codec->extradata_size= icodec->extradata_size;
2971 codec->bits_per_coded_sample = icodec->bits_per_coded_sample;
2973 codec->time_base = ist->st->time_base;
2975 * Avi is a special case here because it supports variable fps but
2976 * having the fps and timebase differe significantly adds quite some
2979 if(!strcmp(oc->oformat->name, "avi")) {
2980 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2981 && av_q2d(ist->st->time_base) < 1.0/500
2983 codec->time_base = icodec->time_base;
2984 codec->time_base.num *= icodec->ticks_per_frame;
2985 codec->time_base.den *= 2;
2986 codec->ticks_per_frame = 2;
2988 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2989 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2990 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2992 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2993 && av_q2d(ist->st->time_base) < 1.0/500
2995 codec->time_base = icodec->time_base;
2996 codec->time_base.num *= icodec->ticks_per_frame;
2999 av_reduce(&codec->time_base.num, &codec->time_base.den,
3000 codec->time_base.num, codec->time_base.den, INT_MAX);
3002 switch (codec->codec_type) {
3003 case AVMEDIA_TYPE_AUDIO:
3004 if (audio_volume != 256) {
3005 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3008 codec->channel_layout = icodec->channel_layout;
3009 codec->sample_rate = icodec->sample_rate;
3010 codec->channels = icodec->channels;
3011 codec->frame_size = icodec->frame_size;
3012 codec->audio_service_type = icodec->audio_service_type;
3013 codec->block_align = icodec->block_align;
3014 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
3015 codec->block_align= 0;
3016 if(codec->codec_id == CODEC_ID_AC3)
3017 codec->block_align= 0;
3019 case AVMEDIA_TYPE_VIDEO:
3020 codec->pix_fmt = icodec->pix_fmt;
3021 codec->width = icodec->width;
3022 codec->height = icodec->height;
3023 codec->has_b_frames = icodec->has_b_frames;
3024 if (!codec->sample_aspect_ratio.num) {
3025 codec->sample_aspect_ratio =
3026 ost->st->sample_aspect_ratio =
3027 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
3028 ist->st->codec->sample_aspect_ratio.num ?
3029 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
3031 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3033 case AVMEDIA_TYPE_SUBTITLE:
3034 codec->width = icodec->width;
3035 codec->height = icodec->height;
3037 case AVMEDIA_TYPE_DATA:
3038 case AVMEDIA_TYPE_ATTACHMENT:
3045 ost->enc = avcodec_find_encoder(codec->codec_id);
3047 /* should only happen when a default codec is not present. */
3048 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3049 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3050 ret = AVERROR(EINVAL);
3055 ist->decoding_needed = 1;
3056 ost->encoding_needed = 1;
3058 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3059 if (ist && !ost->frame_rate.num)
3060 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
3061 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3062 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3063 ost->frame_rate = ost->enc->supported_framerates[idx];
3068 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3069 codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
3071 fg = init_simple_filtergraph(ist, ost);
3072 if (configure_filtergraph(fg)) {
3073 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3078 switch (codec->codec_type) {
3079 case AVMEDIA_TYPE_AUDIO:
3080 codec->sample_fmt = ost->filter->filter->inputs[0]->format;
3081 codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
3082 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3083 codec->channels = av_get_channel_layout_nb_channels(codec->channel_layout);
3084 codec->time_base = (AVRational){ 1, codec->sample_rate };
3086 case AVMEDIA_TYPE_VIDEO:
3087 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3088 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3089 && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3090 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3091 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3093 for (j = 0; j < ost->forced_kf_count; j++)
3094 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3098 codec->width = ost->filter->filter->inputs[0]->w;
3099 codec->height = ost->filter->filter->inputs[0]->h;
3100 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3101 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3102 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3103 ost->filter->filter->inputs[0]->sample_aspect_ratio;
3104 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3106 if (codec->width != icodec->width ||
3107 codec->height != icodec->height ||
3108 codec->pix_fmt != icodec->pix_fmt) {
3109 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3113 case AVMEDIA_TYPE_SUBTITLE:
3114 codec->time_base = (AVRational){1, 1000};
3121 if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3122 char logfilename[1024];
3125 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3126 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3128 if (!strcmp(ost->enc->name, "libx264")) {
3129 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3131 if (codec->flags & CODEC_FLAG_PASS2) {
3133 size_t logbuffer_size;
3134 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3135 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3139 codec->stats_in = logbuffer;
3141 if (codec->flags & CODEC_FLAG_PASS1) {
3142 f = fopen(logfilename, "wb");
3144 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3145 logfilename, strerror(errno));
3155 /* open each encoder */
3156 for (i = 0; i < nb_output_streams; i++) {
3157 ost = output_streams[i];
3158 if (ost->encoding_needed) {
3159 AVCodec *codec = ost->enc;
3160 AVCodecContext *dec = NULL;
3162 if ((ist = get_input_stream(ost)))
3163 dec = ist->st->codec;
3164 if (dec && dec->subtitle_header) {
3165 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3166 if (!ost->st->codec->subtitle_header) {
3167 ret = AVERROR(ENOMEM);
3170 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3171 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3173 if (!av_dict_get(ost->opts, "threads", NULL, 0))
3174 av_dict_set(&ost->opts, "threads", "auto", 0);
3175 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3176 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3177 ost->file_index, ost->index);
3178 ret = AVERROR(EINVAL);
3181 assert_codec_experimental(ost->st->codec, 1);
3182 assert_avoptions(ost->opts);
3183 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3184 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3185 " It takes bits/s as argument, not kbits/s\n");
3186 extra_size += ost->st->codec->extradata_size;
3188 if (ost->st->codec->me_threshold)
3189 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3193 /* init input streams */
3194 for (i = 0; i < nb_input_streams; i++)
3195 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3198 /* discard unused programs */
3199 for (i = 0; i < nb_input_files; i++) {
3200 InputFile *ifile = input_files[i];
3201 for (j = 0; j < ifile->ctx->nb_programs; j++) {
3202 AVProgram *p = ifile->ctx->programs[j];
3203 int discard = AVDISCARD_ALL;
3205 for (k = 0; k < p->nb_stream_indexes; k++)
3206 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3207 discard = AVDISCARD_DEFAULT;
3210 p->discard = discard;
3214 /* open files and write file headers */
3215 for (i = 0; i < nb_output_files; i++) {
3216 oc = output_files[i]->ctx;
3217 oc->interrupt_callback = int_cb;
3218 if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
3220 const char *errbuf_ptr = errbuf;
3221 if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
3222 errbuf_ptr = strerror(AVUNERROR(ret));
3223 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
3224 ret = AVERROR(EINVAL);
3227 // assert_avoptions(output_files[i]->opts);
3228 if (strcmp(oc->oformat->name, "rtp")) {
3234 /* dump the file output parameters - cannot be done before in case
3236 for (i = 0; i < nb_output_files; i++) {
3237 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3240 /* dump the stream mapping */
3241 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3242 for (i = 0; i < nb_input_streams; i++) {
3243 ist = input_streams[i];
3245 for (j = 0; j < ist->nb_filters; j++) {
3246 if (ist->filters[j]->graph->graph_desc) {
3247 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
3248 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3249 ist->filters[j]->name);
3250 if (nb_filtergraphs > 1)
3251 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3252 av_log(NULL, AV_LOG_INFO, "\n");
3257 for (i = 0; i < nb_output_streams; i++) {
3258 ost = output_streams[i];
3260 if (ost->attachment_filename) {
3261 /* an attached file */
3262 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
3263 ost->attachment_filename, ost->file_index, ost->index);
3267 if (ost->filter && ost->filter->graph->graph_desc) {
3268 /* output from a complex graph */
3269 av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
3270 if (nb_filtergraphs > 1)
3271 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3273 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3274 ost->index, ost->enc ? ost->enc->name : "?");
3278 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
3279 input_streams[ost->source_index]->file_index,
3280 input_streams[ost->source_index]->st->index,
3283 if (ost->sync_ist != input_streams[ost->source_index])
3284 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3285 ost->sync_ist->file_index,
3286 ost->sync_ist->st->index);
3287 if (ost->stream_copy)
3288 av_log(NULL, AV_LOG_INFO, " (copy)");
3290 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3291 input_streams[ost->source_index]->dec->name : "?",
3292 ost->enc ? ost->enc->name : "?");
3293 av_log(NULL, AV_LOG_INFO, "\n");
3297 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3309 * The following code is the main loop of the file converter
3311 static int transcode(void)
3314 AVFormatContext *is, *os;
3318 int no_packet_count = 0;
3319 int64_t timer_start;
3322 if (!(no_packet = av_mallocz(nb_input_files)))
3325 ret = transcode_init();
3330 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3333 timer_start = av_gettime();
3335 for (; received_sigterm == 0;) {
3336 int file_index, ist_index, past_recording_time = 1;
3339 int64_t cur_time= av_gettime();
3341 ipts_min = INT64_MAX;
3342 /* if 'q' pressed, exits */
3344 static int64_t last_time;
3345 if (received_nb_signals)
3347 /* read_key() returns 0 on EOF */
3348 if(cur_time - last_time >= 100000 && !run_as_daemon){
3350 last_time = cur_time;
3355 if (key == '+') av_log_set_level(av_log_get_level()+10);
3356 if (key == '-') av_log_set_level(av_log_get_level()-10);
3357 if (key == 's') qp_hist ^= 1;
3360 do_hex_dump = do_pkt_dump = 0;
3361 } else if(do_pkt_dump){
3365 av_log_set_level(AV_LOG_DEBUG);
3367 if (key == 'c' || key == 'C'){
3368 char buf[4096], target[64], command[256], arg[256] = {0};
3371 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3373 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3378 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3379 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3380 target, time, command, arg);
3381 for (i = 0; i < nb_filtergraphs; i++) {
3382 FilterGraph *fg = filtergraphs[i];
3385 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3386 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3387 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3389 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3394 av_log(NULL, AV_LOG_ERROR,
3395 "Parse error, at least 3 arguments were expected, "
3396 "only %d given in string '%s'\n", n, buf);
3399 if (key == 'd' || key == 'D'){
3402 debug = input_streams[0]->st->codec->debug<<1;
3403 if(!debug) debug = 1;
3404 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3407 if(scanf("%d", &debug)!=1)
3408 fprintf(stderr,"error parsing debug value\n");
3409 for(i=0;i<nb_input_streams;i++) {
3410 input_streams[i]->st->codec->debug = debug;
3412 for(i=0;i<nb_output_streams;i++) {
3413 ost = output_streams[i];
3414 ost->st->codec->debug = debug;
3416 if(debug) av_log_set_level(AV_LOG_DEBUG);
3417 fprintf(stderr,"debug=%d\n", debug);
3420 fprintf(stderr, "key function\n"
3421 "? show this help\n"
3422 "+ increase verbosity\n"
3423 "- decrease verbosity\n"
3424 "c Send command to filtergraph\n"
3425 "D cycle through available debug modes\n"
3426 "h dump packets/hex press to cycle through the 3 states\n"
3428 "s Show QP histogram\n"
3433 /* check if there's any stream where output is still needed */
3434 for (i = 0; i < nb_output_streams; i++) {
3436 ost = output_streams[i];
3437 of = output_files[ost->file_index];
3438 os = output_files[ost->file_index]->ctx;
3439 if (ost->is_past_recording_time ||
3440 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3442 if (ost->frame_number >= ost->max_frames) {
3444 for (j = 0; j < of->ctx->nb_streams; j++)
3445 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3448 past_recording_time = 0;
3450 if (past_recording_time)
3453 /* select the stream that we must read now by looking at the
3454 smallest output pts */
3456 for (i = 0; i < nb_input_streams; i++) {
3458 ist = input_streams[i];
3460 if (ist->discard || no_packet[ist->file_index])
3462 if (!input_files[ist->file_index]->eof_reached) {
3463 if (ipts < ipts_min) {
3465 file_index = ist->file_index;
3469 /* if none, if is finished */
3470 if (file_index < 0) {
3471 if (no_packet_count) {
3472 no_packet_count = 0;
3473 memset(no_packet, 0, nb_input_files);
3480 /* read a frame from it and output it in the fifo */
3481 is = input_files[file_index]->ctx;
3482 ret = av_read_frame(is, &pkt);
3483 if (ret == AVERROR(EAGAIN)) {
3484 no_packet[file_index] = 1;
3489 input_files[file_index]->eof_reached = 1;
3491 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3492 ist = input_streams[input_files[file_index]->ist_index + i];
3493 if (ist->decoding_needed)
3494 output_packet(ist, NULL);
3503 no_packet_count = 0;
3504 memset(no_packet, 0, nb_input_files);
3507 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3508 is->streams[pkt.stream_index]);
3510 /* the following test is needed in case new streams appear
3511 dynamically in stream : we ignore them */
3512 if (pkt.stream_index >= input_files[file_index]->nb_streams)
3513 goto discard_packet;
3514 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3515 ist = input_streams[ist_index];
3517 goto discard_packet;
3519 if (pkt.dts != AV_NOPTS_VALUE)
3520 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3521 if (pkt.pts != AV_NOPTS_VALUE)
3522 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3524 if (pkt.pts != AV_NOPTS_VALUE)
3525 pkt.pts *= ist->ts_scale;
3526 if (pkt.dts != AV_NOPTS_VALUE)
3527 pkt.dts *= ist->ts_scale;
3530 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3531 "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",
3532 ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3533 av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &ist->st->time_base),
3534 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3535 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3536 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3537 input_files[ist->file_index]->ts_offset);
3540 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3541 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3542 int64_t delta = pkt_dts - ist->next_dts;
3543 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3544 if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3545 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3546 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3547 pkt_dts+1<ist->pts){
3548 input_files[ist->file_index]->ts_offset -= delta;
3549 av_log(NULL, AV_LOG_DEBUG,
3550 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3551 delta, input_files[ist->file_index]->ts_offset);
3552 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3553 if (pkt.pts != AV_NOPTS_VALUE)
3554 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3557 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3558 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3559 pkt_dts+1<ist->pts){
3560 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3561 pkt.dts = AV_NOPTS_VALUE;
3563 if (pkt.pts != AV_NOPTS_VALUE){
3564 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3565 delta = pkt_pts - ist->next_dts;
3566 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3567 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3568 pkt_pts+1<ist->pts) {
3569 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3570 pkt.pts = AV_NOPTS_VALUE;
3576 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3577 if (output_packet(ist, &pkt) < 0 ||
3578 ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3579 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3580 ist->file_index, ist->st->index);
3583 av_free_packet(&pkt);
3588 av_free_packet(&pkt);
3590 /* dump report by using the output first video and audio streams */
3591 print_report(0, timer_start, cur_time);
3594 /* at the end of stream, we must flush the decoder buffers */
3595 for (i = 0; i < nb_input_streams; i++) {
3596 ist = input_streams[i];
3597 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3598 output_packet(ist, NULL);
3606 /* write the trailer if needed and close file */
3607 for (i = 0; i < nb_output_files; i++) {
3608 os = output_files[i]->ctx;
3609 av_write_trailer(os);
3612 /* dump report by using the first video and audio streams */
3613 print_report(1, timer_start, av_gettime());
3615 /* close each encoder */
3616 for (i = 0; i < nb_output_streams; i++) {
3617 ost = output_streams[i];
3618 if (ost->encoding_needed) {
3619 av_freep(&ost->st->codec->stats_in);
3620 avcodec_close(ost->st->codec);
3624 /* close each decoder */
3625 for (i = 0; i < nb_input_streams; i++) {
3626 ist = input_streams[i];
3627 if (ist->decoding_needed) {
3628 avcodec_close(ist->st->codec);
3636 av_freep(&no_packet);
3638 if (output_streams) {
3639 for (i = 0; i < nb_output_streams; i++) {
3640 ost = output_streams[i];
3642 if (ost->stream_copy)
3643 av_freep(&ost->st->codec->extradata);
3645 fclose(ost->logfile);
3646 ost->logfile = NULL;
3648 av_freep(&ost->st->codec->subtitle_header);
3649 av_free(ost->forced_kf_pts);
3650 av_dict_free(&ost->opts);
3657 static int opt_frame_crop(const char *opt, const char *arg)
3659 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3660 return AVERROR(EINVAL);
3663 static int opt_pad(const char *opt, const char *arg)
3665 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3669 static int opt_video_channel(const char *opt, const char *arg)
3671 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3672 return opt_default("channel", arg);
3675 static int opt_video_standard(const char *opt, const char *arg)
3677 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3678 return opt_default("standard", arg);
3681 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3683 audio_codec_name = arg;
3684 return parse_option(o, "codec:a", arg, options);
3687 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3689 video_codec_name = arg;
3690 return parse_option(o, "codec:v", arg, options);
3693 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3695 subtitle_codec_name = arg;
3696 return parse_option(o, "codec:s", arg, options);
3699 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3701 return parse_option(o, "codec:d", arg, options);
3704 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3706 StreamMap *m = NULL;
3707 int i, negative = 0, file_idx;
3708 int sync_file_idx = -1, sync_stream_idx = 0;
3716 map = av_strdup(arg);
3718 /* parse sync stream first, just pick first matching stream */
3719 if (sync = strchr(map, ',')) {
3721 sync_file_idx = strtol(sync + 1, &sync, 0);
3722 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3723 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3728 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3729 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3730 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3731 sync_stream_idx = i;
3734 if (i == input_files[sync_file_idx]->nb_streams) {
3735 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3736 "match any streams.\n", arg);
3742 if (map[0] == '[') {
3743 /* this mapping refers to lavfi output */
3744 const char *c = map + 1;
3745 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3746 &o->nb_stream_maps, o->nb_stream_maps + 1);
3747 m = &o->stream_maps[o->nb_stream_maps - 1];
3748 m->linklabel = av_get_token(&c, "]");
3749 if (!m->linklabel) {
3750 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3754 file_idx = strtol(map, &p, 0);
3755 if (file_idx >= nb_input_files || file_idx < 0) {
3756 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3760 /* disable some already defined maps */
3761 for (i = 0; i < o->nb_stream_maps; i++) {
3762 m = &o->stream_maps[i];
3763 if (file_idx == m->file_index &&
3764 check_stream_specifier(input_files[m->file_index]->ctx,
3765 input_files[m->file_index]->ctx->streams[m->stream_index],
3766 *p == ':' ? p + 1 : p) > 0)
3770 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3771 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3772 *p == ':' ? p + 1 : p) <= 0)
3774 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3775 &o->nb_stream_maps, o->nb_stream_maps + 1);
3776 m = &o->stream_maps[o->nb_stream_maps - 1];
3778 m->file_index = file_idx;
3779 m->stream_index = i;
3781 if (sync_file_idx >= 0) {
3782 m->sync_file_index = sync_file_idx;
3783 m->sync_stream_index = sync_stream_idx;
3785 m->sync_file_index = file_idx;
3786 m->sync_stream_index = i;
3792 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3800 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3802 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3803 &o->nb_attachments, o->nb_attachments + 1);
3804 o->attachments[o->nb_attachments - 1] = arg;
3808 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3814 o->audio_channel_maps =
3815 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3816 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3817 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3819 /* muted channel syntax */
3820 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3821 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3822 m->file_idx = m->stream_idx = -1;
3824 m->ofile_idx = m->ostream_idx = -1;
3829 n = sscanf(arg, "%d.%d.%d:%d.%d",
3830 &m->file_idx, &m->stream_idx, &m->channel_idx,
3831 &m->ofile_idx, &m->ostream_idx);
3833 if (n != 3 && n != 5) {
3834 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3835 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3839 if (n != 5) // only file.stream.channel specified
3840 m->ofile_idx = m->ostream_idx = -1;
3843 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3844 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3848 if (m->stream_idx < 0 ||
3849 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
3850 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3851 m->file_idx, m->stream_idx);
3854 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
3855 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3856 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3857 m->file_idx, m->stream_idx);
3860 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3861 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3862 m->file_idx, m->stream_idx, m->channel_idx);
3869 * Parse a metadata specifier in arg.
3870 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3871 * @param index for type c/p, chapter/program index is written here
3872 * @param stream_spec for type s, the stream specifier is written here
3874 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3882 if (*(++arg) && *arg != ':') {
3883 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3886 *stream_spec = *arg == ':' ? arg + 1 : "";
3890 if (*(++arg) == ':')
3891 *index = strtol(++arg, NULL, 0);
3894 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3901 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3903 AVDictionary **meta_in = NULL;
3904 AVDictionary **meta_out = NULL;
3906 char type_in, type_out;
3907 const char *istream_spec = NULL, *ostream_spec = NULL;
3908 int idx_in = 0, idx_out = 0;
3910 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3911 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3914 if (type_out == 'g' || !*outspec)
3915 o->metadata_global_manual = 1;
3916 if (type_out == 's' || !*outspec)
3917 o->metadata_streams_manual = 1;
3918 if (type_out == 'c' || !*outspec)
3919 o->metadata_chapters_manual = 1;
3923 if (type_in == 'g' || type_out == 'g')
3924 o->metadata_global_manual = 1;
3925 if (type_in == 's' || type_out == 's')
3926 o->metadata_streams_manual = 1;
3927 if (type_in == 'c' || type_out == 'c')
3928 o->metadata_chapters_manual = 1;
3930 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3931 if ((index) < 0 || (index) >= (nb_elems)) {\
3932 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3937 #define SET_DICT(type, meta, context, index)\
3940 meta = &context->metadata;\
3943 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3944 meta = &context->chapters[index]->metadata;\
3947 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3948 meta = &context->programs[index]->metadata;\
3952 SET_DICT(type_in, meta_in, ic, idx_in);
3953 SET_DICT(type_out, meta_out, oc, idx_out);
3955 /* for input streams choose first matching stream */
3956 if (type_in == 's') {
3957 for (i = 0; i < ic->nb_streams; i++) {
3958 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3959 meta_in = &ic->streams[i]->metadata;
3965 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3970 if (type_out == 's') {
3971 for (i = 0; i < oc->nb_streams; i++) {
3972 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3973 meta_out = &oc->streams[i]->metadata;
3974 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3979 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3984 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3987 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3988 struct tm time = *gmtime((time_t*)&recording_timestamp);
3989 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3990 parse_option(o, "metadata", buf, options);
3992 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3993 "tag instead.\n", opt);
3997 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3999 const char *codec_string = encoder ? "encoder" : "decoder";
4003 avcodec_find_encoder_by_name(name) :
4004 avcodec_find_decoder_by_name(name);
4006 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4009 if (codec->type != type) {
4010 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4016 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4018 char *codec_name = NULL;
4020 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4022 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4023 st->codec->codec_id = codec->id;
4026 return avcodec_find_decoder(st->codec->codec_id);
4030 * Add all the streams from the given input file to the global
4031 * list of input streams.
4033 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4036 char *next, *codec_tag = NULL;
4038 for (i = 0; i < ic->nb_streams; i++) {
4039 AVStream *st = ic->streams[i];
4040 AVCodecContext *dec = st->codec;
4041 InputStream *ist = av_mallocz(sizeof(*ist));
4042 char *framerate = NULL;
4047 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4048 input_streams[nb_input_streams - 1] = ist;
4051 ist->file_index = nb_input_files;
4053 st->discard = AVDISCARD_ALL;
4054 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
4056 ist->ts_scale = 1.0;
4057 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4059 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4061 uint32_t tag = strtol(codec_tag, &next, 0);
4063 tag = AV_RL32(codec_tag);
4064 st->codec->codec_tag = tag;
4067 ist->dec = choose_decoder(o, ic, st);
4069 switch (dec->codec_type) {
4070 case AVMEDIA_TYPE_VIDEO:
4072 ist->dec = avcodec_find_decoder(dec->codec_id);
4074 dec->flags |= CODEC_FLAG_EMU_EDGE;
4077 ist->resample_height = dec->height;
4078 ist->resample_width = dec->width;
4079 ist->resample_pix_fmt = dec->pix_fmt;
4081 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
4082 if (framerate && av_parse_video_rate(&ist->framerate,
4084 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
4089 ist->top_field_first = -1;
4090 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
4093 case AVMEDIA_TYPE_AUDIO:
4094 guess_input_channel_layout(ist);
4096 ist->resample_sample_fmt = dec->sample_fmt;
4097 ist->resample_sample_rate = dec->sample_rate;
4098 ist->resample_channels = dec->channels;
4099 ist->resample_channel_layout = dec->channel_layout;
4102 case AVMEDIA_TYPE_DATA:
4103 case AVMEDIA_TYPE_SUBTITLE:
4105 ist->dec = avcodec_find_decoder(dec->codec_id);
4107 case AVMEDIA_TYPE_ATTACHMENT:
4108 case AVMEDIA_TYPE_UNKNOWN:
4116 static void assert_file_overwrite(const char *filename)
4118 if ((!file_overwrite || no_file_overwrite) &&
4119 (strchr(filename, ':') == NULL || filename[1] == ':' ||
4120 av_strstart(filename, "file:", NULL))) {
4121 if (avio_check(filename, 0) == 0) {
4122 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
4123 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4126 signal(SIGINT, SIG_DFL);
4127 if (!read_yesno()) {
4128 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4134 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4141 static void dump_attachment(AVStream *st, const char *filename)
4144 AVIOContext *out = NULL;
4145 AVDictionaryEntry *e;
4147 if (!st->codec->extradata_size) {
4148 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4149 nb_input_files - 1, st->index);
4152 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4153 filename = e->value;
4155 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4156 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4160 assert_file_overwrite(filename);
4162 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4163 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4168 avio_write(out, st->codec->extradata, st->codec->extradata_size);
4173 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4175 AVFormatContext *ic;
4176 AVInputFormat *file_iformat = NULL;
4180 AVDictionary **opts;
4181 int orig_nb_streams; // number of streams before avformat_find_stream_info
4184 if (!(file_iformat = av_find_input_format(o->format))) {
4185 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4190 if (!strcmp(filename, "-"))
4193 using_stdin |= !strncmp(filename, "pipe:", 5) ||
4194 !strcmp(filename, "/dev/stdin");
4196 /* get default parameters from command line */
4197 ic = avformat_alloc_context();
4199 print_error(filename, AVERROR(ENOMEM));
4202 if (o->nb_audio_sample_rate) {
4203 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4204 av_dict_set(&format_opts, "sample_rate", buf, 0);
4206 if (o->nb_audio_channels) {
4207 /* because we set audio_channels based on both the "ac" and
4208 * "channel_layout" options, we need to check that the specified
4209 * demuxer actually has the "channels" option before setting it */
4210 if (file_iformat && file_iformat->priv_class &&
4211 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4212 AV_OPT_SEARCH_FAKE_OBJ)) {
4213 snprintf(buf, sizeof(buf), "%d",
4214 o->audio_channels[o->nb_audio_channels - 1].u.i);
4215 av_dict_set(&format_opts, "channels", buf, 0);
4218 if (o->nb_frame_rates) {
4219 /* set the format-level framerate option;
4220 * this is important for video grabbers, e.g. x11 */
4221 if (file_iformat && file_iformat->priv_class &&
4222 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
4223 AV_OPT_SEARCH_FAKE_OBJ)) {
4224 av_dict_set(&format_opts, "framerate",
4225 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4228 if (o->nb_frame_sizes) {
4229 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4231 if (o->nb_frame_pix_fmts)
4232 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4234 ic->video_codec_id = video_codec_name ?
4235 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
4236 ic->audio_codec_id = audio_codec_name ?
4237 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
4238 ic->subtitle_codec_id= subtitle_codec_name ?
4239 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4240 ic->flags |= AVFMT_FLAG_NONBLOCK;
4241 ic->interrupt_callback = int_cb;
4243 /* open the input file with generic avformat function */
4244 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4246 print_error(filename, err);
4249 assert_avoptions(format_opts);
4251 /* apply forced codec ids */
4252 for (i = 0; i < ic->nb_streams; i++)
4253 choose_decoder(o, ic, ic->streams[i]);
4255 /* Set AVCodecContext options for avformat_find_stream_info */
4256 opts = setup_find_stream_info_opts(ic, codec_opts);
4257 orig_nb_streams = ic->nb_streams;
4259 /* If not enough info to get the stream parameters, we decode the
4260 first frames to get it. (used in mpeg case for example) */
4261 ret = avformat_find_stream_info(ic, opts);
4263 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4264 avformat_close_input(&ic);
4268 timestamp = o->start_time;
4269 /* add the stream start time */
4270 if (ic->start_time != AV_NOPTS_VALUE)
4271 timestamp += ic->start_time;
4273 /* if seeking requested, we execute it */
4274 if (o->start_time != 0) {
4275 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4277 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4278 filename, (double)timestamp / AV_TIME_BASE);
4282 /* update the current parameters so that they match the one of the input stream */
4283 add_input_streams(o, ic);
4285 /* dump the file content */
4286 av_dump_format(ic, nb_input_files, filename, 0);
4288 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4289 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4292 input_files[nb_input_files - 1]->ctx = ic;
4293 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
4294 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4295 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4296 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
4298 for (i = 0; i < o->nb_dump_attachment; i++) {
4301 for (j = 0; j < ic->nb_streams; j++) {
4302 AVStream *st = ic->streams[j];
4304 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4305 dump_attachment(st, o->dump_attachment[i].u.str);
4309 for (i = 0; i < orig_nb_streams; i++)
4310 av_dict_free(&opts[i]);
4313 reset_options(o, 1);
4317 static void parse_forced_key_frames(char *kf, OutputStream *ost)
4322 for (p = kf; *p; p++)
4325 ost->forced_kf_count = n;
4326 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
4327 if (!ost->forced_kf_pts) {
4328 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
4332 for (i = 0; i < n; i++) {
4333 char *next = strchr(p, ',');
4334 if (next) *next++ = 0;
4335 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
4340 static uint8_t *get_line(AVIOContext *s)
4346 if (avio_open_dyn_buf(&line) < 0) {
4347 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4351 while ((c = avio_r8(s)) && c != '\n')
4354 avio_close_dyn_buf(line, &buf);
4359 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4362 char filename[1000];
4363 const char *base[3] = { getenv("AVCONV_DATADIR"),
4368 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4372 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4373 i != 1 ? "" : "/.avconv", codec_name, preset_name);
4374 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4377 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4378 i != 1 ? "" : "/.avconv", preset_name);
4379 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4385 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4387 char *codec_name = NULL;
4389 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4391 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4392 NULL, ost->st->codec->codec_type);
4393 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4394 } else if (!strcmp(codec_name, "copy"))
4395 ost->stream_copy = 1;
4397 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4398 ost->st->codec->codec_id = ost->enc->id;
4402 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4405 AVStream *st = avformat_new_stream(oc, NULL);
4406 int idx = oc->nb_streams - 1, ret = 0;
4407 char *bsf = NULL, *next, *codec_tag = NULL;
4408 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4410 char *buf = NULL, *arg = NULL, *preset = NULL;
4411 AVIOContext *s = NULL;
4414 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4418 if (oc->nb_streams - 1 < o->nb_streamid_map)
4419 st->id = o->streamid_map[oc->nb_streams - 1];
4421 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4422 nb_output_streams + 1);
4423 if (!(ost = av_mallocz(sizeof(*ost))))
4425 output_streams[nb_output_streams - 1] = ost;
4427 ost->file_index = nb_output_files;
4430 st->codec->codec_type = type;
4431 choose_encoder(o, oc, ost);
4433 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
4436 avcodec_get_context_defaults3(st->codec, ost->enc);
4437 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4439 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4440 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4443 if (!buf[0] || buf[0] == '#') {
4447 if (!(arg = strchr(buf, '='))) {
4448 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4452 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4454 } while (!s->eof_reached);
4458 av_log(NULL, AV_LOG_FATAL,
4459 "Preset %s specified for stream %d:%d, but could not be opened.\n",
4460 preset, ost->file_index, ost->index);
4464 ost->max_frames = INT64_MAX;
4465 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4467 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4469 if (next = strchr(bsf, ','))
4471 if (!(bsfc = av_bitstream_filter_init(bsf))) {
4472 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4476 bsfc_prev->next = bsfc;
4478 ost->bitstream_filters = bsfc;
4484 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4486 uint32_t tag = strtol(codec_tag, &next, 0);
4488 tag = AV_RL32(codec_tag);
4489 st->codec->codec_tag = tag;
4492 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4493 if (qscale >= 0 || same_quant) {
4494 st->codec->flags |= CODEC_FLAG_QSCALE;
4495 st->codec->global_quality = FF_QP2LAMBDA * qscale;
4498 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4499 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4501 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4502 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4503 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4505 ost->source_index = source_index;
4506 if (source_index >= 0) {
4507 ost->sync_ist = input_streams[source_index];
4508 input_streams[source_index]->discard = 0;
4509 input_streams[source_index]->st->discard = AVDISCARD_NONE;
4515 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4518 const char *p = str;
4525 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4532 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4536 AVCodecContext *video_enc;
4538 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4540 video_enc = st->codec;
4542 if (!ost->stream_copy) {
4543 const char *p = NULL;
4544 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
4545 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4546 char *intra_matrix = NULL, *inter_matrix = NULL;
4547 const char *filters = "null";
4550 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4551 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4552 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4556 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4557 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4558 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4562 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4563 if (frame_aspect_ratio) {
4565 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4566 q.num <= 0 || q.den <= 0) {
4567 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4570 ost->frame_aspect_ratio = av_q2d(q);
4573 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4574 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4575 if (frame_pix_fmt && *frame_pix_fmt == '+') {
4576 ost->keep_pix_fmt = 1;
4577 if (!*++frame_pix_fmt)
4578 frame_pix_fmt = NULL;
4580 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4581 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4584 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4587 video_enc->gop_size = 0;
4588 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4590 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4591 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4594 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4596 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4598 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4599 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4602 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4605 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4606 for (i = 0; p; i++) {
4608 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4610 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4613 /* FIXME realloc failure */
4614 video_enc->rc_override =
4615 av_realloc(video_enc->rc_override,
4616 sizeof(RcOverride) * (i + 1));
4617 video_enc->rc_override[i].start_frame = start;
4618 video_enc->rc_override[i].end_frame = end;
4620 video_enc->rc_override[i].qscale = q;
4621 video_enc->rc_override[i].quality_factor = 1.0;
4624 video_enc->rc_override[i].qscale = 0;
4625 video_enc->rc_override[i].quality_factor = -q/100.0;
4630 video_enc->rc_override_count = i;
4631 if (!video_enc->rc_initial_buffer_occupancy)
4632 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4633 video_enc->intra_dc_precision = intra_dc_precision - 8;
4636 video_enc->flags|= CODEC_FLAG_PSNR;
4641 video_enc->flags |= CODEC_FLAG_PASS1;
4644 video_enc->flags |= CODEC_FLAG_PASS2;
4648 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4649 if (forced_key_frames)
4650 parse_forced_key_frames(forced_key_frames, ost);
4652 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4654 ost->top_field_first = -1;
4655 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4657 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4658 ost->avfilter = av_strdup(filters);
4660 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4666 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4671 AVCodecContext *audio_enc;
4673 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4676 audio_enc = st->codec;
4677 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4679 if (!ost->stream_copy) {
4680 char *sample_fmt = NULL;
4681 const char *filters = "anull";
4683 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4685 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4687 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4688 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4692 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4694 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4696 av_assert1(filters);
4697 ost->avfilter = av_strdup(filters);
4699 /* check for channel mapping for this audio stream */
4700 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4701 AudioChannelMap *map = &o->audio_channel_maps[n];
4702 InputStream *ist = input_streams[ost->source_index];
4703 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4704 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4705 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4706 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4707 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4709 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4710 ost->file_index, ost->st->index);
4718 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4722 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4723 if (!ost->stream_copy) {
4724 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4731 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4733 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4734 ost->stream_copy = 1;
4738 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4742 AVCodecContext *subtitle_enc;
4744 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4746 subtitle_enc = st->codec;
4748 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4750 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4755 /* arg format is "output-stream-index:streamid-value". */
4756 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4762 av_strlcpy(idx_str, arg, sizeof(idx_str));
4763 p = strchr(idx_str, ':');
4765 av_log(NULL, AV_LOG_FATAL,
4766 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4771 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4772 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4773 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4777 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4779 AVFormatContext *is = ifile->ctx;
4780 AVFormatContext *os = ofile->ctx;
4783 for (i = 0; i < is->nb_chapters; i++) {
4784 AVChapter *in_ch = is->chapters[i], *out_ch;
4785 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4786 AV_TIME_BASE_Q, in_ch->time_base);
4787 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4788 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4791 if (in_ch->end < ts_off)
4793 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4796 out_ch = av_mallocz(sizeof(AVChapter));
4798 return AVERROR(ENOMEM);
4800 out_ch->id = in_ch->id;
4801 out_ch->time_base = in_ch->time_base;
4802 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4803 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4806 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4809 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4811 return AVERROR(ENOMEM);
4812 os->chapters[os->nb_chapters - 1] = out_ch;
4817 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4820 AVFormatContext *ic = avformat_alloc_context();
4822 ic->interrupt_callback = int_cb;
4823 err = avformat_open_input(&ic, filename, NULL, NULL);
4826 /* copy stream format */
4827 for(i=0;i<ic->nb_streams;i++) {
4831 AVCodecContext *avctx;
4833 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4834 ost = new_output_stream(o, s, codec->type, -1);
4839 // FIXME: a more elegant solution is needed
4840 memcpy(st, ic->streams[i], sizeof(AVStream));
4842 st->info = av_malloc(sizeof(*st->info));
4843 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4845 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4847 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4848 choose_sample_fmt(st, codec);
4849 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4850 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4853 avformat_close_input(&ic);
4857 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4858 AVFormatContext *oc)
4862 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4863 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
4864 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
4866 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
4871 ost->source_index = -1;
4872 ost->filter = ofilter;
4876 if (ost->stream_copy) {
4877 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4878 "which is fed from a complex filtergraph. Filtering and streamcopy "
4879 "cannot be used together.\n", ost->file_index, ost->index);
4883 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4884 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4887 avfilter_inout_free(&ofilter->out_tmp);
4890 static void opt_output_file(void *optctx, const char *filename)
4892 OptionsContext *o = optctx;
4893 AVFormatContext *oc;
4895 AVOutputFormat *file_oformat;
4899 if (configure_complex_filters() < 0) {
4900 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4904 if (!strcmp(filename, "-"))
4907 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4909 print_error(filename, err);
4912 file_oformat= oc->oformat;
4913 oc->interrupt_callback = int_cb;
4915 /* create streams for all unlabeled output pads */
4916 for (i = 0; i < nb_filtergraphs; i++) {
4917 FilterGraph *fg = filtergraphs[i];
4918 for (j = 0; j < fg->nb_outputs; j++) {
4919 OutputFilter *ofilter = fg->outputs[j];
4921 if (!ofilter->out_tmp || ofilter->out_tmp->name)
4924 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4925 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
4926 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
4927 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
4929 init_output_filter(ofilter, o, oc);
4933 if (!strcmp(file_oformat->name, "ffm") &&
4934 av_strstart(filename, "http:", NULL)) {
4936 /* special case for files sent to ffserver: we get the stream
4937 parameters from ffserver */
4938 int err = read_ffserver_streams(o, oc, filename);
4940 print_error(filename, err);
4943 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4944 ost = output_streams[j];
4945 for (i = 0; i < nb_input_streams; i++) {
4946 ist = input_streams[i];
4947 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4949 ost->source_index= i;
4950 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
4951 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
4953 ist->st->discard = AVDISCARD_NONE;
4958 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));
4962 } else if (!o->nb_stream_maps) {
4963 /* pick the "best" stream of each type */
4965 /* video: highest resolution */
4966 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4967 int area = 0, idx = -1;
4968 for (i = 0; i < nb_input_streams; i++) {
4969 ist = input_streams[i];
4970 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4971 ist->st->codec->width * ist->st->codec->height > area) {
4972 area = ist->st->codec->width * ist->st->codec->height;
4977 new_video_stream(o, oc, idx);
4980 /* audio: most channels */
4981 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4982 int channels = 0, idx = -1;
4983 for (i = 0; i < nb_input_streams; i++) {
4984 ist = input_streams[i];
4985 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4986 ist->st->codec->channels > channels) {
4987 channels = ist->st->codec->channels;
4992 new_audio_stream(o, oc, idx);
4995 /* subtitles: pick first */
4996 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4997 for (i = 0; i < nb_input_streams; i++)
4998 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4999 new_subtitle_stream(o, oc, i);
5003 /* do something with data? */
5005 for (i = 0; i < o->nb_stream_maps; i++) {
5006 StreamMap *map = &o->stream_maps[i];
5007 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5012 if (map->linklabel) {
5014 OutputFilter *ofilter = NULL;
5017 for (j = 0; j < nb_filtergraphs; j++) {
5018 fg = filtergraphs[j];
5019 for (k = 0; k < fg->nb_outputs; k++) {
5020 AVFilterInOut *out = fg->outputs[k]->out_tmp;
5021 if (out && !strcmp(out->name, map->linklabel)) {
5022 ofilter = fg->outputs[k];
5029 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5030 "in any defined filter graph.\n", map->linklabel);
5033 init_output_filter(ofilter, o, oc);
5035 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5036 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5038 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5040 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5042 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5045 switch (ist->st->codec->codec_type) {
5046 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
5047 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
5048 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
5049 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
5050 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5052 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5053 map->file_index, map->stream_index);
5061 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5062 AVDictionaryEntry *e;
5063 ost = output_streams[i];
5065 if ( ost->stream_copy
5066 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5067 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5068 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5072 /* handle attached files */
5073 for (i = 0; i < o->nb_attachments; i++) {
5075 uint8_t *attachment;
5079 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5080 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5084 if ((len = avio_size(pb)) <= 0) {
5085 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5089 if (!(attachment = av_malloc(len))) {
5090 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5094 avio_read(pb, attachment, len);
5096 ost = new_attachment_stream(o, oc, -1);
5097 ost->stream_copy = 0;
5098 ost->attachment_filename = o->attachments[i];
5099 ost->st->codec->extradata = attachment;
5100 ost->st->codec->extradata_size = len;
5102 p = strrchr(o->attachments[i], '/');
5103 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5107 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5108 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5111 output_files[nb_output_files - 1]->ctx = oc;
5112 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
5113 output_files[nb_output_files - 1]->recording_time = o->recording_time;
5114 if (o->recording_time != INT64_MAX)
5115 oc->duration = o->recording_time;
5116 output_files[nb_output_files - 1]->start_time = o->start_time;
5117 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5118 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5120 /* check filename in case of an image number is expected */
5121 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5122 if (!av_filename_number_test(oc->filename)) {
5123 print_error(oc->filename, AVERROR(EINVAL));
5128 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5129 /* test if it already exists to avoid losing precious files */
5130 assert_file_overwrite(filename);
5133 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5134 &oc->interrupt_callback,
5135 &output_files[nb_output_files - 1]->opts)) < 0) {
5136 print_error(filename, err);
5141 if (o->mux_preload) {
5143 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5144 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5146 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5149 for (i = 0; i < o->nb_metadata_map; i++) {
5151 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5153 if (in_file_index >= nb_input_files) {
5154 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5157 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5161 if (o->chapters_input_file >= nb_input_files) {
5162 if (o->chapters_input_file == INT_MAX) {
5163 /* copy chapters from the first input file that has them*/
5164 o->chapters_input_file = -1;
5165 for (i = 0; i < nb_input_files; i++)
5166 if (input_files[i]->ctx->nb_chapters) {
5167 o->chapters_input_file = i;
5171 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5172 o->chapters_input_file);
5176 if (o->chapters_input_file >= 0)
5177 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5178 !o->metadata_chapters_manual);
5180 /* copy global metadata by default */
5181 if (!o->metadata_global_manual && nb_input_files){
5182 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5183 AV_DICT_DONT_OVERWRITE);
5184 if(o->recording_time != INT64_MAX)
5185 av_dict_set(&oc->metadata, "duration", NULL, 0);
5187 if (!o->metadata_streams_manual)
5188 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5190 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
5192 ist = input_streams[output_streams[i]->source_index];
5193 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5196 /* process manually set metadata */
5197 for (i = 0; i < o->nb_metadata; i++) {
5200 const char *stream_spec;
5201 int index = 0, j, ret = 0;
5203 val = strchr(o->metadata[i].u.str, '=');
5205 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5206 o->metadata[i].u.str);
5211 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5213 for (j = 0; j < oc->nb_streams; j++) {
5214 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5215 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5219 printf("ret %d, stream_spec %s\n", ret, stream_spec);
5227 if (index < 0 || index >= oc->nb_chapters) {
5228 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5231 m = &oc->chapters[index]->metadata;
5234 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5237 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5241 reset_options(o, 0);
5244 /* same option as mencoder */
5245 static int opt_pass(const char *opt, const char *arg)
5247 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5251 static int64_t getmaxrss(void)
5253 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5254 struct rusage rusage;
5255 getrusage(RUSAGE_SELF, &rusage);
5256 return (int64_t)rusage.ru_maxrss * 1024;
5257 #elif HAVE_GETPROCESSMEMORYINFO
5259 PROCESS_MEMORY_COUNTERS memcounters;
5260 proc = GetCurrentProcess();
5261 memcounters.cb = sizeof(memcounters);
5262 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5263 return memcounters.PeakPagefileUsage;
5269 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5271 return parse_option(o, "q:a", arg, options);
5274 static void show_usage(void)
5276 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5277 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5278 av_log(NULL, AV_LOG_INFO, "\n");
5281 static int opt_help(const char *opt, const char *arg)
5283 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5284 av_log_set_callback(log_callback_help);
5286 show_help_options(options, "Main options:\n",
5287 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5288 show_help_options(options, "\nAdvanced options:\n",
5289 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5291 show_help_options(options, "\nVideo options:\n",
5292 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5294 show_help_options(options, "\nAdvanced Video options:\n",
5295 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5296 OPT_VIDEO | OPT_EXPERT);
5297 show_help_options(options, "\nAudio options:\n",
5298 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5300 show_help_options(options, "\nAdvanced Audio options:\n",
5301 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5302 OPT_AUDIO | OPT_EXPERT);
5303 show_help_options(options, "\nSubtitle options:\n",
5304 OPT_SUBTITLE | OPT_GRAB,
5306 show_help_options(options, "\nAudio/Video grab options:\n",
5310 show_help_children(avcodec_get_class(), flags);
5311 show_help_children(avformat_get_class(), flags);
5312 show_help_children(sws_get_class(), flags);
5317 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5319 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5320 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5322 if (!strncmp(arg, "pal-", 4)) {
5325 } else if (!strncmp(arg, "ntsc-", 5)) {
5328 } else if (!strncmp(arg, "film-", 5)) {
5332 /* Try to determine PAL/NTSC by peeking in the input files */
5333 if (nb_input_files) {
5335 for (j = 0; j < nb_input_files; j++) {
5336 for (i = 0; i < input_files[j]->nb_streams; i++) {
5337 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5338 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5340 fr = c->time_base.den * 1000 / c->time_base.num;
5344 } else if ((fr == 29970) || (fr == 23976)) {
5349 if (norm != UNKNOWN)
5353 if (norm != UNKNOWN)
5354 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5357 if (norm == UNKNOWN) {
5358 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5359 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5360 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5364 if (!strcmp(arg, "vcd")) {
5365 opt_video_codec(o, "c:v", "mpeg1video");
5366 opt_audio_codec(o, "c:a", "mp2");
5367 parse_option(o, "f", "vcd", options);
5369 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5370 parse_option(o, "r", frame_rates[norm], options);
5371 opt_default("g", norm == PAL ? "15" : "18");
5373 opt_default("b:v", "1150000");
5374 opt_default("maxrate", "1150000");
5375 opt_default("minrate", "1150000");
5376 opt_default("bufsize", "327680"); // 40*1024*8;
5378 opt_default("b:a", "224000");
5379 parse_option(o, "ar", "44100", options);
5380 parse_option(o, "ac", "2", options);
5382 opt_default("packetsize", "2324");
5383 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5385 /* We have to offset the PTS, so that it is consistent with the SCR.
5386 SCR starts at 36000, but the first two packs contain only padding
5387 and the first pack from the other stream, respectively, may also have
5388 been written before.
5389 So the real data starts at SCR 36000+3*1200. */
5390 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5391 } else if (!strcmp(arg, "svcd")) {
5393 opt_video_codec(o, "c:v", "mpeg2video");
5394 opt_audio_codec(o, "c:a", "mp2");
5395 parse_option(o, "f", "svcd", options);
5397 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5398 parse_option(o, "r", frame_rates[norm], options);
5399 parse_option(o, "pix_fmt", "yuv420p", options);
5400 opt_default("g", norm == PAL ? "15" : "18");
5402 opt_default("b:v", "2040000");
5403 opt_default("maxrate", "2516000");
5404 opt_default("minrate", "0"); // 1145000;
5405 opt_default("bufsize", "1835008"); // 224*1024*8;
5406 opt_default("scan_offset", "1");
5409 opt_default("b:a", "224000");
5410 parse_option(o, "ar", "44100", options);
5412 opt_default("packetsize", "2324");
5414 } else if (!strcmp(arg, "dvd")) {
5416 opt_video_codec(o, "c:v", "mpeg2video");
5417 opt_audio_codec(o, "c:a", "ac3");
5418 parse_option(o, "f", "dvd", options);
5420 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5421 parse_option(o, "r", frame_rates[norm], options);
5422 parse_option(o, "pix_fmt", "yuv420p", options);
5423 opt_default("g", norm == PAL ? "15" : "18");
5425 opt_default("b:v", "6000000");
5426 opt_default("maxrate", "9000000");
5427 opt_default("minrate", "0"); // 1500000;
5428 opt_default("bufsize", "1835008"); // 224*1024*8;
5430 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5431 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5433 opt_default("b:a", "448000");
5434 parse_option(o, "ar", "48000", options);
5436 } else if (!strncmp(arg, "dv", 2)) {
5438 parse_option(o, "f", "dv", options);
5440 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5441 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5442 norm == PAL ? "yuv420p" : "yuv411p", options);
5443 parse_option(o, "r", frame_rates[norm], options);
5445 parse_option(o, "ar", "48000", options);
5446 parse_option(o, "ac", "2", options);
5449 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5450 return AVERROR(EINVAL);
5455 static int opt_vstats_file(const char *opt, const char *arg)
5457 av_free (vstats_filename);
5458 vstats_filename = av_strdup (arg);
5462 static int opt_vstats(const char *opt, const char *arg)
5465 time_t today2 = time(NULL);
5466 struct tm *today = localtime(&today2);
5468 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5470 return opt_vstats_file(opt, filename);
5473 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5475 return parse_option(o, "frames:v", arg, options);
5478 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5480 return parse_option(o, "frames:a", arg, options);
5483 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5485 return parse_option(o, "frames:d", arg, options);
5488 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5491 char filename[1000], line[1000], tmp_line[1000];
5492 const char *codec_name = *opt == 'v' ? video_codec_name :
5493 *opt == 'a' ? audio_codec_name :
5494 subtitle_codec_name;
5496 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5497 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5498 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5500 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5504 while (fgets(line, sizeof(line), f)) {
5505 char *key = tmp_line, *value, *endptr;
5507 if (strcspn(line, "#\n\r") == 0)
5509 strcpy(tmp_line, line);
5510 if (!av_strtok(key, "=", &value) ||
5511 !av_strtok(value, "\r\n", &endptr)) {
5512 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5515 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
5517 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
5518 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
5519 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
5520 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
5521 else if (opt_default(key, value) < 0) {
5522 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
5523 filename, line, key, value);
5533 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5537 static int opt_passlogfile(const char *opt, const char *arg)
5539 pass_logfilename_prefix = arg;
5540 #if CONFIG_LIBX264_ENCODER
5541 return opt_default(opt, arg);
5547 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5549 char *s = av_asprintf("%s:%c", opt + 1, *opt);
5550 int ret = parse_option(o, s, arg, options);
5555 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5557 if(!strcmp(opt, "b")){
5558 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5559 return parse_option(o, "b:v", arg, options);
5561 return opt_default(opt, arg);
5564 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5568 if(!strcmp(opt, "qscale")){
5569 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5570 return parse_option(o, "q:v", arg, options);
5572 s = av_asprintf("q%s", opt + 6);
5573 ret = parse_option(o, s, arg, options);
5578 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5580 if(!strcmp(opt, "profile")){
5581 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5582 return parse_option(o, "profile:v", arg, options);
5584 return opt_default(opt, arg);
5587 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5589 return parse_option(o, "filter:v", arg, options);
5592 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
5594 return parse_option(o, "filter:a", arg, options);
5597 static int opt_vsync(const char *opt, const char *arg)
5599 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
5600 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
5601 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5602 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
5604 if (video_sync_method == VSYNC_AUTO)
5605 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5609 static int opt_deinterlace(const char *opt, const char *arg)
5611 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5616 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5618 int idx = locate_option(argc, argv, options, "cpuflags");
5619 if (idx && argv[idx + 1])
5620 opt_cpuflags("cpuflags", argv[idx + 1]);
5623 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5625 char layout_str[32];
5628 int ret, channels, ac_str_size;
5631 layout = av_get_channel_layout(arg);
5633 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5634 return AVERROR(EINVAL);
5636 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5637 ret = opt_default(opt, layout_str);
5641 /* set 'ac' option based on channel layout */
5642 channels = av_get_channel_layout_nb_channels(layout);
5643 snprintf(layout_str, sizeof(layout_str), "%d", channels);
5644 stream_str = strchr(opt, ':');
5645 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5646 ac_str = av_mallocz(ac_str_size);
5648 return AVERROR(ENOMEM);
5649 av_strlcpy(ac_str, "ac", 3);
5651 av_strlcat(ac_str, stream_str, ac_str_size);
5652 ret = parse_option(o, ac_str, layout_str, options);
5658 static int opt_filter_complex(const char *opt, const char *arg)
5660 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5661 &nb_filtergraphs, nb_filtergraphs + 1);
5662 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5663 return AVERROR(ENOMEM);
5664 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
5665 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5669 #define OFFSET(x) offsetof(OptionsContext, x)
5670 static const OptionDef options[] = {
5672 #include "cmdutils_common_opts.h"
5673 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5674 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5675 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5676 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5677 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5678 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5679 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5680 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5681 { "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]" },
5682 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5683 "outfile[,metadata]:infile[,metadata]" },
5684 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
5685 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5686 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5687 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5688 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5689 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5690 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5691 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5692 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5693 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5694 "add timings for benchmarking" },
5695 { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5696 "add timings for each task" },
5697 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5698 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5699 "dump each input packet" },
5700 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5701 "when dumping packets, also dump the payload" },
5702 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5703 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5704 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5705 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5706 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5707 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
5708 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
5709 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5710 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5711 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5712 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5713 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5714 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5715 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5716 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5717 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5718 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5719 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5720 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5721 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5722 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5723 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5724 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5727 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5728 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5729 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5730 { "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" },
5731 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5732 { "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" },
5733 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5734 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5735 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5736 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5737 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5738 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5739 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5740 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5741 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5742 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5743 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5744 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5745 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5746 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5747 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5748 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5749 "use same quantizer as source (implies VBR)" },
5750 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5751 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5752 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5753 "this option is deprecated, use the yadif filter instead" },
5754 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5755 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5756 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5757 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5758 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5759 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5760 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5761 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5762 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5763 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5764 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5765 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5766 { "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" },
5767 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5770 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5771 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5772 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5773 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5774 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5775 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5776 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5777 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5778 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5779 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5780 { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
5782 /* subtitle options */
5783 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5784 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5785 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5788 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5789 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5790 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5793 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5794 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5796 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5797 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5798 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5800 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5801 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5802 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5803 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5804 /* data codec support */
5805 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5806 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5808 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5812 int main(int argc, char **argv)
5814 OptionsContext o = { 0 };
5817 reset_options(&o, 0);
5819 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5820 parse_loglevel(argc, argv, options);
5822 if(argc>1 && !strcmp(argv[1], "-d")){
5824 av_log_set_callback(log_callback_null);
5829 avcodec_register_all();
5831 avdevice_register_all();
5833 avfilter_register_all();
5835 avformat_network_init();
5837 show_banner(argc, argv, options);
5841 parse_cpuflags(argc, argv, options);
5844 parse_options(&o, argc, argv, options, opt_output_file);
5846 if (nb_output_files <= 0 && nb_input_files == 0) {
5848 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5852 /* file converter / grab */
5853 if (nb_output_files <= 0) {
5854 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5858 if (nb_input_files == 0) {
5859 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5863 current_time = ti = getutime();
5864 if (transcode() < 0)
5866 ti = getutime() - ti;
5868 int maxrss = getmaxrss() / 1024;
5869 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);