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
37 #include "libavformat/avformat.h"
38 #include "libavdevice/avdevice.h"
39 #include "libswscale/swscale.h"
40 #include "libswresample/swresample.h"
41 #include "libavutil/opt.h"
42 #include "libavutil/audioconvert.h"
43 #include "libavutil/parseutils.h"
44 #include "libavutil/samplefmt.h"
45 #include "libavutil/colorspace.h"
46 #include "libavutil/fifo.h"
47 #include "libavutil/intreadwrite.h"
48 #include "libavutil/dict.h"
49 #include "libavutil/mathematics.h"
50 #include "libavutil/pixdesc.h"
51 #include "libavutil/avstring.h"
52 #include "libavutil/libm.h"
53 #include "libavutil/imgutils.h"
54 #include "libavutil/timestamp.h"
55 #include "libavutil/bprint.h"
56 #include "libavutil/time.h"
57 #include "libavformat/os_support.h"
59 #include "libavformat/ffm.h" // not public API
61 # include "libavfilter/avcodec.h"
62 # include "libavfilter/avfilter.h"
63 # include "libavfilter/avfiltergraph.h"
64 # include "libavfilter/buffersrc.h"
65 # include "libavfilter/buffersink.h"
67 #if HAVE_SYS_RESOURCE_H
68 #include <sys/types.h>
69 #include <sys/resource.h>
70 #elif HAVE_GETPROCESSTIMES
73 #if HAVE_GETPROCESSMEMORYINFO
79 #include <sys/select.h>
84 #include <sys/ioctl.h>
99 #include "libavutil/avassert.h"
101 #define VSYNC_AUTO -1
102 #define VSYNC_PASSTHROUGH 0
105 #define VSYNC_DROP 0xff
107 const char program_name[] = "ffmpeg";
108 const int program_birth_year = 2000;
110 /* select an input stream for an output stream */
111 typedef struct StreamMap {
112 int disabled; /** 1 is this mapping is disabled by a negative map */
116 int sync_stream_index;
117 char *linklabel; /** name of an output link, for mapping lavfi outputs */
121 int file_idx, stream_idx, channel_idx; // input
122 int ofile_idx, ostream_idx; // output
125 static const OptionDef options[];
127 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
129 static int frame_bits_per_raw_sample = 0;
130 static int video_discard = 0;
131 static int same_quant = 0;
132 static int do_deinterlace = 0;
133 static int intra_dc_precision = 8;
134 static int qp_hist = 0;
135 static int intra_only = 0;
136 static const char *video_codec_name = NULL;
137 static const char *audio_codec_name = NULL;
138 static const char *subtitle_codec_name = NULL;
140 static int file_overwrite = 0;
141 static int no_file_overwrite = 0;
142 static int do_benchmark = 0;
143 static int do_benchmark_all = 0;
144 static int do_hex_dump = 0;
145 static int do_pkt_dump = 0;
146 static int do_psnr = 0;
147 static int do_pass = 0;
148 static const char *pass_logfilename_prefix;
149 static int video_sync_method = VSYNC_AUTO;
150 static int audio_sync_method = 0;
151 static float audio_drift_threshold = 0.1;
152 static int copy_ts = 0;
153 static int copy_tb = -1;
154 static int opt_shortest = 0;
155 static char *vstats_filename;
156 static FILE *vstats_file;
158 static int audio_volume = 256;
160 static int exit_on_error = 0;
161 static int using_stdin = 0;
162 static int run_as_daemon = 0;
163 static volatile int received_nb_signals = 0;
164 static int64_t video_size = 0;
165 static int64_t audio_size = 0;
166 static int64_t subtitle_size = 0;
167 static int64_t extra_size = 0;
168 static int nb_frames_dup = 0;
169 static int nb_frames_drop = 0;
170 static int input_sync;
172 static float dts_delta_threshold = 10;
173 static float dts_error_threshold = 3600*30;
175 static int print_stats = 1;
176 static int debug_ts = 0;
177 static int current_time;
179 static uint8_t *subtitle_out;
182 /* signal to input threads that they should exit; set by the main thread */
183 static int transcoding_finished;
186 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
188 typedef struct InputFilter {
189 AVFilterContext *filter;
190 struct InputStream *ist;
191 struct FilterGraph *graph;
195 typedef struct OutputFilter {
196 AVFilterContext *filter;
197 struct OutputStream *ost;
198 struct FilterGraph *graph;
201 /* temporary storage until stream maps are processed */
202 AVFilterInOut *out_tmp;
205 typedef struct FilterGraph {
207 const char *graph_desc;
209 AVFilterGraph *graph;
211 InputFilter **inputs;
213 OutputFilter **outputs;
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 */
266 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
267 from ctx.nb_streams if new streams appear during av_read_frame() */
271 pthread_t thread; /* thread reading from this file */
272 int finished; /* the thread has exited */
273 int joined; /* the thread has been joined */
274 pthread_mutex_t fifo_lock; /* lock for access to fifo */
275 pthread_cond_t fifo_cond; /* the main thread will signal on this cond after reading from fifo */
276 AVFifoBuffer *fifo; /* demuxed packets are stored here; freed by the main thread */
280 typedef struct OutputStream {
281 int file_index; /* file index */
282 int index; /* stream index in the output file */
283 int source_index; /* InputStream index */
284 AVStream *st; /* stream in the output file */
285 int encoding_needed; /* true if encoding needed for this stream */
287 /* input pts and corresponding output pts
289 struct InputStream *sync_ist; /* input stream to sync against */
290 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
291 /* pts of the first frame encoded for this stream, used for limiting
294 AVBitStreamFilterContext *bitstream_filters;
297 AVFrame *filtered_frame;
300 AVRational frame_rate;
304 float frame_aspect_ratio;
307 /* forced key frames */
308 int64_t *forced_kf_pts;
311 char *forced_keyframes;
314 int audio_channels_map[SWR_CH_MAX]; /* list of the channels id to pick from the source stream */
315 int audio_channels_mapped; /* number of channels in audio_channels_map */
319 OutputFilter *filter;
323 int64_t swr_dither_method;
324 double swr_dither_scale;
326 int is_past_recording_time;
328 const char *attachment_filename;
329 int copy_initial_nonkeyframes;
337 /* init terminal so that we can grab keys */
338 static struct termios oldtty;
339 static int restore_tty;
342 typedef struct OutputFile {
343 AVFormatContext *ctx;
345 int ost_index; /* index of the first stream in output_streams */
346 int64_t recording_time; /* desired length of the resulting file in microseconds */
347 int64_t start_time; /* start time in microseconds */
348 uint64_t limit_filesize; /* filesize limit expressed in bytes */
351 static InputStream **input_streams = NULL;
352 static int nb_input_streams = 0;
353 static InputFile **input_files = NULL;
354 static int nb_input_files = 0;
356 static OutputStream **output_streams = NULL;
357 static int nb_output_streams = 0;
358 static OutputFile **output_files = NULL;
359 static int nb_output_files = 0;
361 static FilterGraph **filtergraphs;
364 typedef struct OptionsContext {
365 /* input/output options */
369 SpecifierOpt *codec_names;
371 SpecifierOpt *audio_channels;
372 int nb_audio_channels;
373 SpecifierOpt *audio_sample_rate;
374 int nb_audio_sample_rate;
375 SpecifierOpt *frame_rates;
377 SpecifierOpt *frame_sizes;
379 SpecifierOpt *frame_pix_fmts;
380 int nb_frame_pix_fmts;
383 int64_t input_ts_offset;
386 SpecifierOpt *ts_scale;
388 SpecifierOpt *dump_attachment;
389 int nb_dump_attachment;
392 StreamMap *stream_maps;
394 AudioChannelMap *audio_channel_maps; /* one info entry per -map_channel */
395 int nb_audio_channel_maps; /* number of (valid) -map_channel settings */
396 int metadata_global_manual;
397 int metadata_streams_manual;
398 int metadata_chapters_manual;
399 const char **attachments;
402 int chapters_input_file;
404 int64_t recording_time;
405 uint64_t limit_filesize;
411 int subtitle_disable;
414 /* indexed by output file stream index */
418 SpecifierOpt *metadata;
420 SpecifierOpt *max_frames;
422 SpecifierOpt *bitstream_filters;
423 int nb_bitstream_filters;
424 SpecifierOpt *codec_tags;
426 SpecifierOpt *sample_fmts;
428 SpecifierOpt *qscale;
430 SpecifierOpt *forced_key_frames;
431 int nb_forced_key_frames;
432 SpecifierOpt *force_fps;
434 SpecifierOpt *frame_aspect_ratios;
435 int nb_frame_aspect_ratios;
436 SpecifierOpt *rc_overrides;
438 SpecifierOpt *intra_matrices;
439 int nb_intra_matrices;
440 SpecifierOpt *inter_matrices;
441 int nb_inter_matrices;
442 SpecifierOpt *top_field_first;
443 int nb_top_field_first;
444 SpecifierOpt *metadata_map;
446 SpecifierOpt *presets;
448 SpecifierOpt *copy_initial_nonkeyframes;
449 int nb_copy_initial_nonkeyframes;
450 SpecifierOpt *filters;
454 static void do_video_stats(AVFormatContext *os, OutputStream *ost, int frame_size);
456 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
459 for (i = 0; i < o->nb_ ## name; i++) {\
460 char *spec = o->name[i].specifier;\
461 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
462 outvar = o->name[i].u.type;\
468 static int64_t getutime(void)
471 struct rusage rusage;
473 getrusage(RUSAGE_SELF, &rusage);
474 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
475 #elif HAVE_GETPROCESSTIMES
478 proc = GetCurrentProcess();
479 GetProcessTimes(proc, &c, &e, &k, &u);
480 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
486 static void update_benchmark(const char *fmt, ...)
488 if (do_benchmark_all) {
489 int64_t t = getutime();
495 vsnprintf(buf, sizeof(buf), fmt, va);
497 printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
503 static void reset_options(OptionsContext *o, int is_input)
505 const OptionDef *po = options;
506 OptionsContext bak= *o;
509 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
511 void *dst = (uint8_t*)o + po->u.off;
513 if (po->flags & OPT_SPEC) {
514 SpecifierOpt **so = dst;
515 int i, *count = (int*)(so + 1);
516 for (i = 0; i < *count; i++) {
517 av_freep(&(*so)[i].specifier);
518 if (po->flags & OPT_STRING)
519 av_freep(&(*so)[i].u.str);
523 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
528 for (i = 0; i < o->nb_stream_maps; i++)
529 av_freep(&o->stream_maps[i].linklabel);
530 av_freep(&o->stream_maps);
531 av_freep(&o->audio_channel_maps);
532 av_freep(&o->streamid_map);
534 memset(o, 0, sizeof(*o));
537 o->recording_time = bak.recording_time;
538 if (o->recording_time != INT64_MAX)
539 av_log(NULL, AV_LOG_WARNING,
540 "-t is not an input option, keeping it for the next output;"
541 " consider fixing your command line.\n");
543 o->recording_time = INT64_MAX;
544 o->mux_max_delay = 0.7;
545 o->limit_filesize = UINT64_MAX;
546 o->chapters_input_file = INT_MAX;
552 static enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target)
554 if (codec && codec->pix_fmts) {
555 const enum PixelFormat *p = codec->pix_fmts;
556 int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0;
557 enum PixelFormat best= PIX_FMT_NONE;
558 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
559 if (st->codec->codec_id == CODEC_ID_MJPEG) {
560 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
561 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
562 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
563 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
566 for (; *p != PIX_FMT_NONE; p++) {
567 best= avcodec_find_best_pix_fmt2(best, *p, target, has_alpha, NULL);
571 if (*p == PIX_FMT_NONE) {
572 if (target != PIX_FMT_NONE)
573 av_log(NULL, AV_LOG_WARNING,
574 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
575 av_pix_fmt_descriptors[target].name,
577 av_pix_fmt_descriptors[best].name);
584 static char *choose_pix_fmts(OutputStream *ost)
586 if (ost->keep_pix_fmt) {
588 avfilter_graph_set_auto_convert(ost->filter->graph->graph,
589 AVFILTER_AUTO_CONVERT_NONE);
590 if (ost->st->codec->pix_fmt == PIX_FMT_NONE)
592 return av_strdup(av_get_pix_fmt_name(ost->st->codec->pix_fmt));
594 if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
595 return av_strdup(av_get_pix_fmt_name(choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt)));
596 } else if (ost->enc && ost->enc->pix_fmts) {
597 const enum PixelFormat *p;
598 AVIOContext *s = NULL;
602 if (avio_open_dyn_buf(&s) < 0)
605 p = ost->enc->pix_fmts;
606 if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
607 if (ost->st->codec->codec_id == CODEC_ID_MJPEG) {
608 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
609 } else if (ost->st->codec->codec_id == CODEC_ID_LJPEG) {
610 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
611 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
615 for (; *p != PIX_FMT_NONE; p++) {
616 const char *name = av_get_pix_fmt_name(*p);
617 avio_printf(s, "%s:", name);
619 len = avio_close_dyn_buf(s, &ret);
627 * Define a function for building a string containing a list of
630 #define DEF_CHOOSE_FORMAT(type, var, supported_list, none, get_name, separator) \
631 static char *choose_ ## var ## s(OutputStream *ost) \
633 if (ost->st->codec->var != none) { \
634 get_name(ost->st->codec->var); \
635 return av_strdup(name); \
636 } else if (ost->enc->supported_list) { \
638 AVIOContext *s = NULL; \
642 if (avio_open_dyn_buf(&s) < 0) \
645 for (p = ost->enc->supported_list; *p != none; p++) { \
647 avio_printf(s, "%s" separator, name); \
649 len = avio_close_dyn_buf(s, &ret); \
656 #define GET_PIX_FMT_NAME(pix_fmt)\
657 const char *name = av_get_pix_fmt_name(pix_fmt);
659 // DEF_CHOOSE_FORMAT(enum PixelFormat, pix_fmt, pix_fmts, PIX_FMT_NONE,
660 // GET_PIX_FMT_NAME, ":")
662 #define GET_SAMPLE_FMT_NAME(sample_fmt)\
663 const char *name = av_get_sample_fmt_name(sample_fmt)
665 DEF_CHOOSE_FORMAT(enum AVSampleFormat, sample_fmt, sample_fmts,
666 AV_SAMPLE_FMT_NONE, GET_SAMPLE_FMT_NAME, ",")
668 #define GET_SAMPLE_RATE_NAME(rate)\
670 snprintf(name, sizeof(name), "%d", rate);
672 DEF_CHOOSE_FORMAT(int, sample_rate, supported_samplerates, 0,
673 GET_SAMPLE_RATE_NAME, ",")
675 #define GET_CH_LAYOUT_NAME(ch_layout)\
677 snprintf(name, sizeof(name), "0x%"PRIx64, ch_layout);
679 DEF_CHOOSE_FORMAT(uint64_t, channel_layout, channel_layouts, 0,
680 GET_CH_LAYOUT_NAME, ",")
682 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
684 FilterGraph *fg = av_mallocz(sizeof(*fg));
688 fg->index = nb_filtergraphs;
690 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
692 if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
694 fg->outputs[0]->ost = ost;
695 fg->outputs[0]->graph = fg;
697 ost->filter = fg->outputs[0];
699 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
701 if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
703 fg->inputs[0]->ist = ist;
704 fg->inputs[0]->graph = fg;
706 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
707 &ist->nb_filters, ist->nb_filters + 1);
708 ist->filters[ist->nb_filters - 1] = fg->inputs[0];
710 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
711 &nb_filtergraphs, nb_filtergraphs + 1);
712 filtergraphs[nb_filtergraphs - 1] = fg;
717 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
719 InputStream *ist = NULL;
720 enum AVMediaType type = avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx);
723 // TODO: support other filter types
724 if (type != AVMEDIA_TYPE_VIDEO && type != AVMEDIA_TYPE_AUDIO) {
725 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters supported "
734 int file_idx = strtol(in->name, &p, 0);
736 if (file_idx < 0 || file_idx >= nb_input_files) {
737 av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n",
738 file_idx, fg->graph_desc);
741 s = input_files[file_idx]->ctx;
743 for (i = 0; i < s->nb_streams; i++) {
744 if (s->streams[i]->codec->codec_type != type)
746 if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
752 av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
753 "matches no streams.\n", p, fg->graph_desc);
756 ist = input_streams[input_files[file_idx]->ist_index + st->index];
758 /* find the first unused stream of corresponding type */
759 for (i = 0; i < nb_input_streams; i++) {
760 ist = input_streams[i];
761 if (ist->st->codec->codec_type == type && ist->discard)
764 if (i == nb_input_streams) {
765 av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
766 "unlabeled input pad %d on filter %s\n", in->pad_idx,
767 in->filter_ctx->name);
774 ist->decoding_needed = 1;
775 ist->st->discard = AVDISCARD_NONE;
777 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
778 &fg->nb_inputs, fg->nb_inputs + 1);
779 if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
781 fg->inputs[fg->nb_inputs - 1]->ist = ist;
782 fg->inputs[fg->nb_inputs - 1]->graph = fg;
784 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
785 &ist->nb_filters, ist->nb_filters + 1);
786 ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
789 static int configure_output_video_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
792 OutputStream *ost = ofilter->ost;
793 AVCodecContext *codec = ost->st->codec;
794 AVFilterContext *last_filter = out->filter_ctx;
795 int pad_idx = out->pad_idx;
798 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
800 snprintf(name, sizeof(name), "output stream %d:%d", ost->file_index, ost->index);
801 ret = avfilter_graph_create_filter(&ofilter->filter,
802 avfilter_get_by_name("buffersink"),
803 name, NULL, NULL/*buffersink_params*/, fg->graph);
804 av_freep(&buffersink_params);
809 if (codec->width || codec->height) {
811 AVFilterContext *filter;
813 snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
816 (unsigned)ost->sws_flags);
817 snprintf(name, sizeof(name), "scaler for output stream %d:%d",
818 ost->file_index, ost->index);
819 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
820 name, args, NULL, fg->graph)) < 0)
822 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
825 last_filter = filter;
829 if ((pix_fmts = choose_pix_fmts(ost))) {
830 AVFilterContext *filter;
831 snprintf(name, sizeof(name), "pixel format for output stream %d:%d",
832 ost->file_index, ost->index);
833 if ((ret = avfilter_graph_create_filter(&filter,
834 avfilter_get_by_name("format"),
835 "format", pix_fmts, NULL,
838 if ((ret = avfilter_link(last_filter, pad_idx, filter, 0)) < 0)
841 last_filter = filter;
846 if (ost->frame_rate.num && 0) {
847 AVFilterContext *fps;
850 snprintf(args, sizeof(args), "fps=%d/%d", ost->frame_rate.num,
851 ost->frame_rate.den);
852 snprintf(name, sizeof(name), "fps for output stream %d:%d",
853 ost->file_index, ost->index);
854 ret = avfilter_graph_create_filter(&fps, avfilter_get_by_name("fps"),
855 name, args, NULL, fg->graph);
859 ret = avfilter_link(last_filter, pad_idx, fps, 0);
866 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
872 static int configure_output_audio_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
874 OutputStream *ost = ofilter->ost;
875 AVCodecContext *codec = ost->st->codec;
876 AVFilterContext *last_filter = out->filter_ctx;
877 int pad_idx = out->pad_idx;
878 char *sample_fmts, *sample_rates, *channel_layouts;
883 snprintf(name, sizeof(name), "output stream %d:%d", ost->file_index, ost->index);
884 ret = avfilter_graph_create_filter(&ofilter->filter,
885 avfilter_get_by_name("abuffersink"),
886 name, NULL, NULL, fg->graph);
890 #define AUTO_INSERT_FILTER(opt_name, filter_name, arg) do { \
891 AVFilterContext *filt_ctx; \
893 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
894 "similarly to -af " filter_name "=%s.\n", arg); \
896 ret = avfilter_graph_create_filter(&filt_ctx, \
897 avfilter_get_by_name(filter_name), \
898 filter_name, arg, NULL, fg->graph); \
902 ret = avfilter_link(last_filter, pad_idx, filt_ctx, 0); \
906 last_filter = filt_ctx; \
909 if (ost->audio_channels_mapped) {
912 av_bprint_init(&pan_buf, 256, 8192);
913 av_bprintf(&pan_buf, "0x%"PRIx64,
914 av_get_default_channel_layout(ost->audio_channels_mapped));
915 for (i = 0; i < ost->audio_channels_mapped; i++)
916 if (ost->audio_channels_map[i] != -1)
917 av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
919 AUTO_INSERT_FILTER("-map_channel", "pan", pan_buf.str);
920 av_bprint_finalize(&pan_buf, NULL);
923 if (codec->channels && !codec->channel_layout)
924 codec->channel_layout = av_get_default_channel_layout(codec->channels);
926 sample_fmts = choose_sample_fmts(ost);
927 sample_rates = choose_sample_rates(ost);
928 channel_layouts = choose_channel_layouts(ost);
929 if (sample_fmts || sample_rates || channel_layouts) {
930 AVFilterContext *format;
935 len += snprintf(args + len, sizeof(args) - len, "sample_fmts=%s:",
938 len += snprintf(args + len, sizeof(args) - len, "sample_rates=%s:",
941 len += snprintf(args + len, sizeof(args) - len, "channel_layouts=%s:",
945 av_freep(&sample_fmts);
946 av_freep(&sample_rates);
947 av_freep(&channel_layouts);
949 snprintf(name, sizeof(name), "audio format for output stream %d:%d",
950 ost->file_index, ost->index);
951 ret = avfilter_graph_create_filter(&format,
952 avfilter_get_by_name("aformat"),
953 name, args, NULL, fg->graph);
957 ret = avfilter_link(last_filter, pad_idx, format, 0);
961 last_filter = format;
965 if (audio_volume != 256 && 0) {
968 snprintf(args, sizeof(args), "%f", audio_volume / 256.);
969 AUTO_INSERT_FILTER("-vol", "volume", args);
972 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
978 #define DESCRIBE_FILTER_LINK(f, inout, in) \
980 AVFilterContext *ctx = inout->filter_ctx; \
981 AVFilterPad *pads = in ? ctx->input_pads : ctx->output_pads; \
982 int nb_pads = in ? ctx->input_count : ctx->output_count; \
985 if (avio_open_dyn_buf(&pb) < 0) \
988 avio_printf(pb, "%s", ctx->filter->name); \
990 avio_printf(pb, ":%s", avfilter_pad_get_name(pads, inout->pad_idx));\
992 avio_close_dyn_buf(pb, &f->name); \
995 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
997 av_freep(&ofilter->name);
998 DESCRIBE_FILTER_LINK(ofilter, out, 0);
1000 switch (avfilter_pad_get_type(out->filter_ctx->output_pads, out->pad_idx)) {
1001 case AVMEDIA_TYPE_VIDEO: return configure_output_video_filter(fg, ofilter, out);
1002 case AVMEDIA_TYPE_AUDIO: return configure_output_audio_filter(fg, ofilter, out);
1003 default: av_assert0(0);
1007 static int configure_input_video_filter(FilterGraph *fg, InputFilter *ifilter,
1010 AVFilterContext *first_filter = in->filter_ctx;
1011 AVFilter *filter = avfilter_get_by_name("buffer");
1012 InputStream *ist = ifilter->ist;
1013 AVRational tb = ist->framerate.num ? (AVRational){ist->framerate.den,
1014 ist->framerate.num} :
1016 AVRational fr = ist->framerate.num ? ist->framerate :
1017 ist->st->r_frame_rate;
1021 int pad_idx = in->pad_idx;
1024 sar = ist->st->sample_aspect_ratio.num ?
1025 ist->st->sample_aspect_ratio :
1026 ist->st->codec->sample_aspect_ratio;
1028 sar = (AVRational){0,1};
1029 av_bprint_init(&args, 0, 1);
1031 "video_size=%dx%d:pix_fmt=%d:time_base=%d/%d:"
1032 "pixel_aspect=%d/%d:sws_param=flags=%d", ist->st->codec->width,
1033 ist->st->codec->height, ist->st->codec->pix_fmt,
1034 tb.num, tb.den, sar.num, sar.den,
1035 SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
1036 if (fr.num && fr.den)
1037 av_bprintf(&args, ":frame_rate=%d/%d", fr.num, fr.den);
1038 snprintf(name, sizeof(name), "graph %d input from stream %d:%d", fg->index,
1039 ist->file_index, ist->st->index);
1041 if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter, name,
1042 args.str, NULL, fg->graph)) < 0)
1045 if (ist->framerate.num) {
1046 AVFilterContext *setpts;
1048 snprintf(name, sizeof(name), "force CFR for input from stream %d:%d",
1049 ist->file_index, ist->st->index);
1050 if ((ret = avfilter_graph_create_filter(&setpts,
1051 avfilter_get_by_name("setpts"),
1056 if ((ret = avfilter_link(setpts, 0, first_filter, pad_idx)) < 0)
1059 first_filter = setpts;
1063 if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
1068 static int configure_input_audio_filter(FilterGraph *fg, InputFilter *ifilter,
1071 AVFilterContext *first_filter = in->filter_ctx;
1072 AVFilter *filter = avfilter_get_by_name("abuffer");
1073 InputStream *ist = ifilter->ist;
1074 int pad_idx = in->pad_idx;
1075 char args[255], name[255];
1078 snprintf(args, sizeof(args), "time_base=%d/%d:sample_rate=%d:sample_fmt=%s"
1079 ":channel_layout=0x%"PRIx64,
1080 ist->st->time_base.num, ist->st->time_base.den,
1081 ist->st->codec->sample_rate,
1082 av_get_sample_fmt_name(ist->st->codec->sample_fmt),
1083 ist->st->codec->channel_layout);
1084 snprintf(name, sizeof(name), "graph %d input from stream %d:%d", fg->index,
1085 ist->file_index, ist->st->index);
1087 if ((ret = avfilter_graph_create_filter(&ifilter->filter, filter,
1092 #define AUTO_INSERT_FILTER_INPUT(opt_name, filter_name, arg) do { \
1093 AVFilterContext *filt_ctx; \
1095 av_log(NULL, AV_LOG_INFO, opt_name " is forwarded to lavfi " \
1096 "similarly to -af " filter_name "=%s.\n", arg); \
1098 snprintf(name, sizeof(name), "graph %d %s for input stream %d:%d", \
1099 fg->index, filter_name, ist->file_index, ist->st->index); \
1100 ret = avfilter_graph_create_filter(&filt_ctx, \
1101 avfilter_get_by_name(filter_name), \
1102 name, arg, NULL, fg->graph); \
1106 ret = avfilter_link(filt_ctx, 0, first_filter, pad_idx); \
1110 first_filter = filt_ctx; \
1113 if (audio_sync_method > 0) {
1114 char args[256] = {0};
1116 av_strlcatf(args, sizeof(args), "min_comp=0.001:min_hard_comp=%f", audio_drift_threshold);
1117 if (audio_sync_method > 1)
1118 av_strlcatf(args, sizeof(args), ":max_soft_comp=%f", audio_sync_method/(double)ist->st->codec->sample_rate);
1119 AUTO_INSERT_FILTER_INPUT("-async", "aresample", args);
1122 // if (ost->audio_channels_mapped) {
1124 // AVBPrint pan_buf;
1125 // av_bprint_init(&pan_buf, 256, 8192);
1126 // av_bprintf(&pan_buf, "0x%"PRIx64,
1127 // av_get_default_channel_layout(ost->audio_channels_mapped));
1128 // for (i = 0; i < ost->audio_channels_mapped; i++)
1129 // if (ost->audio_channels_map[i] != -1)
1130 // av_bprintf(&pan_buf, ":c%d=c%d", i, ost->audio_channels_map[i]);
1131 // AUTO_INSERT_FILTER_INPUT("-map_channel", "pan", pan_buf.str);
1132 // av_bprint_finalize(&pan_buf, NULL);
1135 if (audio_volume != 256) {
1138 snprintf(args, sizeof(args), "%f", audio_volume / 256.);
1139 AUTO_INSERT_FILTER_INPUT("-vol", "volume", args);
1141 if ((ret = avfilter_link(ifilter->filter, 0, first_filter, pad_idx)) < 0)
1147 static int configure_input_filter(FilterGraph *fg, InputFilter *ifilter,
1150 av_freep(&ifilter->name);
1151 DESCRIBE_FILTER_LINK(ifilter, in, 1);
1153 switch (avfilter_pad_get_type(in->filter_ctx->input_pads, in->pad_idx)) {
1154 case AVMEDIA_TYPE_VIDEO: return configure_input_video_filter(fg, ifilter, in);
1155 case AVMEDIA_TYPE_AUDIO: return configure_input_audio_filter(fg, ifilter, in);
1156 default: av_assert0(0);
1160 static int configure_filtergraph(FilterGraph *fg)
1162 AVFilterInOut *inputs, *outputs, *cur;
1163 int ret, i, init = !fg->graph, simple = !fg->graph_desc;
1164 const char *graph_desc = simple ? fg->outputs[0]->ost->avfilter :
1167 avfilter_graph_free(&fg->graph);
1168 if (!(fg->graph = avfilter_graph_alloc()))
1169 return AVERROR(ENOMEM);
1172 OutputStream *ost = fg->outputs[0]->ost;
1174 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
1175 fg->graph->scale_sws_opts = av_strdup(args);
1178 if ((ret = avfilter_graph_parse2(fg->graph, graph_desc, &inputs, &outputs)) < 0)
1181 if (simple && (!inputs || inputs->next || !outputs || outputs->next)) {
1182 av_log(NULL, AV_LOG_ERROR, "Simple filtergraph '%s' does not have "
1183 "exactly one input and output.\n", graph_desc);
1184 return AVERROR(EINVAL);
1187 for (cur = inputs; !simple && init && cur; cur = cur->next)
1188 init_input_filter(fg, cur);
1190 for (cur = inputs, i = 0; cur; cur = cur->next, i++)
1191 if ((ret = configure_input_filter(fg, fg->inputs[i], cur)) < 0)
1193 avfilter_inout_free(&inputs);
1195 if (!init || simple) {
1196 /* we already know the mappings between lavfi outputs and output streams,
1197 * so we can finish the setup */
1198 for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1199 configure_output_filter(fg, fg->outputs[i], cur);
1200 avfilter_inout_free(&outputs);
1202 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1205 /* wait until output mappings are processed */
1206 for (cur = outputs; cur;) {
1207 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1208 &fg->nb_outputs, fg->nb_outputs + 1);
1209 if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1211 fg->outputs[fg->nb_outputs - 1]->graph = fg;
1212 fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1214 fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1221 static int configure_complex_filters(void)
1225 for (i = 0; i < nb_filtergraphs; i++)
1226 if (!filtergraphs[i]->graph &&
1227 (ret = configure_filtergraph(filtergraphs[i])) < 0)
1232 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1235 for (i = 0; i < fg->nb_inputs; i++)
1236 if (fg->inputs[i]->ist == ist)
1241 static void term_exit(void)
1243 av_log(NULL, AV_LOG_QUIET, "%s", "");
1246 tcsetattr (0, TCSANOW, &oldtty);
1250 static volatile int received_sigterm = 0;
1252 static void sigterm_handler(int sig)
1254 received_sigterm = sig;
1255 received_nb_signals++;
1257 if(received_nb_signals > 3)
1261 static void term_init(void)
1268 istty = isatty(0) && isatty(2);
1270 if (istty && tcgetattr (0, &tty) == 0) {
1275 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1276 |INLCR|IGNCR|ICRNL|IXON);
1277 tty.c_oflag |= OPOST;
1278 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1279 tty.c_cflag &= ~(CSIZE|PARENB);
1282 tty.c_cc[VTIME] = 0;
1284 tcsetattr (0, TCSANOW, &tty);
1286 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
1289 avformat_network_deinit();
1291 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
1292 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
1294 signal(SIGXCPU, sigterm_handler);
1298 /* read a key without blocking */
1299 static int read_key(void)
1311 n = select(1, &rfds, NULL, NULL, &tv);
1313 n = read(0, &ch, 1);
1320 # if HAVE_PEEKNAMEDPIPE
1322 static HANDLE input_handle;
1325 input_handle = GetStdHandle(STD_INPUT_HANDLE);
1326 is_pipe = !GetConsoleMode(input_handle, &dw);
1329 if (stdin->_cnt > 0) {
1334 /* When running under a GUI, you will end here. */
1335 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
1352 static int decode_interrupt_cb(void *ctx)
1354 return received_nb_signals > 1;
1357 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1359 void av_noreturn exit_program(int ret)
1363 for (i = 0; i < nb_filtergraphs; i++) {
1364 avfilter_graph_free(&filtergraphs[i]->graph);
1365 for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
1366 av_freep(&filtergraphs[i]->inputs[j]->name);
1367 av_freep(&filtergraphs[i]->inputs[j]);
1369 av_freep(&filtergraphs[i]->inputs);
1370 for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
1371 av_freep(&filtergraphs[i]->outputs[j]->name);
1372 av_freep(&filtergraphs[i]->outputs[j]);
1374 av_freep(&filtergraphs[i]->outputs);
1375 av_freep(&filtergraphs[i]);
1377 av_freep(&filtergraphs);
1379 av_freep(&subtitle_out);
1382 for (i = 0; i < nb_output_files; i++) {
1383 AVFormatContext *s = output_files[i]->ctx;
1384 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1386 avformat_free_context(s);
1387 av_dict_free(&output_files[i]->opts);
1388 av_freep(&output_files[i]);
1390 for (i = 0; i < nb_output_streams; i++) {
1391 AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1393 AVBitStreamFilterContext *next = bsfc->next;
1394 av_bitstream_filter_close(bsfc);
1397 output_streams[i]->bitstream_filters = NULL;
1399 av_freep(&output_streams[i]->forced_keyframes);
1400 av_freep(&output_streams[i]->filtered_frame);
1401 av_freep(&output_streams[i]->avfilter);
1402 av_freep(&output_streams[i]);
1404 for (i = 0; i < nb_input_files; i++) {
1405 avformat_close_input(&input_files[i]->ctx);
1406 av_freep(&input_files[i]);
1408 for (i = 0; i < nb_input_streams; i++) {
1409 av_freep(&input_streams[i]->decoded_frame);
1410 av_dict_free(&input_streams[i]->opts);
1411 free_buffer_pool(&input_streams[i]->buffer_pool);
1412 av_freep(&input_streams[i]->filters);
1413 av_freep(&input_streams[i]);
1417 fclose(vstats_file);
1418 av_free(vstats_filename);
1420 av_freep(&input_streams);
1421 av_freep(&input_files);
1422 av_freep(&output_streams);
1423 av_freep(&output_files);
1428 avformat_network_deinit();
1430 if (received_sigterm) {
1431 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1432 (int) received_sigterm);
1439 static void assert_avoptions(AVDictionary *m)
1441 AVDictionaryEntry *t;
1442 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1443 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1448 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1450 const char *codec_string = encoder ? "encoder" : "decoder";
1452 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1453 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1454 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1455 "results.\nAdd '-strict experimental' if you want to use it.\n",
1456 codec_string, c->codec->name);
1457 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1458 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1459 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1460 codec_string, codec->name);
1465 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
1467 if (codec && codec->sample_fmts) {
1468 const enum AVSampleFormat *p = codec->sample_fmts;
1469 for (; *p != -1; p++) {
1470 if (*p == st->codec->sample_fmt)
1474 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
1475 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
1476 if(av_get_sample_fmt_name(st->codec->sample_fmt))
1477 av_log(NULL, AV_LOG_WARNING,
1478 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
1479 av_get_sample_fmt_name(st->codec->sample_fmt),
1481 av_get_sample_fmt_name(codec->sample_fmts[0]));
1482 st->codec->sample_fmt = codec->sample_fmts[0];
1487 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1489 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1490 AVCodecContext *avctx = ost->st->codec;
1493 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1494 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1495 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1497 if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
1498 int64_t max = ost->st->cur_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
1499 if (ost->st->cur_dts && ost->st->cur_dts != AV_NOPTS_VALUE && max > pkt->dts) {
1500 av_log(s, max - pkt->dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG, "Audio timestamp %"PRId64" < %"PRId64" invalid, cliping\n", pkt->dts, max);
1501 pkt->pts = pkt->dts = max;
1506 * Audio encoders may split the packets -- #frames in != #packets out.
1507 * But there is no reordering, so we can limit the number of output packets
1508 * by simply dropping them here.
1509 * Counting encoded video frames needs to be done separately because of
1510 * reordering, see do_video_out()
1512 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1513 if (ost->frame_number >= ost->max_frames) {
1514 av_free_packet(pkt);
1517 ost->frame_number++;
1521 AVPacket new_pkt = *pkt;
1522 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1523 &new_pkt.data, &new_pkt.size,
1524 pkt->data, pkt->size,
1525 pkt->flags & AV_PKT_FLAG_KEY);
1527 av_free_packet(pkt);
1528 new_pkt.destruct = av_destruct_packet;
1530 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1531 bsfc->filter->name, pkt->stream_index,
1532 avctx->codec ? avctx->codec->name : "copy");
1542 pkt->stream_index = ost->index;
1543 ret = av_interleaved_write_frame(s, pkt);
1545 print_error("av_interleaved_write_frame()", ret);
1550 static int check_recording_time(OutputStream *ost)
1552 OutputFile *of = output_files[ost->file_index];
1554 if (of->recording_time != INT64_MAX &&
1555 av_compare_ts(ost->sync_opts - ost->first_pts, ost->st->codec->time_base, of->recording_time,
1556 AV_TIME_BASE_Q) >= 0) {
1557 ost->is_past_recording_time = 1;
1563 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1566 AVCodecContext *enc = ost->st->codec;
1570 av_init_packet(&pkt);
1574 if (!check_recording_time(ost))
1577 if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
1578 frame->pts = ost->sync_opts;
1579 ost->sync_opts = frame->pts + frame->nb_samples;
1581 av_assert0(pkt.size || !pkt.data);
1582 update_benchmark(NULL);
1583 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1584 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1587 update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
1590 if (pkt.pts != AV_NOPTS_VALUE)
1591 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1592 if (pkt.dts != AV_NOPTS_VALUE)
1593 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1594 if (pkt.duration > 0)
1595 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1598 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1599 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1600 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1601 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1604 write_frame(s, &pkt, ost);
1606 audio_size += pkt.size;
1607 av_free_packet(&pkt);
1611 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1613 AVCodecContext *dec;
1614 AVPicture *picture2;
1615 AVPicture picture_tmp;
1618 dec = ist->st->codec;
1620 /* deinterlace : must be done before any resize */
1621 if (do_deinterlace) {
1624 /* create temporary picture */
1625 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1626 buf = av_malloc(size);
1630 picture2 = &picture_tmp;
1631 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1633 if (avpicture_deinterlace(picture2, picture,
1634 dec->pix_fmt, dec->width, dec->height) < 0) {
1635 /* if error, do not deinterlace */
1636 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1645 if (picture != picture2)
1646 *picture = *picture2;
1650 static void do_subtitle_out(AVFormatContext *s,
1656 int subtitle_out_max_size = 1024 * 1024;
1657 int subtitle_out_size, nb, i;
1658 AVCodecContext *enc;
1661 if (pts == AV_NOPTS_VALUE) {
1662 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1668 enc = ost->st->codec;
1670 if (!subtitle_out) {
1671 subtitle_out = av_malloc(subtitle_out_max_size);
1674 /* Note: DVB subtitle need one packet to draw them and one other
1675 packet to clear them */
1676 /* XXX: signal it in the codec context ? */
1677 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1682 for (i = 0; i < nb; i++) {
1683 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1685 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1686 // start_display_time is required to be 0
1687 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1688 sub->end_display_time -= sub->start_display_time;
1689 sub->start_display_time = 0;
1690 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1691 subtitle_out_max_size, sub);
1692 if (subtitle_out_size < 0) {
1693 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1697 av_init_packet(&pkt);
1698 pkt.data = subtitle_out;
1699 pkt.size = subtitle_out_size;
1700 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1701 pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
1702 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1703 /* XXX: the pts correction is handled here. Maybe handling
1704 it in the codec would be better */
1706 pkt.pts += 90 * sub->start_display_time;
1708 pkt.pts += 90 * sub->end_display_time;
1710 write_frame(s, &pkt, ost);
1711 subtitle_size += pkt.size;
1715 static void do_video_out(AVFormatContext *s,
1717 AVFrame *in_picture,
1720 int ret, format_video_sync;
1722 AVCodecContext *enc = ost->st->codec;
1724 double sync_ipts, delta;
1725 double duration = 0;
1727 InputStream *ist = NULL;
1729 if (ost->source_index >= 0)
1730 ist = input_streams[ost->source_index];
1732 if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1733 duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));
1735 sync_ipts = in_picture->pts;
1736 delta = sync_ipts - ost->sync_opts + duration;
1738 /* by default, we output a single frame */
1741 format_video_sync = video_sync_method;
1742 if (format_video_sync == VSYNC_AUTO)
1743 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1745 switch (format_video_sync) {
1747 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1750 else if (delta > 1.1)
1751 nb_frames = lrintf(delta);
1756 else if (delta > 0.6)
1757 ost->sync_opts = lrint(sync_ipts);
1760 case VSYNC_PASSTHROUGH:
1761 ost->sync_opts = lrint(sync_ipts);
1767 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1768 if (nb_frames == 0) {
1770 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1772 } else if (nb_frames > 1) {
1773 nb_frames_dup += nb_frames - 1;
1774 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1779 av_init_packet(&pkt);
1783 in_picture->pts = ost->sync_opts;
1785 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1786 enc->codec->id == CODEC_ID_RAWVIDEO) {
1787 /* raw pictures are written as AVPicture structure to
1788 avoid any copies. We support temporarily the older
1790 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1791 enc->coded_frame->top_field_first = in_picture->top_field_first;
1792 pkt.data = (uint8_t *)in_picture;
1793 pkt.size = sizeof(AVPicture);
1794 pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
1795 pkt.flags |= AV_PKT_FLAG_KEY;
1797 write_frame(s, &pkt, ost);
1798 video_size += pkt.size;
1801 AVFrame big_picture;
1803 big_picture = *in_picture;
1804 /* better than nothing: use input picture interlaced
1806 big_picture.interlaced_frame = in_picture->interlaced_frame;
1807 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1808 if (ost->top_field_first == -1)
1809 big_picture.top_field_first = in_picture->top_field_first;
1811 big_picture.top_field_first = !!ost->top_field_first;
1814 /* handles same_quant here. This is not correct because it may
1815 not be a global option */
1816 big_picture.quality = quality;
1817 if (!enc->me_threshold)
1818 big_picture.pict_type = 0;
1819 if (ost->forced_kf_index < ost->forced_kf_count &&
1820 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1821 big_picture.pict_type = AV_PICTURE_TYPE_I;
1822 ost->forced_kf_index++;
1824 update_benchmark(NULL);
1825 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
1826 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1828 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1833 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
1834 pkt.pts = ost->sync_opts;
1836 if (pkt.pts != AV_NOPTS_VALUE)
1837 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1838 if (pkt.dts != AV_NOPTS_VALUE)
1839 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1842 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1843 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1844 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1845 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1848 write_frame(s, &pkt, ost);
1849 frame_size = pkt.size;
1850 video_size += pkt.size;
1851 av_free_packet(&pkt);
1853 /* if two pass, output log */
1854 if (ost->logfile && enc->stats_out) {
1855 fprintf(ost->logfile, "%s", enc->stats_out);
1861 * For video, number of frames in == number of packets out.
1862 * But there may be reordering, so we can't throw away frames on encoder
1863 * flush, we need to limit them here, before they go into encoder.
1865 ost->frame_number++;
1868 goto duplicate_frame;
1870 if (vstats_filename && frame_size)
1871 do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
1874 static double psnr(double d)
1876 return -10.0 * log(d) / log(10.0);
1879 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1882 AVCodecContext *enc;
1884 double ti1, bitrate, avg_bitrate;
1886 /* this is executed just the first time do_video_stats is called */
1888 vstats_file = fopen(vstats_filename, "w");
1895 enc = ost->st->codec;
1896 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1897 frame_number = ost->frame_number;
1898 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1899 if (enc->flags&CODEC_FLAG_PSNR)
1900 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1902 fprintf(vstats_file,"f_size= %6d ", frame_size);
1903 /* compute pts value */
1904 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1908 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1909 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1910 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1911 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1912 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1916 /* check for new output on any of the filtergraphs */
1917 static int poll_filters(void)
1919 AVFilterBufferRef *picref;
1920 AVFrame *filtered_frame = NULL;
1921 int i, ret, ret_all;
1922 unsigned nb_success, nb_eof;
1926 /* Reap all buffers present in the buffer sinks */
1927 for (i = 0; i < nb_output_streams; i++) {
1928 OutputStream *ost = output_streams[i];
1929 OutputFile *of = output_files[ost->file_index];
1935 if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
1936 return AVERROR(ENOMEM);
1938 avcodec_get_frame_defaults(ost->filtered_frame);
1939 filtered_frame = ost->filtered_frame;
1941 while (!ost->is_past_recording_time) {
1942 ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
1943 AV_BUFFERSINK_FLAG_NO_REQUEST);
1945 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1947 av_strerror(ret, buf, sizeof(buf));
1948 av_log(NULL, AV_LOG_WARNING,
1949 "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
1953 frame_pts = AV_NOPTS_VALUE;
1954 if (picref->pts != AV_NOPTS_VALUE) {
1955 filtered_frame->pts = frame_pts = av_rescale_q(picref->pts,
1956 ost->filter->filter->inputs[0]->time_base,
1957 ost->st->codec->time_base) -
1958 av_rescale_q(of->start_time,
1960 ost->st->codec->time_base);
1962 if (of->start_time && filtered_frame->pts < 0) {
1963 avfilter_unref_buffer(picref);
1967 //if (ost->source_index >= 0)
1968 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1971 switch (ost->filter->filter->inputs[0]->type) {
1972 case AVMEDIA_TYPE_VIDEO:
1973 avfilter_copy_buf_props(filtered_frame, picref);
1974 filtered_frame->pts = frame_pts;
1975 if (!ost->frame_aspect_ratio)
1976 ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
1978 do_video_out(of->ctx, ost, filtered_frame,
1979 same_quant ? ost->last_quality :
1980 ost->st->codec->global_quality);
1982 case AVMEDIA_TYPE_AUDIO:
1983 avfilter_copy_buf_props(filtered_frame, picref);
1984 filtered_frame->pts = frame_pts;
1985 do_audio_out(of->ctx, ost, filtered_frame);
1988 // TODO support subtitle filters
1992 avfilter_unref_buffer(picref);
1995 /* Request frames through all the graphs */
1996 ret_all = nb_success = nb_eof = 0;
1997 for (i = 0; i < nb_filtergraphs; i++) {
1998 ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
2001 } else if (ret == AVERROR_EOF) {
2003 } else if (ret != AVERROR(EAGAIN)) {
2005 av_strerror(ret, buf, sizeof(buf));
2006 av_log(NULL, AV_LOG_WARNING,
2007 "Error in request_frame(): %s\n", buf);
2013 /* Try again if anything succeeded */
2015 return nb_eof == nb_filtergraphs ? AVERROR_EOF : ret_all;
2018 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
2022 AVFormatContext *oc;
2024 AVCodecContext *enc;
2025 int frame_number, vid, i;
2027 int64_t pts = INT64_MAX;
2028 static int64_t last_time = -1;
2029 static int qp_histogram[52];
2030 int hours, mins, secs, us;
2032 if (!print_stats && !is_last_report)
2035 if (!is_last_report) {
2036 if (last_time == -1) {
2037 last_time = cur_time;
2040 if ((cur_time - last_time) < 500000)
2042 last_time = cur_time;
2046 oc = output_files[0]->ctx;
2048 total_size = avio_size(oc->pb);
2049 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
2050 total_size = avio_tell(oc->pb);
2057 for (i = 0; i < nb_output_streams; i++) {
2059 ost = output_streams[i];
2060 enc = ost->st->codec;
2061 if (!ost->stream_copy && enc->coded_frame)
2062 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
2063 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2064 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
2066 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2067 float fps, t = (cur_time-timer_start) / 1000000.0;
2069 frame_number = ost->frame_number;
2070 fps = t > 1 ? frame_number / t : 0;
2071 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
2072 frame_number, fps < 9.95, fps, q);
2074 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
2078 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
2080 for (j = 0; j < 32; j++)
2081 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
2083 if (enc->flags&CODEC_FLAG_PSNR) {
2085 double error, error_sum = 0;
2086 double scale, scale_sum = 0;
2087 char type[3] = { 'Y','U','V' };
2088 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
2089 for (j = 0; j < 3; j++) {
2090 if (is_last_report) {
2091 error = enc->error[j];
2092 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
2094 error = enc->coded_frame->error[j];
2095 scale = enc->width * enc->height * 255.0 * 255.0;
2101 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
2103 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
2107 /* compute min output value */
2108 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
2109 ost->st->time_base, AV_TIME_BASE_Q));
2112 secs = pts / AV_TIME_BASE;
2113 us = pts % AV_TIME_BASE;
2119 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
2121 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2122 "size=%8.0fkB time=", total_size / 1024.0);
2123 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2124 "%02d:%02d:%02d.%02d ", hours, mins, secs,
2125 (100 * us) / AV_TIME_BASE);
2126 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2127 "bitrate=%6.1fkbits/s", bitrate);
2129 if (nb_frames_dup || nb_frames_drop)
2130 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
2131 nb_frames_dup, nb_frames_drop);
2133 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
2137 if (is_last_report) {
2138 int64_t raw= audio_size + video_size + subtitle_size + extra_size;
2139 av_log(NULL, AV_LOG_INFO, "\n");
2140 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0f global headers:%1.0fkB muxing overhead %f%%\n",
2141 video_size / 1024.0,
2142 audio_size / 1024.0,
2143 subtitle_size / 1024.0,
2144 extra_size / 1024.0,
2145 100.0 * (total_size - raw) / raw
2147 if(video_size + audio_size + subtitle_size + extra_size == 0){
2148 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
2153 static void flush_encoders(void)
2157 for (i = 0; i < nb_output_streams; i++) {
2158 OutputStream *ost = output_streams[i];
2159 AVCodecContext *enc = ost->st->codec;
2160 AVFormatContext *os = output_files[ost->file_index]->ctx;
2161 int stop_encoding = 0;
2163 if (!ost->encoding_needed)
2166 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
2168 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
2172 int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
2176 switch (ost->st->codec->codec_type) {
2177 case AVMEDIA_TYPE_AUDIO:
2178 encode = avcodec_encode_audio2;
2182 case AVMEDIA_TYPE_VIDEO:
2183 encode = avcodec_encode_video2;
2194 av_init_packet(&pkt);
2198 update_benchmark(NULL);
2199 ret = encode(enc, &pkt, NULL, &got_packet);
2200 update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index);
2202 av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
2206 if (ost->logfile && enc->stats_out) {
2207 fprintf(ost->logfile, "%s", enc->stats_out);
2213 if (pkt.pts != AV_NOPTS_VALUE)
2214 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2215 if (pkt.dts != AV_NOPTS_VALUE)
2216 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2217 write_frame(os, &pkt, ost);
2227 * Check whether a packet from ist should be written into ost at this time
2229 static int check_output_constraints(InputStream *ist, OutputStream *ost)
2231 OutputFile *of = output_files[ost->file_index];
2232 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
2234 if (ost->source_index != ist_index)
2237 if (of->start_time && ist->pts < of->start_time)
2240 if (of->recording_time != INT64_MAX &&
2241 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
2242 (AVRational){ 1, 1000000 }) >= 0) {
2243 ost->is_past_recording_time = 1;
2250 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2252 OutputFile *of = output_files[ost->file_index];
2253 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
2257 av_init_packet(&opkt);
2259 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2260 !ost->copy_initial_nonkeyframes)
2263 /* force the input stream PTS */
2264 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2265 audio_size += pkt->size;
2266 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2267 video_size += pkt->size;
2269 } else if (ost->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2270 subtitle_size += pkt->size;
2273 if (pkt->pts != AV_NOPTS_VALUE)
2274 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
2276 opkt.pts = AV_NOPTS_VALUE;
2278 if (pkt->dts == AV_NOPTS_VALUE)
2279 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
2281 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
2282 opkt.dts -= ost_tb_start_time;
2284 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
2285 opkt.flags = pkt->flags;
2287 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2288 if ( ost->st->codec->codec_id != CODEC_ID_H264
2289 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
2290 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
2291 && ost->st->codec->codec_id != CODEC_ID_VC1
2293 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
2294 opkt.destruct = av_destruct_packet;
2296 opkt.data = pkt->data;
2297 opkt.size = pkt->size;
2299 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2300 /* store AVPicture in AVPacket, as expected by the output format */
2301 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2302 opkt.data = (uint8_t *)&pict;
2303 opkt.size = sizeof(AVPicture);
2304 opkt.flags |= AV_PKT_FLAG_KEY;
2307 write_frame(of->ctx, &opkt, ost);
2308 ost->st->codec->frame_number++;
2309 av_free_packet(&opkt);
2312 static void rate_emu_sleep(InputStream *ist)
2314 if (input_files[ist->file_index]->rate_emu) {
2315 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2316 int64_t now = av_gettime() - ist->start;
2318 av_usleep(pts - now);
2322 static int guess_input_channel_layout(InputStream *ist)
2324 AVCodecContext *dec = ist->st->codec;
2326 if (!dec->channel_layout) {
2327 char layout_name[256];
2329 dec->channel_layout = av_get_default_channel_layout(dec->channels);
2330 if (!dec->channel_layout)
2332 av_get_channel_layout_string(layout_name, sizeof(layout_name),
2333 dec->channels, dec->channel_layout);
2334 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2335 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2340 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2342 AVFrame *decoded_frame;
2343 AVCodecContext *avctx = ist->st->codec;
2344 int i, ret, resample_changed;
2346 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2347 return AVERROR(ENOMEM);
2349 avcodec_get_frame_defaults(ist->decoded_frame);
2350 decoded_frame = ist->decoded_frame;
2352 update_benchmark(NULL);
2353 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2354 update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2358 if (avctx->sample_rate <= 0) {
2359 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2360 return AVERROR_INVALIDDATA;
2364 /* no audio frame */
2366 for (i = 0; i < ist->nb_filters; i++)
2367 av_buffersrc_add_ref(ist->filters[i]->filter, NULL,
2368 AV_BUFFERSRC_FLAG_NO_COPY);
2372 /* if the decoder provides a pts, use it instead of the last packet pts.
2373 the decoder could be delaying output by a packet or more. */
2374 if (decoded_frame->pts != AV_NOPTS_VALUE)
2375 ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2376 else if (pkt->pts != AV_NOPTS_VALUE) {
2377 decoded_frame->pts = pkt->pts;
2378 pkt->pts = AV_NOPTS_VALUE;
2380 decoded_frame->pts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2384 /* increment next_dts to use for the case where the input stream does not
2385 have timestamps or there are multiple frames in the packet */
2386 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2388 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2392 rate_emu_sleep(ist);
2394 resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
2395 ist->resample_channels != avctx->channels ||
2396 ist->resample_channel_layout != decoded_frame->channel_layout ||
2397 ist->resample_sample_rate != decoded_frame->sample_rate;
2398 if (resample_changed) {
2399 char layout1[64], layout2[64];
2401 if (!guess_input_channel_layout(ist)) {
2402 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
2403 "layout for Input Stream #%d.%d\n", ist->file_index,
2407 decoded_frame->channel_layout = avctx->channel_layout;
2409 av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
2410 ist->resample_channel_layout);
2411 av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
2412 decoded_frame->channel_layout);
2414 av_log(NULL, AV_LOG_INFO,
2415 "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",
2416 ist->file_index, ist->st->index,
2417 ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt),
2418 ist->resample_channels, layout1,
2419 decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2420 avctx->channels, layout2);
2422 ist->resample_sample_fmt = decoded_frame->format;
2423 ist->resample_sample_rate = decoded_frame->sample_rate;
2424 ist->resample_channel_layout = decoded_frame->channel_layout;
2425 ist->resample_channels = avctx->channels;
2427 for (i = 0; i < nb_filtergraphs; i++)
2428 if (ist_in_filtergraph(filtergraphs[i], ist)) {
2429 FilterGraph *fg = filtergraphs[i];
2431 if (configure_filtergraph(fg) < 0) {
2432 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2435 for (j = 0; j < fg->nb_outputs; j++) {
2436 OutputStream *ost = fg->outputs[j]->ost;
2437 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2438 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
2439 av_buffersink_set_frame_size(ost->filter->filter,
2440 ost->st->codec->frame_size);
2445 for (i = 0; i < ist->nb_filters; i++)
2446 av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0);
2451 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2453 AVFrame *decoded_frame;
2454 void *buffer_to_free = NULL;
2455 int i, ret = 0, resample_changed;
2456 int64_t best_effort_timestamp;
2457 AVRational *frame_sample_aspect;
2460 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2461 return AVERROR(ENOMEM);
2463 avcodec_get_frame_defaults(ist->decoded_frame);
2464 decoded_frame = ist->decoded_frame;
2465 pkt->dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2467 update_benchmark(NULL);
2468 ret = avcodec_decode_video2(ist->st->codec,
2469 decoded_frame, got_output, pkt);
2470 update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2474 quality = same_quant ? decoded_frame->quality : 0;
2476 /* no picture yet */
2478 for (i = 0; i < ist->nb_filters; i++)
2479 av_buffersrc_add_ref(ist->filters[i]->filter, NULL, AV_BUFFERSRC_FLAG_NO_COPY);
2483 if(ist->top_field_first>=0)
2484 decoded_frame->top_field_first = ist->top_field_first;
2486 best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2487 if(best_effort_timestamp != AV_NOPTS_VALUE)
2488 ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2491 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2493 rate_emu_sleep(ist);
2495 if (ist->st->sample_aspect_ratio.num)
2496 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2498 resample_changed = ist->resample_width != decoded_frame->width ||
2499 ist->resample_height != decoded_frame->height ||
2500 ist->resample_pix_fmt != decoded_frame->format;
2501 if (resample_changed) {
2502 av_log(NULL, AV_LOG_INFO,
2503 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2504 ist->file_index, ist->st->index,
2505 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2506 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2508 ist->resample_width = decoded_frame->width;
2509 ist->resample_height = decoded_frame->height;
2510 ist->resample_pix_fmt = decoded_frame->format;
2512 for (i = 0; i < nb_filtergraphs; i++)
2513 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2514 configure_filtergraph(filtergraphs[i]) < 0) {
2515 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2520 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2521 for (i = 0; i < ist->nb_filters; i++) {
2522 int changed = ist->st->codec->width != ist->filters[i]->filter->outputs[0]->w
2523 || ist->st->codec->height != ist->filters[i]->filter->outputs[0]->h
2524 || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2525 // XXX what an ugly hack
2526 if (ist->filters[i]->graph->nb_outputs == 1)
2527 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2529 if (!frame_sample_aspect->num)
2530 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2531 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2532 FrameBuffer *buf = decoded_frame->opaque;
2533 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2534 decoded_frame->data, decoded_frame->linesize,
2535 AV_PERM_READ | AV_PERM_PRESERVE,
2536 ist->st->codec->width, ist->st->codec->height,
2537 ist->st->codec->pix_fmt);
2539 avfilter_copy_frame_props(fb, decoded_frame);
2540 fb->buf->priv = buf;
2541 fb->buf->free = filter_release_buffer;
2543 av_assert0(buf->refcount>0);
2545 av_buffersrc_add_ref(ist->filters[i]->filter, fb,
2546 AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
2547 AV_BUFFERSRC_FLAG_NO_COPY);
2549 if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0)<0) {
2550 av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2556 av_free(buffer_to_free);
2560 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2562 AVSubtitle subtitle;
2563 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2564 &subtitle, got_output, pkt);
2570 rate_emu_sleep(ist);
2572 for (i = 0; i < nb_output_streams; i++) {
2573 OutputStream *ost = output_streams[i];
2575 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2578 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2581 avsubtitle_free(&subtitle);
2585 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2586 static int output_packet(InputStream *ist, const AVPacket *pkt)
2592 if (!ist->saw_first_ts) {
2593 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;
2595 if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2596 ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2597 ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2599 ist->saw_first_ts = 1;
2602 if (ist->next_dts == AV_NOPTS_VALUE)
2603 ist->next_dts = ist->dts;
2604 if (ist->next_pts == AV_NOPTS_VALUE)
2605 ist->next_pts = ist->pts;
2609 av_init_packet(&avpkt);
2617 if (pkt->dts != AV_NOPTS_VALUE) {
2618 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2619 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2620 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2623 // while we have more to decode or while the decoder did output something on EOF
2624 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2628 ist->pts = ist->next_pts;
2629 ist->dts = ist->next_dts;
2631 if (avpkt.size && avpkt.size != pkt->size) {
2632 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2633 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2634 ist->showed_multi_packet_warning = 1;
2637 switch (ist->st->codec->codec_type) {
2638 case AVMEDIA_TYPE_AUDIO:
2639 ret = decode_audio (ist, &avpkt, &got_output);
2641 case AVMEDIA_TYPE_VIDEO:
2642 ret = decode_video (ist, &avpkt, &got_output);
2643 if (avpkt.duration) {
2644 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2645 } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2646 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2647 duration = ((int64_t)AV_TIME_BASE *
2648 ist->st->codec->time_base.num * ticks) /
2649 ist->st->codec->time_base.den;
2653 if(ist->dts != AV_NOPTS_VALUE && duration) {
2654 ist->next_dts += duration;
2656 ist->next_dts = AV_NOPTS_VALUE;
2659 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2661 case AVMEDIA_TYPE_SUBTITLE:
2662 ret = transcode_subtitles(ist, &avpkt, &got_output);
2672 avpkt.pts= AV_NOPTS_VALUE;
2674 // touch data and size only if not EOF
2676 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2686 /* handle stream copy */
2687 if (!ist->decoding_needed) {
2688 rate_emu_sleep(ist);
2689 ist->dts = ist->next_dts;
2690 switch (ist->st->codec->codec_type) {
2691 case AVMEDIA_TYPE_AUDIO:
2692 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2693 ist->st->codec->sample_rate;
2695 case AVMEDIA_TYPE_VIDEO:
2696 if (pkt->duration) {
2697 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2698 } else if(ist->st->codec->time_base.num != 0) {
2699 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2700 ist->next_dts += ((int64_t)AV_TIME_BASE *
2701 ist->st->codec->time_base.num * ticks) /
2702 ist->st->codec->time_base.den;
2706 ist->pts = ist->dts;
2707 ist->next_pts = ist->next_dts;
2709 for (i = 0; pkt && i < nb_output_streams; i++) {
2710 OutputStream *ost = output_streams[i];
2712 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2715 do_streamcopy(ist, ost, pkt);
2721 static void print_sdp(void)
2725 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2729 for (i = 0; i < nb_output_files; i++)
2730 avc[i] = output_files[i]->ctx;
2732 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2733 printf("SDP:\n%s\n", sdp);
2738 static int init_input_stream(int ist_index, char *error, int error_len)
2740 InputStream *ist = input_streams[ist_index];
2742 if (ist->decoding_needed) {
2743 AVCodec *codec = ist->dec;
2745 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2746 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2747 return AVERROR(EINVAL);
2750 ist->dr1 = (codec->capabilities & CODEC_CAP_DR1) && !do_deinterlace;
2751 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2752 ist->st->codec->get_buffer = codec_get_buffer;
2753 ist->st->codec->release_buffer = codec_release_buffer;
2754 ist->st->codec->opaque = &ist->buffer_pool;
2757 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2758 av_dict_set(&ist->opts, "threads", "auto", 0);
2759 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2760 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2761 ist->file_index, ist->st->index);
2762 return AVERROR(EINVAL);
2764 assert_codec_experimental(ist->st->codec, 0);
2765 assert_avoptions(ist->opts);
2768 ist->next_pts = AV_NOPTS_VALUE;
2769 ist->next_dts = AV_NOPTS_VALUE;
2775 static InputStream *get_input_stream(OutputStream *ost)
2777 if (ost->source_index >= 0)
2778 return input_streams[ost->source_index];
2782 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2783 AVCodecContext *avctx)
2789 for (p = kf; *p; p++)
2792 ost->forced_kf_count = n;
2793 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2794 if (!ost->forced_kf_pts) {
2795 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2799 for (i = 0; i < n; i++) {
2800 char *next = strchr(p, ',');
2801 if (next) *next++ = 0;
2802 t = parse_time_or_die("force_key_frames", p, 1);
2803 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2808 static int transcode_init(void)
2810 int ret = 0, i, j, k;
2811 AVFormatContext *oc;
2812 AVCodecContext *codec, *icodec = NULL;
2818 /* init framerate emulation */
2819 for (i = 0; i < nb_input_files; i++) {
2820 InputFile *ifile = input_files[i];
2821 if (ifile->rate_emu)
2822 for (j = 0; j < ifile->nb_streams; j++)
2823 input_streams[j + ifile->ist_index]->start = av_gettime();
2826 /* output stream init */
2827 for (i = 0; i < nb_output_files; i++) {
2828 oc = output_files[i]->ctx;
2829 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2830 av_dump_format(oc, i, oc->filename, 1);
2831 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2832 return AVERROR(EINVAL);
2836 /* init complex filtergraphs */
2837 for (i = 0; i < nb_filtergraphs; i++)
2838 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2841 /* for each output stream, we compute the right encoding parameters */
2842 for (i = 0; i < nb_output_streams; i++) {
2843 ost = output_streams[i];
2844 oc = output_files[ost->file_index]->ctx;
2845 ist = get_input_stream(ost);
2847 if (ost->attachment_filename)
2850 codec = ost->st->codec;
2853 icodec = ist->st->codec;
2855 ost->st->disposition = ist->st->disposition;
2856 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2857 codec->chroma_sample_location = icodec->chroma_sample_location;
2860 if (ost->stream_copy) {
2861 uint64_t extra_size;
2863 av_assert0(ist && !ost->filter);
2865 extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2867 if (extra_size > INT_MAX) {
2868 return AVERROR(EINVAL);
2871 /* if stream_copy is selected, no need to decode or encode */
2872 codec->codec_id = icodec->codec_id;
2873 codec->codec_type = icodec->codec_type;
2875 if (!codec->codec_tag) {
2876 if (!oc->oformat->codec_tag ||
2877 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2878 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2879 codec->codec_tag = icodec->codec_tag;
2882 codec->bit_rate = icodec->bit_rate;
2883 codec->rc_max_rate = icodec->rc_max_rate;
2884 codec->rc_buffer_size = icodec->rc_buffer_size;
2885 codec->field_order = icodec->field_order;
2886 codec->extradata = av_mallocz(extra_size);
2887 if (!codec->extradata) {
2888 return AVERROR(ENOMEM);
2890 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2891 codec->extradata_size= icodec->extradata_size;
2892 codec->bits_per_coded_sample = icodec->bits_per_coded_sample;
2894 codec->time_base = ist->st->time_base;
2896 * Avi is a special case here because it supports variable fps but
2897 * having the fps and timebase differe significantly adds quite some
2900 if(!strcmp(oc->oformat->name, "avi")) {
2901 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2902 && av_q2d(ist->st->time_base) < 1.0/500
2904 codec->time_base = icodec->time_base;
2905 codec->time_base.num *= icodec->ticks_per_frame;
2906 codec->time_base.den *= 2;
2907 codec->ticks_per_frame = 2;
2909 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2910 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2911 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2913 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2914 && av_q2d(ist->st->time_base) < 1.0/500
2916 codec->time_base = icodec->time_base;
2917 codec->time_base.num *= icodec->ticks_per_frame;
2921 if(ost->frame_rate.num)
2922 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2924 av_reduce(&codec->time_base.num, &codec->time_base.den,
2925 codec->time_base.num, codec->time_base.den, INT_MAX);
2927 switch (codec->codec_type) {
2928 case AVMEDIA_TYPE_AUDIO:
2929 if (audio_volume != 256) {
2930 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2933 codec->channel_layout = icodec->channel_layout;
2934 codec->sample_rate = icodec->sample_rate;
2935 codec->channels = icodec->channels;
2936 codec->frame_size = icodec->frame_size;
2937 codec->audio_service_type = icodec->audio_service_type;
2938 codec->block_align = icodec->block_align;
2939 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2940 codec->block_align= 0;
2941 if(codec->codec_id == CODEC_ID_AC3)
2942 codec->block_align= 0;
2944 case AVMEDIA_TYPE_VIDEO:
2945 codec->pix_fmt = icodec->pix_fmt;
2946 codec->width = icodec->width;
2947 codec->height = icodec->height;
2948 codec->has_b_frames = icodec->has_b_frames;
2949 if (!codec->sample_aspect_ratio.num) {
2950 codec->sample_aspect_ratio =
2951 ost->st->sample_aspect_ratio =
2952 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2953 ist->st->codec->sample_aspect_ratio.num ?
2954 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2956 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2958 case AVMEDIA_TYPE_SUBTITLE:
2959 codec->width = icodec->width;
2960 codec->height = icodec->height;
2962 case AVMEDIA_TYPE_DATA:
2963 case AVMEDIA_TYPE_ATTACHMENT:
2970 ost->enc = avcodec_find_encoder(codec->codec_id);
2972 /* should only happen when a default codec is not present. */
2973 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2974 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2975 ret = AVERROR(EINVAL);
2980 ist->decoding_needed = 1;
2981 ost->encoding_needed = 1;
2983 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2984 if (ost->filter && !ost->frame_rate.num)
2985 ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
2986 if (ist && !ost->frame_rate.num)
2987 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
2988 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2989 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2990 ost->frame_rate = ost->enc->supported_framerates[idx];
2995 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
2996 codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
2998 fg = init_simple_filtergraph(ist, ost);
2999 if (configure_filtergraph(fg)) {
3000 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3005 switch (codec->codec_type) {
3006 case AVMEDIA_TYPE_AUDIO:
3007 codec->sample_fmt = ost->filter->filter->inputs[0]->format;
3008 codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
3009 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3010 codec->channels = av_get_channel_layout_nb_channels(codec->channel_layout);
3011 codec->time_base = (AVRational){ 1, codec->sample_rate };
3013 case AVMEDIA_TYPE_VIDEO:
3014 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3015 if (ost->filter && !(codec->time_base.num && codec->time_base.den))
3016 codec->time_base = ost->filter->filter->inputs[0]->time_base;
3017 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3018 && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3019 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3020 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3022 for (j = 0; j < ost->forced_kf_count; j++)
3023 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3027 codec->width = ost->filter->filter->inputs[0]->w;
3028 codec->height = ost->filter->filter->inputs[0]->h;
3029 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3030 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3031 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3032 ost->filter->filter->inputs[0]->sample_aspect_ratio;
3033 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3036 codec->width != icodec->width ||
3037 codec->height != icodec->height ||
3038 codec->pix_fmt != icodec->pix_fmt) {
3039 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3042 if (ost->forced_keyframes)
3043 parse_forced_key_frames(ost->forced_keyframes, ost,
3046 case AVMEDIA_TYPE_SUBTITLE:
3047 codec->time_base = (AVRational){1, 1000};
3054 if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3055 char logfilename[1024];
3058 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3059 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3061 if (!strcmp(ost->enc->name, "libx264")) {
3062 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3064 if (codec->flags & CODEC_FLAG_PASS2) {
3066 size_t logbuffer_size;
3067 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3068 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3072 codec->stats_in = logbuffer;
3074 if (codec->flags & CODEC_FLAG_PASS1) {
3075 f = fopen(logfilename, "wb");
3077 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3078 logfilename, strerror(errno));
3088 /* open each encoder */
3089 for (i = 0; i < nb_output_streams; i++) {
3090 ost = output_streams[i];
3091 if (ost->encoding_needed) {
3092 AVCodec *codec = ost->enc;
3093 AVCodecContext *dec = NULL;
3095 if ((ist = get_input_stream(ost)))
3096 dec = ist->st->codec;
3097 if (dec && dec->subtitle_header) {
3098 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3099 if (!ost->st->codec->subtitle_header) {
3100 ret = AVERROR(ENOMEM);
3103 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3104 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3106 if (!av_dict_get(ost->opts, "threads", NULL, 0))
3107 av_dict_set(&ost->opts, "threads", "auto", 0);
3108 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3109 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3110 ost->file_index, ost->index);
3111 ret = AVERROR(EINVAL);
3114 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
3115 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
3116 av_buffersink_set_frame_size(ost->filter->filter,
3117 ost->st->codec->frame_size);
3118 assert_codec_experimental(ost->st->codec, 1);
3119 assert_avoptions(ost->opts);
3120 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3121 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3122 " It takes bits/s as argument, not kbits/s\n");
3123 extra_size += ost->st->codec->extradata_size;
3125 if (ost->st->codec->me_threshold)
3126 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3130 /* init input streams */
3131 for (i = 0; i < nb_input_streams; i++)
3132 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3135 /* discard unused programs */
3136 for (i = 0; i < nb_input_files; i++) {
3137 InputFile *ifile = input_files[i];
3138 for (j = 0; j < ifile->ctx->nb_programs; j++) {
3139 AVProgram *p = ifile->ctx->programs[j];
3140 int discard = AVDISCARD_ALL;
3142 for (k = 0; k < p->nb_stream_indexes; k++)
3143 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3144 discard = AVDISCARD_DEFAULT;
3147 p->discard = discard;
3151 /* open files and write file headers */
3152 for (i = 0; i < nb_output_files; i++) {
3153 oc = output_files[i]->ctx;
3154 oc->interrupt_callback = int_cb;
3155 if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
3157 const char *errbuf_ptr = errbuf;
3158 if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
3159 errbuf_ptr = strerror(AVUNERROR(ret));
3160 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
3161 ret = AVERROR(EINVAL);
3164 // assert_avoptions(output_files[i]->opts);
3165 if (strcmp(oc->oformat->name, "rtp")) {
3171 /* dump the file output parameters - cannot be done before in case
3173 for (i = 0; i < nb_output_files; i++) {
3174 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3177 /* dump the stream mapping */
3178 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3179 for (i = 0; i < nb_input_streams; i++) {
3180 ist = input_streams[i];
3182 for (j = 0; j < ist->nb_filters; j++) {
3183 if (ist->filters[j]->graph->graph_desc) {
3184 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
3185 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3186 ist->filters[j]->name);
3187 if (nb_filtergraphs > 1)
3188 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3189 av_log(NULL, AV_LOG_INFO, "\n");
3194 for (i = 0; i < nb_output_streams; i++) {
3195 ost = output_streams[i];
3197 if (ost->attachment_filename) {
3198 /* an attached file */
3199 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
3200 ost->attachment_filename, ost->file_index, ost->index);
3204 if (ost->filter && ost->filter->graph->graph_desc) {
3205 /* output from a complex graph */
3206 av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
3207 if (nb_filtergraphs > 1)
3208 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3210 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3211 ost->index, ost->enc ? ost->enc->name : "?");
3215 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
3216 input_streams[ost->source_index]->file_index,
3217 input_streams[ost->source_index]->st->index,
3220 if (ost->sync_ist != input_streams[ost->source_index])
3221 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3222 ost->sync_ist->file_index,
3223 ost->sync_ist->st->index);
3224 if (ost->stream_copy)
3225 av_log(NULL, AV_LOG_INFO, " (copy)");
3227 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3228 input_streams[ost->source_index]->dec->name : "?",
3229 ost->enc ? ost->enc->name : "?");
3230 av_log(NULL, AV_LOG_INFO, "\n");
3234 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3246 * @return 1 if there are still streams where more output is wanted,
3249 static int need_output(void)
3253 for (i = 0; i < nb_output_streams; i++) {
3254 OutputStream *ost = output_streams[i];
3255 OutputFile *of = output_files[ost->file_index];
3256 AVFormatContext *os = output_files[ost->file_index]->ctx;
3258 if (ost->is_past_recording_time ||
3259 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3261 if (ost->frame_number >= ost->max_frames) {
3263 for (j = 0; j < of->ctx->nb_streams; j++)
3264 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3274 static int select_input_file(uint8_t *no_packet)
3276 int64_t ipts_min = INT64_MAX;
3277 int i, file_index = -1;
3279 for (i = 0; i < nb_input_streams; i++) {
3280 InputStream *ist = input_streams[i];
3281 int64_t ipts = ist->pts;
3283 if (ist->discard || no_packet[ist->file_index])
3285 if (!input_files[ist->file_index]->eof_reached) {
3286 if (ipts < ipts_min) {
3288 file_index = ist->file_index;
3296 static int check_keyboard_interaction(int64_t cur_time)
3299 static int64_t last_time;
3300 if (received_nb_signals)
3301 return AVERROR_EXIT;
3302 /* read_key() returns 0 on EOF */
3303 if(cur_time - last_time >= 100000 && !run_as_daemon){
3305 last_time = cur_time;
3309 return AVERROR_EXIT;
3310 if (key == '+') av_log_set_level(av_log_get_level()+10);
3311 if (key == '-') av_log_set_level(av_log_get_level()-10);
3312 if (key == 's') qp_hist ^= 1;
3315 do_hex_dump = do_pkt_dump = 0;
3316 } else if(do_pkt_dump){
3320 av_log_set_level(AV_LOG_DEBUG);
3322 if (key == 'c' || key == 'C'){
3323 char buf[4096], target[64], command[256], arg[256] = {0};
3326 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3328 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3333 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3334 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3335 target, time, command, arg);
3336 for (i = 0; i < nb_filtergraphs; i++) {
3337 FilterGraph *fg = filtergraphs[i];
3340 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3341 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3342 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3344 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3349 av_log(NULL, AV_LOG_ERROR,
3350 "Parse error, at least 3 arguments were expected, "
3351 "only %d given in string '%s'\n", n, buf);
3354 if (key == 'd' || key == 'D'){
3357 debug = input_streams[0]->st->codec->debug<<1;
3358 if(!debug) debug = 1;
3359 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3362 if(scanf("%d", &debug)!=1)
3363 fprintf(stderr,"error parsing debug value\n");
3364 for(i=0;i<nb_input_streams;i++) {
3365 input_streams[i]->st->codec->debug = debug;
3367 for(i=0;i<nb_output_streams;i++) {
3368 OutputStream *ost = output_streams[i];
3369 ost->st->codec->debug = debug;
3371 if(debug) av_log_set_level(AV_LOG_DEBUG);
3372 fprintf(stderr,"debug=%d\n", debug);
3375 fprintf(stderr, "key function\n"
3376 "? show this help\n"
3377 "+ increase verbosity\n"
3378 "- decrease verbosity\n"
3379 "c Send command to filtergraph\n"
3380 "D cycle through available debug modes\n"
3381 "h dump packets/hex press to cycle through the 3 states\n"
3383 "s Show QP histogram\n"
3390 static void *input_thread(void *arg)
3395 while (!transcoding_finished && ret >= 0) {
3397 ret = av_read_frame(f->ctx, &pkt);
3399 if (ret == AVERROR(EAGAIN)) {
3406 pthread_mutex_lock(&f->fifo_lock);
3407 while (!av_fifo_space(f->fifo))
3408 pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
3410 av_dup_packet(&pkt);
3411 av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
3413 pthread_mutex_unlock(&f->fifo_lock);
3420 static void free_input_threads(void)
3424 if (nb_input_files == 1)
3427 transcoding_finished = 1;
3429 for (i = 0; i < nb_input_files; i++) {
3430 InputFile *f = input_files[i];
3433 if (!f->fifo || f->joined)
3436 pthread_mutex_lock(&f->fifo_lock);
3437 while (av_fifo_size(f->fifo)) {
3438 av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
3439 av_free_packet(&pkt);
3441 pthread_cond_signal(&f->fifo_cond);
3442 pthread_mutex_unlock(&f->fifo_lock);
3444 pthread_join(f->thread, NULL);
3447 while (av_fifo_size(f->fifo)) {
3448 av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
3449 av_free_packet(&pkt);
3451 av_fifo_free(f->fifo);
3455 static int init_input_threads(void)
3459 if (nb_input_files == 1)
3462 for (i = 0; i < nb_input_files; i++) {
3463 InputFile *f = input_files[i];
3465 if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
3466 return AVERROR(ENOMEM);
3468 pthread_mutex_init(&f->fifo_lock, NULL);
3469 pthread_cond_init (&f->fifo_cond, NULL);
3471 if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
3472 return AVERROR(ret);
3477 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
3481 pthread_mutex_lock(&f->fifo_lock);
3483 if (av_fifo_size(f->fifo)) {
3484 av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
3485 pthread_cond_signal(&f->fifo_cond);
3490 ret = AVERROR(EAGAIN);
3493 pthread_mutex_unlock(&f->fifo_lock);
3499 static int get_input_packet(InputFile *f, AVPacket *pkt)
3502 if (nb_input_files > 1)
3503 return get_input_packet_mt(f, pkt);
3505 return av_read_frame(f->ctx, pkt);
3509 * The following code is the main loop of the file converter
3511 static int transcode(void)
3514 AVFormatContext *is, *os;
3518 int no_packet_count = 0;
3519 int64_t timer_start;
3521 if (!(no_packet = av_mallocz(nb_input_files)))
3524 ret = transcode_init();
3529 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3532 timer_start = av_gettime();
3535 if ((ret = init_input_threads()) < 0)
3539 for (; received_sigterm == 0;) {
3540 int file_index, ist_index;
3542 int64_t cur_time= av_gettime();
3544 /* if 'q' pressed, exits */
3546 if (check_keyboard_interaction(cur_time) < 0)
3549 /* check if there's any stream where output is still needed */
3550 if (!need_output()) {
3551 av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
3555 /* select the stream that we must read now */
3556 file_index = select_input_file(no_packet);
3557 /* if none, if is finished */
3558 if (file_index < 0) {
3559 if (no_packet_count) {
3560 no_packet_count = 0;
3561 memset(no_packet, 0, nb_input_files);
3565 av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
3569 is = input_files[file_index]->ctx;
3570 ret = get_input_packet(input_files[file_index], &pkt);
3572 if (ret == AVERROR(EAGAIN)) {
3573 no_packet[file_index] = 1;
3578 input_files[file_index]->eof_reached = 1;
3580 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3581 ist = input_streams[input_files[file_index]->ist_index + i];
3582 if (ist->decoding_needed)
3583 output_packet(ist, NULL);
3592 no_packet_count = 0;
3593 memset(no_packet, 0, nb_input_files);
3596 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3597 is->streams[pkt.stream_index]);
3599 /* the following test is needed in case new streams appear
3600 dynamically in stream : we ignore them */
3601 if (pkt.stream_index >= input_files[file_index]->nb_streams)
3602 goto discard_packet;
3603 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3604 ist = input_streams[ist_index];
3606 goto discard_packet;
3608 if (pkt.dts != AV_NOPTS_VALUE)
3609 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3610 if (pkt.pts != AV_NOPTS_VALUE)
3611 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3613 if (pkt.pts != AV_NOPTS_VALUE)
3614 pkt.pts *= ist->ts_scale;
3615 if (pkt.dts != AV_NOPTS_VALUE)
3616 pkt.dts *= ist->ts_scale;
3619 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3620 "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",
3621 ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3622 av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &ist->st->time_base),
3623 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3624 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3625 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3626 input_files[ist->file_index]->ts_offset);
3629 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3630 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3631 int64_t delta = pkt_dts - ist->next_dts;
3632 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3633 if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3634 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3635 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3636 pkt_dts+1<ist->pts){
3637 input_files[ist->file_index]->ts_offset -= delta;
3638 av_log(NULL, AV_LOG_DEBUG,
3639 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3640 delta, input_files[ist->file_index]->ts_offset);
3641 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3642 if (pkt.pts != AV_NOPTS_VALUE)
3643 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3646 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3647 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3648 pkt_dts+1<ist->pts){
3649 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3650 pkt.dts = AV_NOPTS_VALUE;
3652 if (pkt.pts != AV_NOPTS_VALUE){
3653 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3654 delta = pkt_pts - ist->next_dts;
3655 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3656 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3657 pkt_pts+1<ist->pts) {
3658 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3659 pkt.pts = AV_NOPTS_VALUE;
3665 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3666 if ((ret = output_packet(ist, &pkt)) < 0 ||
3667 ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3669 av_strerror(ret, buf, sizeof(buf));
3670 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
3671 ist->file_index, ist->st->index, buf);
3674 av_free_packet(&pkt);
3679 av_free_packet(&pkt);
3681 /* dump report by using the output first video and audio streams */
3682 print_report(0, timer_start, cur_time);
3685 free_input_threads();
3688 /* at the end of stream, we must flush the decoder buffers */
3689 for (i = 0; i < nb_input_streams; i++) {
3690 ist = input_streams[i];
3691 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3692 output_packet(ist, NULL);
3700 /* write the trailer if needed and close file */
3701 for (i = 0; i < nb_output_files; i++) {
3702 os = output_files[i]->ctx;
3703 av_write_trailer(os);
3706 /* dump report by using the first video and audio streams */
3707 print_report(1, timer_start, av_gettime());
3709 /* close each encoder */
3710 for (i = 0; i < nb_output_streams; i++) {
3711 ost = output_streams[i];
3712 if (ost->encoding_needed) {
3713 av_freep(&ost->st->codec->stats_in);
3714 avcodec_close(ost->st->codec);
3718 /* close each decoder */
3719 for (i = 0; i < nb_input_streams; i++) {
3720 ist = input_streams[i];
3721 if (ist->decoding_needed) {
3722 avcodec_close(ist->st->codec);
3730 av_freep(&no_packet);
3732 free_input_threads();
3735 if (output_streams) {
3736 for (i = 0; i < nb_output_streams; i++) {
3737 ost = output_streams[i];
3739 if (ost->stream_copy)
3740 av_freep(&ost->st->codec->extradata);
3742 fclose(ost->logfile);
3743 ost->logfile = NULL;
3745 av_freep(&ost->st->codec->subtitle_header);
3746 av_free(ost->forced_kf_pts);
3747 av_dict_free(&ost->opts);
3754 static int opt_frame_crop(const char *opt, const char *arg)
3756 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3757 return AVERROR(EINVAL);
3760 static int opt_pad(const char *opt, const char *arg)
3762 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3766 static int opt_video_channel(const char *opt, const char *arg)
3768 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3769 return opt_default("channel", arg);
3772 static int opt_video_standard(const char *opt, const char *arg)
3774 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3775 return opt_default("standard", arg);
3778 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3780 audio_codec_name = arg;
3781 return parse_option(o, "codec:a", arg, options);
3784 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3786 video_codec_name = arg;
3787 return parse_option(o, "codec:v", arg, options);
3790 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3792 subtitle_codec_name = arg;
3793 return parse_option(o, "codec:s", arg, options);
3796 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3798 return parse_option(o, "codec:d", arg, options);
3801 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3803 StreamMap *m = NULL;
3804 int i, negative = 0, file_idx;
3805 int sync_file_idx = -1, sync_stream_idx = 0;
3813 map = av_strdup(arg);
3815 /* parse sync stream first, just pick first matching stream */
3816 if (sync = strchr(map, ',')) {
3818 sync_file_idx = strtol(sync + 1, &sync, 0);
3819 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3820 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3825 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3826 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3827 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3828 sync_stream_idx = i;
3831 if (i == input_files[sync_file_idx]->nb_streams) {
3832 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3833 "match any streams.\n", arg);
3839 if (map[0] == '[') {
3840 /* this mapping refers to lavfi output */
3841 const char *c = map + 1;
3842 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3843 &o->nb_stream_maps, o->nb_stream_maps + 1);
3844 m = &o->stream_maps[o->nb_stream_maps - 1];
3845 m->linklabel = av_get_token(&c, "]");
3846 if (!m->linklabel) {
3847 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3851 file_idx = strtol(map, &p, 0);
3852 if (file_idx >= nb_input_files || file_idx < 0) {
3853 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3857 /* disable some already defined maps */
3858 for (i = 0; i < o->nb_stream_maps; i++) {
3859 m = &o->stream_maps[i];
3860 if (file_idx == m->file_index &&
3861 check_stream_specifier(input_files[m->file_index]->ctx,
3862 input_files[m->file_index]->ctx->streams[m->stream_index],
3863 *p == ':' ? p + 1 : p) > 0)
3867 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3868 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3869 *p == ':' ? p + 1 : p) <= 0)
3871 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3872 &o->nb_stream_maps, o->nb_stream_maps + 1);
3873 m = &o->stream_maps[o->nb_stream_maps - 1];
3875 m->file_index = file_idx;
3876 m->stream_index = i;
3878 if (sync_file_idx >= 0) {
3879 m->sync_file_index = sync_file_idx;
3880 m->sync_stream_index = sync_stream_idx;
3882 m->sync_file_index = file_idx;
3883 m->sync_stream_index = i;
3889 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3897 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3899 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3900 &o->nb_attachments, o->nb_attachments + 1);
3901 o->attachments[o->nb_attachments - 1] = arg;
3905 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3911 o->audio_channel_maps =
3912 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3913 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3914 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3916 /* muted channel syntax */
3917 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3918 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3919 m->file_idx = m->stream_idx = -1;
3921 m->ofile_idx = m->ostream_idx = -1;
3926 n = sscanf(arg, "%d.%d.%d:%d.%d",
3927 &m->file_idx, &m->stream_idx, &m->channel_idx,
3928 &m->ofile_idx, &m->ostream_idx);
3930 if (n != 3 && n != 5) {
3931 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3932 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3936 if (n != 5) // only file.stream.channel specified
3937 m->ofile_idx = m->ostream_idx = -1;
3940 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3941 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3945 if (m->stream_idx < 0 ||
3946 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
3947 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3948 m->file_idx, m->stream_idx);
3951 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
3952 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3953 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3954 m->file_idx, m->stream_idx);
3957 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3958 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3959 m->file_idx, m->stream_idx, m->channel_idx);
3966 * Parse a metadata specifier in arg.
3967 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3968 * @param index for type c/p, chapter/program index is written here
3969 * @param stream_spec for type s, the stream specifier is written here
3971 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3979 if (*(++arg) && *arg != ':') {
3980 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3983 *stream_spec = *arg == ':' ? arg + 1 : "";
3987 if (*(++arg) == ':')
3988 *index = strtol(++arg, NULL, 0);
3991 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3998 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
4000 AVDictionary **meta_in = NULL;
4001 AVDictionary **meta_out = NULL;
4003 char type_in, type_out;
4004 const char *istream_spec = NULL, *ostream_spec = NULL;
4005 int idx_in = 0, idx_out = 0;
4007 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
4008 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
4011 if (type_out == 'g' || !*outspec)
4012 o->metadata_global_manual = 1;
4013 if (type_out == 's' || !*outspec)
4014 o->metadata_streams_manual = 1;
4015 if (type_out == 'c' || !*outspec)
4016 o->metadata_chapters_manual = 1;
4020 if (type_in == 'g' || type_out == 'g')
4021 o->metadata_global_manual = 1;
4022 if (type_in == 's' || type_out == 's')
4023 o->metadata_streams_manual = 1;
4024 if (type_in == 'c' || type_out == 'c')
4025 o->metadata_chapters_manual = 1;
4027 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4028 if ((index) < 0 || (index) >= (nb_elems)) {\
4029 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
4034 #define SET_DICT(type, meta, context, index)\
4037 meta = &context->metadata;\
4040 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
4041 meta = &context->chapters[index]->metadata;\
4044 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
4045 meta = &context->programs[index]->metadata;\
4047 default: av_assert0(0);\
4050 SET_DICT(type_in, meta_in, ic, idx_in);
4051 SET_DICT(type_out, meta_out, oc, idx_out);
4053 /* for input streams choose first matching stream */
4054 if (type_in == 's') {
4055 for (i = 0; i < ic->nb_streams; i++) {
4056 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
4057 meta_in = &ic->streams[i]->metadata;
4063 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
4068 if (type_out == 's') {
4069 for (i = 0; i < oc->nb_streams; i++) {
4070 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
4071 meta_out = &oc->streams[i]->metadata;
4072 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4077 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4082 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
4085 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
4086 struct tm time = *gmtime((time_t*)&recording_timestamp);
4087 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
4088 parse_option(o, "metadata", buf, options);
4090 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
4091 "tag instead.\n", opt);
4095 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
4097 const char *codec_string = encoder ? "encoder" : "decoder";
4101 avcodec_find_encoder_by_name(name) :
4102 avcodec_find_decoder_by_name(name);
4104 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4107 if (codec->type != type) {
4108 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4114 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4116 char *codec_name = NULL;
4118 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4120 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4121 st->codec->codec_id = codec->id;
4124 return avcodec_find_decoder(st->codec->codec_id);
4128 * Add all the streams from the given input file to the global
4129 * list of input streams.
4131 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4134 char *next, *codec_tag = NULL;
4136 for (i = 0; i < ic->nb_streams; i++) {
4137 AVStream *st = ic->streams[i];
4138 AVCodecContext *dec = st->codec;
4139 InputStream *ist = av_mallocz(sizeof(*ist));
4140 char *framerate = NULL;
4145 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4146 input_streams[nb_input_streams - 1] = ist;
4149 ist->file_index = nb_input_files;
4151 st->discard = AVDISCARD_ALL;
4152 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
4154 ist->ts_scale = 1.0;
4155 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4157 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4159 uint32_t tag = strtol(codec_tag, &next, 0);
4161 tag = AV_RL32(codec_tag);
4162 st->codec->codec_tag = tag;
4165 ist->dec = choose_decoder(o, ic, st);
4167 switch (dec->codec_type) {
4168 case AVMEDIA_TYPE_VIDEO:
4170 ist->dec = avcodec_find_decoder(dec->codec_id);
4172 dec->flags |= CODEC_FLAG_EMU_EDGE;
4175 ist->resample_height = dec->height;
4176 ist->resample_width = dec->width;
4177 ist->resample_pix_fmt = dec->pix_fmt;
4179 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
4180 if (framerate && av_parse_video_rate(&ist->framerate,
4182 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
4187 ist->top_field_first = -1;
4188 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
4191 case AVMEDIA_TYPE_AUDIO:
4192 guess_input_channel_layout(ist);
4194 ist->resample_sample_fmt = dec->sample_fmt;
4195 ist->resample_sample_rate = dec->sample_rate;
4196 ist->resample_channels = dec->channels;
4197 ist->resample_channel_layout = dec->channel_layout;
4200 case AVMEDIA_TYPE_DATA:
4201 case AVMEDIA_TYPE_SUBTITLE:
4203 ist->dec = avcodec_find_decoder(dec->codec_id);
4205 case AVMEDIA_TYPE_ATTACHMENT:
4206 case AVMEDIA_TYPE_UNKNOWN:
4214 static void assert_file_overwrite(const char *filename)
4216 if ((!file_overwrite || no_file_overwrite) &&
4217 (strchr(filename, ':') == NULL || filename[1] == ':' ||
4218 av_strstart(filename, "file:", NULL))) {
4219 if (avio_check(filename, 0) == 0) {
4220 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
4221 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4224 signal(SIGINT, SIG_DFL);
4225 if (!read_yesno()) {
4226 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4232 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4239 static void dump_attachment(AVStream *st, const char *filename)
4242 AVIOContext *out = NULL;
4243 AVDictionaryEntry *e;
4245 if (!st->codec->extradata_size) {
4246 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4247 nb_input_files - 1, st->index);
4250 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4251 filename = e->value;
4253 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4254 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4258 assert_file_overwrite(filename);
4260 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4261 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4266 avio_write(out, st->codec->extradata, st->codec->extradata_size);
4271 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4273 AVFormatContext *ic;
4274 AVInputFormat *file_iformat = NULL;
4278 AVDictionary **opts;
4279 int orig_nb_streams; // number of streams before avformat_find_stream_info
4282 if (!(file_iformat = av_find_input_format(o->format))) {
4283 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4288 if (!strcmp(filename, "-"))
4291 using_stdin |= !strncmp(filename, "pipe:", 5) ||
4292 !strcmp(filename, "/dev/stdin");
4294 /* get default parameters from command line */
4295 ic = avformat_alloc_context();
4297 print_error(filename, AVERROR(ENOMEM));
4300 if (o->nb_audio_sample_rate) {
4301 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4302 av_dict_set(&format_opts, "sample_rate", buf, 0);
4304 if (o->nb_audio_channels) {
4305 /* because we set audio_channels based on both the "ac" and
4306 * "channel_layout" options, we need to check that the specified
4307 * demuxer actually has the "channels" option before setting it */
4308 if (file_iformat && file_iformat->priv_class &&
4309 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4310 AV_OPT_SEARCH_FAKE_OBJ)) {
4311 snprintf(buf, sizeof(buf), "%d",
4312 o->audio_channels[o->nb_audio_channels - 1].u.i);
4313 av_dict_set(&format_opts, "channels", buf, 0);
4316 if (o->nb_frame_rates) {
4317 /* set the format-level framerate option;
4318 * this is important for video grabbers, e.g. x11 */
4319 if (file_iformat && file_iformat->priv_class &&
4320 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
4321 AV_OPT_SEARCH_FAKE_OBJ)) {
4322 av_dict_set(&format_opts, "framerate",
4323 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4326 if (o->nb_frame_sizes) {
4327 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4329 if (o->nb_frame_pix_fmts)
4330 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4332 ic->video_codec_id = video_codec_name ?
4333 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
4334 ic->audio_codec_id = audio_codec_name ?
4335 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
4336 ic->subtitle_codec_id= subtitle_codec_name ?
4337 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4338 ic->flags |= AVFMT_FLAG_NONBLOCK;
4339 ic->interrupt_callback = int_cb;
4341 /* open the input file with generic avformat function */
4342 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4344 print_error(filename, err);
4347 assert_avoptions(format_opts);
4349 /* apply forced codec ids */
4350 for (i = 0; i < ic->nb_streams; i++)
4351 choose_decoder(o, ic, ic->streams[i]);
4353 /* Set AVCodecContext options for avformat_find_stream_info */
4354 opts = setup_find_stream_info_opts(ic, codec_opts);
4355 orig_nb_streams = ic->nb_streams;
4357 /* If not enough info to get the stream parameters, we decode the
4358 first frames to get it. (used in mpeg case for example) */
4359 ret = avformat_find_stream_info(ic, opts);
4361 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4362 avformat_close_input(&ic);
4366 timestamp = o->start_time;
4367 /* add the stream start time */
4368 if (ic->start_time != AV_NOPTS_VALUE)
4369 timestamp += ic->start_time;
4371 /* if seeking requested, we execute it */
4372 if (o->start_time != 0) {
4373 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4375 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4376 filename, (double)timestamp / AV_TIME_BASE);
4380 /* update the current parameters so that they match the one of the input stream */
4381 add_input_streams(o, ic);
4383 /* dump the file content */
4384 av_dump_format(ic, nb_input_files, filename, 0);
4386 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4387 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4390 input_files[nb_input_files - 1]->ctx = ic;
4391 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
4392 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4393 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4394 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
4396 for (i = 0; i < o->nb_dump_attachment; i++) {
4399 for (j = 0; j < ic->nb_streams; j++) {
4400 AVStream *st = ic->streams[j];
4402 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4403 dump_attachment(st, o->dump_attachment[i].u.str);
4407 for (i = 0; i < orig_nb_streams; i++)
4408 av_dict_free(&opts[i]);
4411 reset_options(o, 1);
4415 static uint8_t *get_line(AVIOContext *s)
4421 if (avio_open_dyn_buf(&line) < 0) {
4422 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4426 while ((c = avio_r8(s)) && c != '\n')
4429 avio_close_dyn_buf(line, &buf);
4434 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4437 char filename[1000];
4438 const char *base[3] = { getenv("AVCONV_DATADIR"),
4443 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4447 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4448 i != 1 ? "" : "/.avconv", codec_name, preset_name);
4449 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4452 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4453 i != 1 ? "" : "/.avconv", preset_name);
4454 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4460 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4462 char *codec_name = NULL;
4464 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4466 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4467 NULL, ost->st->codec->codec_type);
4468 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4469 } else if (!strcmp(codec_name, "copy"))
4470 ost->stream_copy = 1;
4472 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4473 ost->st->codec->codec_id = ost->enc->id;
4477 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4480 AVStream *st = avformat_new_stream(oc, NULL);
4481 int idx = oc->nb_streams - 1, ret = 0;
4482 char *bsf = NULL, *next, *codec_tag = NULL;
4483 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4485 char *buf = NULL, *arg = NULL, *preset = NULL;
4486 AVIOContext *s = NULL;
4489 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4493 if (oc->nb_streams - 1 < o->nb_streamid_map)
4494 st->id = o->streamid_map[oc->nb_streams - 1];
4496 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4497 nb_output_streams + 1);
4498 if (!(ost = av_mallocz(sizeof(*ost))))
4500 output_streams[nb_output_streams - 1] = ost;
4502 ost->file_index = nb_output_files;
4505 st->codec->codec_type = type;
4506 choose_encoder(o, oc, ost);
4508 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
4511 avcodec_get_context_defaults3(st->codec, ost->enc);
4512 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4514 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4515 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4518 if (!buf[0] || buf[0] == '#') {
4522 if (!(arg = strchr(buf, '='))) {
4523 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4527 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4529 } while (!s->eof_reached);
4533 av_log(NULL, AV_LOG_FATAL,
4534 "Preset %s specified for stream %d:%d, but could not be opened.\n",
4535 preset, ost->file_index, ost->index);
4539 ost->max_frames = INT64_MAX;
4540 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4542 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4544 if (next = strchr(bsf, ','))
4546 if (!(bsfc = av_bitstream_filter_init(bsf))) {
4547 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4551 bsfc_prev->next = bsfc;
4553 ost->bitstream_filters = bsfc;
4559 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4561 uint32_t tag = strtol(codec_tag, &next, 0);
4563 tag = AV_RL32(codec_tag);
4564 st->codec->codec_tag = tag;
4567 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4568 if (qscale >= 0 || same_quant) {
4569 st->codec->flags |= CODEC_FLAG_QSCALE;
4570 st->codec->global_quality = FF_QP2LAMBDA * qscale;
4573 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4574 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4576 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4577 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4578 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4580 ost->source_index = source_index;
4581 if (source_index >= 0) {
4582 ost->sync_ist = input_streams[source_index];
4583 input_streams[source_index]->discard = 0;
4584 input_streams[source_index]->st->discard = AVDISCARD_NONE;
4590 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4593 const char *p = str;
4600 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4607 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4611 AVCodecContext *video_enc;
4612 char *frame_rate = NULL;
4614 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4616 video_enc = st->codec;
4618 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4619 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4620 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4624 if (!ost->stream_copy) {
4625 const char *p = NULL;
4626 char *frame_size = NULL;
4627 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4628 char *intra_matrix = NULL, *inter_matrix = NULL;
4629 const char *filters = "null";
4632 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4633 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4634 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4638 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4639 if (frame_aspect_ratio) {
4641 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4642 q.num <= 0 || q.den <= 0) {
4643 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4646 ost->frame_aspect_ratio = av_q2d(q);
4649 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4650 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4651 if (frame_pix_fmt && *frame_pix_fmt == '+') {
4652 ost->keep_pix_fmt = 1;
4653 if (!*++frame_pix_fmt)
4654 frame_pix_fmt = NULL;
4656 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4657 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4660 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4663 video_enc->gop_size = 0;
4664 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4666 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4667 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4670 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4672 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4674 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4675 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4678 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4681 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4682 for (i = 0; p; i++) {
4684 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4686 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4689 /* FIXME realloc failure */
4690 video_enc->rc_override =
4691 av_realloc(video_enc->rc_override,
4692 sizeof(RcOverride) * (i + 1));
4693 video_enc->rc_override[i].start_frame = start;
4694 video_enc->rc_override[i].end_frame = end;
4696 video_enc->rc_override[i].qscale = q;
4697 video_enc->rc_override[i].quality_factor = 1.0;
4700 video_enc->rc_override[i].qscale = 0;
4701 video_enc->rc_override[i].quality_factor = -q/100.0;
4706 video_enc->rc_override_count = i;
4707 if (!video_enc->rc_initial_buffer_occupancy)
4708 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4709 video_enc->intra_dc_precision = intra_dc_precision - 8;
4712 video_enc->flags|= CODEC_FLAG_PSNR;
4717 video_enc->flags |= CODEC_FLAG_PASS1;
4720 video_enc->flags |= CODEC_FLAG_PASS2;
4724 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
4725 if (ost->forced_keyframes)
4726 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
4728 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4730 ost->top_field_first = -1;
4731 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4733 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4734 ost->avfilter = av_strdup(filters);
4736 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4742 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4747 AVCodecContext *audio_enc;
4749 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4752 audio_enc = st->codec;
4753 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4755 if (!ost->stream_copy) {
4756 char *sample_fmt = NULL;
4757 const char *filters = "anull";
4759 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4761 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4763 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4764 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4768 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4770 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4772 av_assert1(filters);
4773 ost->avfilter = av_strdup(filters);
4775 /* check for channel mapping for this audio stream */
4776 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4777 AudioChannelMap *map = &o->audio_channel_maps[n];
4778 InputStream *ist = input_streams[ost->source_index];
4779 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4780 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4781 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4782 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4783 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4785 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4786 ost->file_index, ost->st->index);
4794 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4798 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4799 if (!ost->stream_copy) {
4800 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4807 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4809 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4810 ost->stream_copy = 1;
4814 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4818 AVCodecContext *subtitle_enc;
4820 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4822 subtitle_enc = st->codec;
4824 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4826 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4831 /* arg format is "output-stream-index:streamid-value". */
4832 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4838 av_strlcpy(idx_str, arg, sizeof(idx_str));
4839 p = strchr(idx_str, ':');
4841 av_log(NULL, AV_LOG_FATAL,
4842 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4847 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4848 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4849 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4853 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4855 AVFormatContext *is = ifile->ctx;
4856 AVFormatContext *os = ofile->ctx;
4859 for (i = 0; i < is->nb_chapters; i++) {
4860 AVChapter *in_ch = is->chapters[i], *out_ch;
4861 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4862 AV_TIME_BASE_Q, in_ch->time_base);
4863 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4864 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4867 if (in_ch->end < ts_off)
4869 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4872 out_ch = av_mallocz(sizeof(AVChapter));
4874 return AVERROR(ENOMEM);
4876 out_ch->id = in_ch->id;
4877 out_ch->time_base = in_ch->time_base;
4878 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4879 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4882 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4885 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4887 return AVERROR(ENOMEM);
4888 os->chapters[os->nb_chapters - 1] = out_ch;
4893 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4896 AVFormatContext *ic = avformat_alloc_context();
4898 ic->interrupt_callback = int_cb;
4899 err = avformat_open_input(&ic, filename, NULL, NULL);
4902 /* copy stream format */
4903 for(i=0;i<ic->nb_streams;i++) {
4907 AVCodecContext *avctx;
4909 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4910 ost = new_output_stream(o, s, codec->type, -1);
4915 // FIXME: a more elegant solution is needed
4916 memcpy(st, ic->streams[i], sizeof(AVStream));
4918 st->info = av_malloc(sizeof(*st->info));
4919 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4921 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4923 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4924 choose_sample_fmt(st, codec);
4925 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4926 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4929 avformat_close_input(&ic);
4933 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4934 AVFormatContext *oc)
4938 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
4939 ofilter->out_tmp->pad_idx)) {
4940 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
4941 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
4943 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
4948 ost->source_index = -1;
4949 ost->filter = ofilter;
4953 if (ost->stream_copy) {
4954 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4955 "which is fed from a complex filtergraph. Filtering and streamcopy "
4956 "cannot be used together.\n", ost->file_index, ost->index);
4959 if (o->recording_time != INT64_MAX)
4960 av_log(NULL, AV_LOG_WARNING,
4961 "-t does not work with -filter_complex (yet).\n");
4963 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4964 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4967 avfilter_inout_free(&ofilter->out_tmp);
4970 static void opt_output_file(void *optctx, const char *filename)
4972 OptionsContext *o = optctx;
4973 AVFormatContext *oc;
4975 AVOutputFormat *file_oformat;
4979 if (configure_complex_filters() < 0) {
4980 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4984 if (!strcmp(filename, "-"))
4987 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4989 print_error(filename, err);
4992 file_oformat= oc->oformat;
4993 oc->interrupt_callback = int_cb;
4995 /* create streams for all unlabeled output pads */
4996 for (i = 0; i < nb_filtergraphs; i++) {
4997 FilterGraph *fg = filtergraphs[i];
4998 for (j = 0; j < fg->nb_outputs; j++) {
4999 OutputFilter *ofilter = fg->outputs[j];
5001 if (!ofilter->out_tmp || ofilter->out_tmp->name)
5004 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
5005 ofilter->out_tmp->pad_idx)) {
5006 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
5007 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
5008 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
5010 init_output_filter(ofilter, o, oc);
5014 if (!strcmp(file_oformat->name, "ffm") &&
5015 av_strstart(filename, "http:", NULL)) {
5017 /* special case for files sent to ffserver: we get the stream
5018 parameters from ffserver */
5019 int err = read_ffserver_streams(o, oc, filename);
5021 print_error(filename, err);
5024 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
5025 ost = output_streams[j];
5026 for (i = 0; i < nb_input_streams; i++) {
5027 ist = input_streams[i];
5028 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
5030 ost->source_index= i;
5031 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
5032 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
5034 ist->st->discard = AVDISCARD_NONE;
5039 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));
5043 } else if (!o->nb_stream_maps) {
5044 /* pick the "best" stream of each type */
5046 /* video: highest resolution */
5047 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
5048 int area = 0, idx = -1;
5049 for (i = 0; i < nb_input_streams; i++) {
5050 ist = input_streams[i];
5051 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
5052 ist->st->codec->width * ist->st->codec->height > area) {
5053 area = ist->st->codec->width * ist->st->codec->height;
5058 new_video_stream(o, oc, idx);
5061 /* audio: most channels */
5062 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
5063 int channels = 0, idx = -1;
5064 for (i = 0; i < nb_input_streams; i++) {
5065 ist = input_streams[i];
5066 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
5067 ist->st->codec->channels > channels) {
5068 channels = ist->st->codec->channels;
5073 new_audio_stream(o, oc, idx);
5076 /* subtitles: pick first */
5077 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
5078 for (i = 0; i < nb_input_streams; i++)
5079 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
5080 new_subtitle_stream(o, oc, i);
5084 /* do something with data? */
5086 for (i = 0; i < o->nb_stream_maps; i++) {
5087 StreamMap *map = &o->stream_maps[i];
5088 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5093 if (map->linklabel) {
5095 OutputFilter *ofilter = NULL;
5098 for (j = 0; j < nb_filtergraphs; j++) {
5099 fg = filtergraphs[j];
5100 for (k = 0; k < fg->nb_outputs; k++) {
5101 AVFilterInOut *out = fg->outputs[k]->out_tmp;
5102 if (out && !strcmp(out->name, map->linklabel)) {
5103 ofilter = fg->outputs[k];
5110 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5111 "in any defined filter graph.\n", map->linklabel);
5114 init_output_filter(ofilter, o, oc);
5116 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5117 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5119 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5121 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5123 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5126 switch (ist->st->codec->codec_type) {
5127 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
5128 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
5129 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
5130 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
5131 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5133 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5134 map->file_index, map->stream_index);
5142 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5143 AVDictionaryEntry *e;
5144 ost = output_streams[i];
5146 if ( ost->stream_copy
5147 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5148 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5149 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5153 /* handle attached files */
5154 for (i = 0; i < o->nb_attachments; i++) {
5156 uint8_t *attachment;
5160 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5161 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5165 if ((len = avio_size(pb)) <= 0) {
5166 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5170 if (!(attachment = av_malloc(len))) {
5171 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5175 avio_read(pb, attachment, len);
5177 ost = new_attachment_stream(o, oc, -1);
5178 ost->stream_copy = 0;
5179 ost->attachment_filename = o->attachments[i];
5180 ost->st->codec->extradata = attachment;
5181 ost->st->codec->extradata_size = len;
5183 p = strrchr(o->attachments[i], '/');
5184 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5188 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5189 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5192 output_files[nb_output_files - 1]->ctx = oc;
5193 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
5194 output_files[nb_output_files - 1]->recording_time = o->recording_time;
5195 if (o->recording_time != INT64_MAX)
5196 oc->duration = o->recording_time;
5197 output_files[nb_output_files - 1]->start_time = o->start_time;
5198 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5199 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5201 /* check filename in case of an image number is expected */
5202 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5203 if (!av_filename_number_test(oc->filename)) {
5204 print_error(oc->filename, AVERROR(EINVAL));
5209 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5210 /* test if it already exists to avoid losing precious files */
5211 assert_file_overwrite(filename);
5214 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5215 &oc->interrupt_callback,
5216 &output_files[nb_output_files - 1]->opts)) < 0) {
5217 print_error(filename, err);
5222 if (o->mux_preload) {
5224 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5225 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5227 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5230 for (i = 0; i < o->nb_metadata_map; i++) {
5232 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5234 if (in_file_index >= nb_input_files) {
5235 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5238 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5242 if (o->chapters_input_file >= nb_input_files) {
5243 if (o->chapters_input_file == INT_MAX) {
5244 /* copy chapters from the first input file that has them*/
5245 o->chapters_input_file = -1;
5246 for (i = 0; i < nb_input_files; i++)
5247 if (input_files[i]->ctx->nb_chapters) {
5248 o->chapters_input_file = i;
5252 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5253 o->chapters_input_file);
5257 if (o->chapters_input_file >= 0)
5258 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5259 !o->metadata_chapters_manual);
5261 /* copy global metadata by default */
5262 if (!o->metadata_global_manual && nb_input_files){
5263 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5264 AV_DICT_DONT_OVERWRITE);
5265 if(o->recording_time != INT64_MAX)
5266 av_dict_set(&oc->metadata, "duration", NULL, 0);
5267 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
5269 if (!o->metadata_streams_manual)
5270 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5272 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
5274 ist = input_streams[output_streams[i]->source_index];
5275 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5278 /* process manually set metadata */
5279 for (i = 0; i < o->nb_metadata; i++) {
5282 const char *stream_spec;
5283 int index = 0, j, ret = 0;
5285 val = strchr(o->metadata[i].u.str, '=');
5287 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5288 o->metadata[i].u.str);
5293 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5295 for (j = 0; j < oc->nb_streams; j++) {
5296 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5297 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5308 if (index < 0 || index >= oc->nb_chapters) {
5309 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5312 m = &oc->chapters[index]->metadata;
5315 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5318 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5322 reset_options(o, 0);
5325 /* same option as mencoder */
5326 static int opt_pass(const char *opt, const char *arg)
5328 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5332 static int64_t getmaxrss(void)
5334 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5335 struct rusage rusage;
5336 getrusage(RUSAGE_SELF, &rusage);
5337 return (int64_t)rusage.ru_maxrss * 1024;
5338 #elif HAVE_GETPROCESSMEMORYINFO
5340 PROCESS_MEMORY_COUNTERS memcounters;
5341 proc = GetCurrentProcess();
5342 memcounters.cb = sizeof(memcounters);
5343 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5344 return memcounters.PeakPagefileUsage;
5350 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5352 return parse_option(o, "q:a", arg, options);
5355 static void show_usage(void)
5357 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5358 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5359 av_log(NULL, AV_LOG_INFO, "\n");
5362 static int opt_help(const char *opt, const char *arg)
5364 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5365 av_log_set_callback(log_callback_help);
5367 show_help_options(options, "Main options:\n",
5368 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5369 show_help_options(options, "\nAdvanced options:\n",
5370 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5372 show_help_options(options, "\nVideo options:\n",
5373 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5375 show_help_options(options, "\nAdvanced Video options:\n",
5376 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5377 OPT_VIDEO | OPT_EXPERT);
5378 show_help_options(options, "\nAudio options:\n",
5379 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5381 show_help_options(options, "\nAdvanced Audio options:\n",
5382 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5383 OPT_AUDIO | OPT_EXPERT);
5384 show_help_options(options, "\nSubtitle options:\n",
5385 OPT_SUBTITLE | OPT_GRAB,
5387 show_help_options(options, "\nAudio/Video grab options:\n",
5391 show_help_children(avcodec_get_class(), flags);
5392 show_help_children(avformat_get_class(), flags);
5393 show_help_children(sws_get_class(), flags);
5394 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
5399 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5401 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5402 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5404 if (!strncmp(arg, "pal-", 4)) {
5407 } else if (!strncmp(arg, "ntsc-", 5)) {
5410 } else if (!strncmp(arg, "film-", 5)) {
5414 /* Try to determine PAL/NTSC by peeking in the input files */
5415 if (nb_input_files) {
5417 for (j = 0; j < nb_input_files; j++) {
5418 for (i = 0; i < input_files[j]->nb_streams; i++) {
5419 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5420 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5422 fr = c->time_base.den * 1000 / c->time_base.num;
5426 } else if ((fr == 29970) || (fr == 23976)) {
5431 if (norm != UNKNOWN)
5435 if (norm != UNKNOWN)
5436 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5439 if (norm == UNKNOWN) {
5440 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5441 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5442 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5446 if (!strcmp(arg, "vcd")) {
5447 opt_video_codec(o, "c:v", "mpeg1video");
5448 opt_audio_codec(o, "c:a", "mp2");
5449 parse_option(o, "f", "vcd", options);
5451 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5452 parse_option(o, "r", frame_rates[norm], options);
5453 opt_default("g", norm == PAL ? "15" : "18");
5455 opt_default("b:v", "1150000");
5456 opt_default("maxrate", "1150000");
5457 opt_default("minrate", "1150000");
5458 opt_default("bufsize", "327680"); // 40*1024*8;
5460 opt_default("b:a", "224000");
5461 parse_option(o, "ar", "44100", options);
5462 parse_option(o, "ac", "2", options);
5464 opt_default("packetsize", "2324");
5465 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5467 /* We have to offset the PTS, so that it is consistent with the SCR.
5468 SCR starts at 36000, but the first two packs contain only padding
5469 and the first pack from the other stream, respectively, may also have
5470 been written before.
5471 So the real data starts at SCR 36000+3*1200. */
5472 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5473 } else if (!strcmp(arg, "svcd")) {
5475 opt_video_codec(o, "c:v", "mpeg2video");
5476 opt_audio_codec(o, "c:a", "mp2");
5477 parse_option(o, "f", "svcd", options);
5479 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5480 parse_option(o, "r", frame_rates[norm], options);
5481 parse_option(o, "pix_fmt", "yuv420p", options);
5482 opt_default("g", norm == PAL ? "15" : "18");
5484 opt_default("b:v", "2040000");
5485 opt_default("maxrate", "2516000");
5486 opt_default("minrate", "0"); // 1145000;
5487 opt_default("bufsize", "1835008"); // 224*1024*8;
5488 opt_default("scan_offset", "1");
5491 opt_default("b:a", "224000");
5492 parse_option(o, "ar", "44100", options);
5494 opt_default("packetsize", "2324");
5496 } else if (!strcmp(arg, "dvd")) {
5498 opt_video_codec(o, "c:v", "mpeg2video");
5499 opt_audio_codec(o, "c:a", "ac3");
5500 parse_option(o, "f", "dvd", options);
5502 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5503 parse_option(o, "r", frame_rates[norm], options);
5504 parse_option(o, "pix_fmt", "yuv420p", options);
5505 opt_default("g", norm == PAL ? "15" : "18");
5507 opt_default("b:v", "6000000");
5508 opt_default("maxrate", "9000000");
5509 opt_default("minrate", "0"); // 1500000;
5510 opt_default("bufsize", "1835008"); // 224*1024*8;
5512 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5513 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5515 opt_default("b:a", "448000");
5516 parse_option(o, "ar", "48000", options);
5518 } else if (!strncmp(arg, "dv", 2)) {
5520 parse_option(o, "f", "dv", options);
5522 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5523 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5524 norm == PAL ? "yuv420p" : "yuv411p", options);
5525 parse_option(o, "r", frame_rates[norm], options);
5527 parse_option(o, "ar", "48000", options);
5528 parse_option(o, "ac", "2", options);
5531 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5532 return AVERROR(EINVAL);
5537 static int opt_vstats_file(const char *opt, const char *arg)
5539 av_free (vstats_filename);
5540 vstats_filename = av_strdup (arg);
5544 static int opt_vstats(const char *opt, const char *arg)
5547 time_t today2 = time(NULL);
5548 struct tm *today = localtime(&today2);
5550 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5552 return opt_vstats_file(opt, filename);
5555 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5557 return parse_option(o, "frames:v", arg, options);
5560 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5562 return parse_option(o, "frames:a", arg, options);
5565 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5567 return parse_option(o, "frames:d", arg, options);
5570 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5573 char filename[1000], line[1000], tmp_line[1000];
5574 const char *codec_name = *opt == 'v' ? video_codec_name :
5575 *opt == 'a' ? audio_codec_name :
5576 subtitle_codec_name;
5578 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5579 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5580 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5582 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5586 while (fgets(line, sizeof(line), f)) {
5587 char *key = tmp_line, *value, *endptr;
5589 if (strcspn(line, "#\n\r") == 0)
5591 strcpy(tmp_line, line);
5592 if (!av_strtok(key, "=", &value) ||
5593 !av_strtok(value, "\r\n", &endptr)) {
5594 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5597 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
5599 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
5600 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
5601 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
5602 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
5603 else if (opt_default(key, value) < 0) {
5604 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
5605 filename, line, key, value);
5615 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5619 static int opt_passlogfile(const char *opt, const char *arg)
5621 pass_logfilename_prefix = arg;
5622 #if CONFIG_LIBX264_ENCODER
5623 return opt_default(opt, arg);
5629 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5631 char *s = av_asprintf("%s:%c", opt + 1, *opt);
5632 int ret = parse_option(o, s, arg, options);
5637 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5639 if(!strcmp(opt, "b")){
5640 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5641 return parse_option(o, "b:v", arg, options);
5643 return opt_default(opt, arg);
5646 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5650 if(!strcmp(opt, "qscale")){
5651 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5652 return parse_option(o, "q:v", arg, options);
5654 s = av_asprintf("q%s", opt + 6);
5655 ret = parse_option(o, s, arg, options);
5660 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5662 if(!strcmp(opt, "profile")){
5663 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5664 return parse_option(o, "profile:v", arg, options);
5666 return opt_default(opt, arg);
5669 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5671 return parse_option(o, "filter:v", arg, options);
5674 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
5676 return parse_option(o, "filter:a", arg, options);
5679 static int opt_vsync(const char *opt, const char *arg)
5681 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
5682 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
5683 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5684 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
5686 if (video_sync_method == VSYNC_AUTO)
5687 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5691 static int opt_deinterlace(const char *opt, const char *arg)
5693 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5698 static int opt_timecode(OptionsContext *o, const char *opt, const char *arg)
5700 char *tcr = av_asprintf("timecode=%s", arg);
5701 int ret = parse_option(o, "metadata:g", tcr, options);
5703 ret = opt_default("gop_timecode", arg);
5708 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5710 int idx = locate_option(argc, argv, options, "cpuflags");
5711 if (idx && argv[idx + 1])
5712 opt_cpuflags("cpuflags", argv[idx + 1]);
5715 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5717 char layout_str[32];
5720 int ret, channels, ac_str_size;
5723 layout = av_get_channel_layout(arg);
5725 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5726 return AVERROR(EINVAL);
5728 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5729 ret = opt_default(opt, layout_str);
5733 /* set 'ac' option based on channel layout */
5734 channels = av_get_channel_layout_nb_channels(layout);
5735 snprintf(layout_str, sizeof(layout_str), "%d", channels);
5736 stream_str = strchr(opt, ':');
5737 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5738 ac_str = av_mallocz(ac_str_size);
5740 return AVERROR(ENOMEM);
5741 av_strlcpy(ac_str, "ac", 3);
5743 av_strlcat(ac_str, stream_str, ac_str_size);
5744 ret = parse_option(o, ac_str, layout_str, options);
5750 static int opt_filter_complex(const char *opt, const char *arg)
5752 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5753 &nb_filtergraphs, nb_filtergraphs + 1);
5754 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5755 return AVERROR(ENOMEM);
5756 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
5757 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5761 #define OFFSET(x) offsetof(OptionsContext, x)
5762 static const OptionDef options[] = {
5764 #include "cmdutils_common_opts.h"
5765 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5766 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5767 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5768 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5769 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5770 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5771 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5772 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5773 { "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]" },
5774 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5775 "outfile[,metadata]:infile[,metadata]" },
5776 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
5777 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5778 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5779 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5780 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5781 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5782 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5783 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5784 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5785 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5786 "add timings for benchmarking" },
5787 { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5788 "add timings for each task" },
5789 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5790 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5791 "dump each input packet" },
5792 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5793 "when dumping packets, also dump the payload" },
5794 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5795 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5796 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5797 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5798 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5799 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
5800 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
5801 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5802 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5803 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5804 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5805 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5806 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5807 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5808 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5809 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5810 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5811 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5812 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5813 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5814 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5815 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5816 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5819 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5820 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5821 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5822 { "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" },
5823 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5824 { "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" },
5825 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5826 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5827 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5828 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5829 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5830 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5831 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5832 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5833 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5834 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5835 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5836 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5837 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5838 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5839 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5840 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5841 "use same quantizer as source (implies VBR)" },
5842 { "timecode", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_timecode}, "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
5843 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5844 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5845 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5846 "this option is deprecated, use the yadif filter instead" },
5847 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5848 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5849 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5850 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5851 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5852 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5853 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5854 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5855 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5856 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5857 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5858 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5859 { "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" },
5860 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5863 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5864 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5865 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5866 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5867 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5868 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5869 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5870 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5871 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5872 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5873 { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
5875 /* subtitle options */
5876 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5877 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5878 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5881 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5882 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5883 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5886 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5887 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5889 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5890 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5891 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5893 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5894 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5895 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5896 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5897 /* data codec support */
5898 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5899 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5901 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5905 int main(int argc, char **argv)
5907 OptionsContext o = { 0 };
5910 reset_options(&o, 0);
5912 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5913 parse_loglevel(argc, argv, options);
5915 if(argc>1 && !strcmp(argv[1], "-d")){
5917 av_log_set_callback(log_callback_null);
5922 avcodec_register_all();
5924 avdevice_register_all();
5926 avfilter_register_all();
5928 avformat_network_init();
5930 show_banner(argc, argv, options);
5934 parse_cpuflags(argc, argv, options);
5937 parse_options(&o, argc, argv, options, opt_output_file);
5939 if (nb_output_files <= 0 && nb_input_files == 0) {
5941 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5945 /* file converter / grab */
5946 if (nb_output_files <= 0) {
5947 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5951 if (nb_input_files == 0) {
5952 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5956 current_time = ti = getutime();
5957 if (transcode() < 0)
5959 ti = getutime() - ti;
5961 int maxrss = getmaxrss() / 1024;
5962 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);