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 1, ist->st->codec->sample_rate,
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);
1684 if (!check_recording_time(ost))
1687 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1688 // start_display_time is required to be 0
1689 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1690 sub->end_display_time -= sub->start_display_time;
1691 sub->start_display_time = 0;
1692 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1693 subtitle_out_max_size, sub);
1694 if (subtitle_out_size < 0) {
1695 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1699 av_init_packet(&pkt);
1700 pkt.data = subtitle_out;
1701 pkt.size = subtitle_out_size;
1702 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1703 pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->st->time_base);
1704 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1705 /* XXX: the pts correction is handled here. Maybe handling
1706 it in the codec would be better */
1708 pkt.pts += 90 * sub->start_display_time;
1710 pkt.pts += 90 * sub->end_display_time;
1712 write_frame(s, &pkt, ost);
1713 subtitle_size += pkt.size;
1717 static void do_video_out(AVFormatContext *s,
1719 AVFrame *in_picture,
1722 int ret, format_video_sync;
1724 AVCodecContext *enc = ost->st->codec;
1726 double sync_ipts, delta;
1727 double duration = 0;
1729 InputStream *ist = NULL;
1731 if (ost->source_index >= 0)
1732 ist = input_streams[ost->source_index];
1734 if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1735 duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));
1737 sync_ipts = in_picture->pts;
1738 delta = sync_ipts - ost->sync_opts + duration;
1740 /* by default, we output a single frame */
1743 format_video_sync = video_sync_method;
1744 if (format_video_sync == VSYNC_AUTO)
1745 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1747 switch (format_video_sync) {
1749 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1752 else if (delta > 1.1)
1753 nb_frames = lrintf(delta);
1758 else if (delta > 0.6)
1759 ost->sync_opts = lrint(sync_ipts);
1762 case VSYNC_PASSTHROUGH:
1763 ost->sync_opts = lrint(sync_ipts);
1769 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1770 if (nb_frames == 0) {
1772 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1774 } else if (nb_frames > 1) {
1775 if (nb_frames > dts_error_threshold * 30) {
1776 av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skiping\n", nb_frames - 1);
1780 nb_frames_dup += nb_frames - 1;
1781 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1786 av_init_packet(&pkt);
1790 in_picture->pts = ost->sync_opts;
1792 if (!check_recording_time(ost))
1795 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1796 enc->codec->id == CODEC_ID_RAWVIDEO) {
1797 /* raw pictures are written as AVPicture structure to
1798 avoid any copies. We support temporarily the older
1800 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1801 enc->coded_frame->top_field_first = in_picture->top_field_first;
1802 pkt.data = (uint8_t *)in_picture;
1803 pkt.size = sizeof(AVPicture);
1804 pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
1805 pkt.flags |= AV_PKT_FLAG_KEY;
1807 write_frame(s, &pkt, ost);
1808 video_size += pkt.size;
1811 AVFrame big_picture;
1813 big_picture = *in_picture;
1814 /* better than nothing: use input picture interlaced
1816 big_picture.interlaced_frame = in_picture->interlaced_frame;
1817 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1818 if (ost->top_field_first == -1)
1819 big_picture.top_field_first = in_picture->top_field_first;
1821 big_picture.top_field_first = !!ost->top_field_first;
1824 /* handles same_quant here. This is not correct because it may
1825 not be a global option */
1826 big_picture.quality = quality;
1827 if (!enc->me_threshold)
1828 big_picture.pict_type = 0;
1829 if (ost->forced_kf_index < ost->forced_kf_count &&
1830 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1831 big_picture.pict_type = AV_PICTURE_TYPE_I;
1832 ost->forced_kf_index++;
1834 update_benchmark(NULL);
1835 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
1836 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1838 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1843 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
1844 pkt.pts = ost->sync_opts;
1846 if (pkt.pts != AV_NOPTS_VALUE)
1847 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1848 if (pkt.dts != AV_NOPTS_VALUE)
1849 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1852 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1853 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1854 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1855 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1858 write_frame(s, &pkt, ost);
1859 frame_size = pkt.size;
1860 video_size += pkt.size;
1861 av_free_packet(&pkt);
1863 /* if two pass, output log */
1864 if (ost->logfile && enc->stats_out) {
1865 fprintf(ost->logfile, "%s", enc->stats_out);
1871 * For video, number of frames in == number of packets out.
1872 * But there may be reordering, so we can't throw away frames on encoder
1873 * flush, we need to limit them here, before they go into encoder.
1875 ost->frame_number++;
1878 goto duplicate_frame;
1880 if (vstats_filename && frame_size)
1881 do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
1884 static double psnr(double d)
1886 return -10.0 * log(d) / log(10.0);
1889 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1892 AVCodecContext *enc;
1894 double ti1, bitrate, avg_bitrate;
1896 /* this is executed just the first time do_video_stats is called */
1898 vstats_file = fopen(vstats_filename, "w");
1905 enc = ost->st->codec;
1906 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1907 frame_number = ost->frame_number;
1908 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1909 if (enc->flags&CODEC_FLAG_PSNR)
1910 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1912 fprintf(vstats_file,"f_size= %6d ", frame_size);
1913 /* compute pts value */
1914 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1918 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1919 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1920 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1921 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1922 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1926 /* check for new output on any of the filtergraphs */
1927 static int poll_filters(void)
1929 AVFilterBufferRef *picref;
1930 AVFrame *filtered_frame = NULL;
1931 int i, ret, ret_all;
1932 unsigned nb_success, nb_eof;
1936 /* Reap all buffers present in the buffer sinks */
1937 for (i = 0; i < nb_output_streams; i++) {
1938 OutputStream *ost = output_streams[i];
1939 OutputFile *of = output_files[ost->file_index];
1945 if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
1946 return AVERROR(ENOMEM);
1948 avcodec_get_frame_defaults(ost->filtered_frame);
1949 filtered_frame = ost->filtered_frame;
1952 ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
1953 AV_BUFFERSINK_FLAG_NO_REQUEST);
1955 if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1957 av_strerror(ret, buf, sizeof(buf));
1958 av_log(NULL, AV_LOG_WARNING,
1959 "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
1963 frame_pts = AV_NOPTS_VALUE;
1964 if (picref->pts != AV_NOPTS_VALUE) {
1965 filtered_frame->pts = frame_pts = av_rescale_q(picref->pts,
1966 ost->filter->filter->inputs[0]->time_base,
1967 ost->st->codec->time_base) -
1968 av_rescale_q(of->start_time,
1970 ost->st->codec->time_base);
1972 if (of->start_time && filtered_frame->pts < 0) {
1973 avfilter_unref_buffer(picref);
1977 //if (ost->source_index >= 0)
1978 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1981 switch (ost->filter->filter->inputs[0]->type) {
1982 case AVMEDIA_TYPE_VIDEO:
1983 avfilter_copy_buf_props(filtered_frame, picref);
1984 filtered_frame->pts = frame_pts;
1985 if (!ost->frame_aspect_ratio)
1986 ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
1988 do_video_out(of->ctx, ost, filtered_frame,
1989 same_quant ? ost->last_quality :
1990 ost->st->codec->global_quality);
1992 case AVMEDIA_TYPE_AUDIO:
1993 avfilter_copy_buf_props(filtered_frame, picref);
1994 filtered_frame->pts = frame_pts;
1995 do_audio_out(of->ctx, ost, filtered_frame);
1998 // TODO support subtitle filters
2002 avfilter_unref_buffer(picref);
2005 /* Request frames through all the graphs */
2006 ret_all = nb_success = nb_eof = 0;
2007 for (i = 0; i < nb_filtergraphs; i++) {
2008 ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
2011 } else if (ret == AVERROR_EOF) {
2013 } else if (ret != AVERROR(EAGAIN)) {
2015 av_strerror(ret, buf, sizeof(buf));
2016 av_log(NULL, AV_LOG_WARNING,
2017 "Error in request_frame(): %s\n", buf);
2023 /* Try again if anything succeeded */
2025 return nb_eof == nb_filtergraphs ? AVERROR_EOF : ret_all;
2028 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
2032 AVFormatContext *oc;
2034 AVCodecContext *enc;
2035 int frame_number, vid, i;
2037 int64_t pts = INT64_MAX;
2038 static int64_t last_time = -1;
2039 static int qp_histogram[52];
2040 int hours, mins, secs, us;
2042 if (!print_stats && !is_last_report)
2045 if (!is_last_report) {
2046 if (last_time == -1) {
2047 last_time = cur_time;
2050 if ((cur_time - last_time) < 500000)
2052 last_time = cur_time;
2056 oc = output_files[0]->ctx;
2058 total_size = avio_size(oc->pb);
2059 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
2060 total_size = avio_tell(oc->pb);
2067 for (i = 0; i < nb_output_streams; i++) {
2069 ost = output_streams[i];
2070 enc = ost->st->codec;
2071 if (!ost->stream_copy && enc->coded_frame)
2072 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
2073 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2074 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
2076 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2077 float fps, t = (cur_time-timer_start) / 1000000.0;
2079 frame_number = ost->frame_number;
2080 fps = t > 1 ? frame_number / t : 0;
2081 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
2082 frame_number, fps < 9.95, fps, q);
2084 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
2088 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
2090 for (j = 0; j < 32; j++)
2091 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
2093 if (enc->flags&CODEC_FLAG_PSNR) {
2095 double error, error_sum = 0;
2096 double scale, scale_sum = 0;
2097 char type[3] = { 'Y','U','V' };
2098 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
2099 for (j = 0; j < 3; j++) {
2100 if (is_last_report) {
2101 error = enc->error[j];
2102 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
2104 error = enc->coded_frame->error[j];
2105 scale = enc->width * enc->height * 255.0 * 255.0;
2111 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
2113 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
2117 /* compute min output value */
2118 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
2119 ost->st->time_base, AV_TIME_BASE_Q));
2122 secs = pts / AV_TIME_BASE;
2123 us = pts % AV_TIME_BASE;
2129 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
2131 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2132 "size=%8.0fkB time=", total_size / 1024.0);
2133 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2134 "%02d:%02d:%02d.%02d ", hours, mins, secs,
2135 (100 * us) / AV_TIME_BASE);
2136 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2137 "bitrate=%6.1fkbits/s", bitrate);
2139 if (nb_frames_dup || nb_frames_drop)
2140 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
2141 nb_frames_dup, nb_frames_drop);
2143 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
2147 if (is_last_report) {
2148 int64_t raw= audio_size + video_size + subtitle_size + extra_size;
2149 av_log(NULL, AV_LOG_INFO, "\n");
2150 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0f global headers:%1.0fkB muxing overhead %f%%\n",
2151 video_size / 1024.0,
2152 audio_size / 1024.0,
2153 subtitle_size / 1024.0,
2154 extra_size / 1024.0,
2155 100.0 * (total_size - raw) / raw
2157 if(video_size + audio_size + subtitle_size + extra_size == 0){
2158 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
2163 static void flush_encoders(void)
2167 for (i = 0; i < nb_output_streams; i++) {
2168 OutputStream *ost = output_streams[i];
2169 AVCodecContext *enc = ost->st->codec;
2170 AVFormatContext *os = output_files[ost->file_index]->ctx;
2171 int stop_encoding = 0;
2173 if (!ost->encoding_needed)
2176 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
2178 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
2182 int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
2186 switch (ost->st->codec->codec_type) {
2187 case AVMEDIA_TYPE_AUDIO:
2188 encode = avcodec_encode_audio2;
2192 case AVMEDIA_TYPE_VIDEO:
2193 encode = avcodec_encode_video2;
2204 av_init_packet(&pkt);
2208 update_benchmark(NULL);
2209 ret = encode(enc, &pkt, NULL, &got_packet);
2210 update_benchmark("flush %s %d.%d", desc, ost->file_index, ost->index);
2212 av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
2216 if (ost->logfile && enc->stats_out) {
2217 fprintf(ost->logfile, "%s", enc->stats_out);
2223 if (pkt.pts != AV_NOPTS_VALUE)
2224 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2225 if (pkt.dts != AV_NOPTS_VALUE)
2226 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2227 write_frame(os, &pkt, ost);
2237 * Check whether a packet from ist should be written into ost at this time
2239 static int check_output_constraints(InputStream *ist, OutputStream *ost)
2241 OutputFile *of = output_files[ost->file_index];
2242 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
2244 if (ost->source_index != ist_index)
2247 if (of->start_time && ist->pts < of->start_time)
2253 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2255 OutputFile *of = output_files[ost->file_index];
2256 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
2260 av_init_packet(&opkt);
2262 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2263 !ost->copy_initial_nonkeyframes)
2266 if (of->recording_time != INT64_MAX &&
2267 ist->pts >= of->recording_time + of->start_time) {
2268 ost->is_past_recording_time = 1;
2272 /* force the input stream PTS */
2273 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2274 audio_size += pkt->size;
2275 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2276 video_size += pkt->size;
2278 } else if (ost->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
2279 subtitle_size += pkt->size;
2282 if (pkt->pts != AV_NOPTS_VALUE)
2283 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
2285 opkt.pts = AV_NOPTS_VALUE;
2287 if (pkt->dts == AV_NOPTS_VALUE)
2288 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
2290 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
2291 opkt.dts -= ost_tb_start_time;
2293 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
2294 opkt.flags = pkt->flags;
2296 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2297 if ( ost->st->codec->codec_id != CODEC_ID_H264
2298 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
2299 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
2300 && ost->st->codec->codec_id != CODEC_ID_VC1
2302 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
2303 opkt.destruct = av_destruct_packet;
2305 opkt.data = pkt->data;
2306 opkt.size = pkt->size;
2308 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2309 /* store AVPicture in AVPacket, as expected by the output format */
2310 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2311 opkt.data = (uint8_t *)&pict;
2312 opkt.size = sizeof(AVPicture);
2313 opkt.flags |= AV_PKT_FLAG_KEY;
2316 write_frame(of->ctx, &opkt, ost);
2317 ost->st->codec->frame_number++;
2318 av_free_packet(&opkt);
2321 static void rate_emu_sleep(InputStream *ist)
2323 if (input_files[ist->file_index]->rate_emu) {
2324 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2325 int64_t now = av_gettime() - ist->start;
2327 av_usleep(pts - now);
2331 static int guess_input_channel_layout(InputStream *ist)
2333 AVCodecContext *dec = ist->st->codec;
2335 if (!dec->channel_layout) {
2336 char layout_name[256];
2338 dec->channel_layout = av_get_default_channel_layout(dec->channels);
2339 if (!dec->channel_layout)
2341 av_get_channel_layout_string(layout_name, sizeof(layout_name),
2342 dec->channels, dec->channel_layout);
2343 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2344 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2349 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2351 AVFrame *decoded_frame;
2352 AVCodecContext *avctx = ist->st->codec;
2353 int i, ret, resample_changed;
2355 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2356 return AVERROR(ENOMEM);
2358 avcodec_get_frame_defaults(ist->decoded_frame);
2359 decoded_frame = ist->decoded_frame;
2361 update_benchmark(NULL);
2362 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2363 update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2367 if (avctx->sample_rate <= 0) {
2368 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2369 return AVERROR_INVALIDDATA;
2373 /* no audio frame */
2375 for (i = 0; i < ist->nb_filters; i++)
2376 av_buffersrc_add_ref(ist->filters[i]->filter, NULL,
2377 AV_BUFFERSRC_FLAG_NO_COPY);
2381 /* if the decoder provides a pts, use it instead of the last packet pts.
2382 the decoder could be delaying output by a packet or more. */
2383 if (decoded_frame->pts != AV_NOPTS_VALUE)
2384 ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2385 else if (pkt->pts != AV_NOPTS_VALUE) {
2386 decoded_frame->pts = pkt->pts;
2387 pkt->pts = AV_NOPTS_VALUE;
2389 decoded_frame->pts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2393 /* increment next_dts to use for the case where the input stream does not
2394 have timestamps or there are multiple frames in the packet */
2395 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2397 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2401 rate_emu_sleep(ist);
2403 resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
2404 ist->resample_channels != avctx->channels ||
2405 ist->resample_channel_layout != decoded_frame->channel_layout ||
2406 ist->resample_sample_rate != decoded_frame->sample_rate;
2407 if (resample_changed) {
2408 char layout1[64], layout2[64];
2410 if (!guess_input_channel_layout(ist)) {
2411 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
2412 "layout for Input Stream #%d.%d\n", ist->file_index,
2416 decoded_frame->channel_layout = avctx->channel_layout;
2418 av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
2419 ist->resample_channel_layout);
2420 av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
2421 decoded_frame->channel_layout);
2423 av_log(NULL, AV_LOG_INFO,
2424 "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",
2425 ist->file_index, ist->st->index,
2426 ist->resample_sample_rate, av_get_sample_fmt_name(ist->resample_sample_fmt),
2427 ist->resample_channels, layout1,
2428 decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
2429 avctx->channels, layout2);
2431 ist->resample_sample_fmt = decoded_frame->format;
2432 ist->resample_sample_rate = decoded_frame->sample_rate;
2433 ist->resample_channel_layout = decoded_frame->channel_layout;
2434 ist->resample_channels = avctx->channels;
2436 for (i = 0; i < nb_filtergraphs; i++)
2437 if (ist_in_filtergraph(filtergraphs[i], ist)) {
2438 FilterGraph *fg = filtergraphs[i];
2440 if (configure_filtergraph(fg) < 0) {
2441 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2444 for (j = 0; j < fg->nb_outputs; j++) {
2445 OutputStream *ost = fg->outputs[j]->ost;
2446 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
2447 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
2448 av_buffersink_set_frame_size(ost->filter->filter,
2449 ost->st->codec->frame_size);
2454 if (decoded_frame->pts != AV_NOPTS_VALUE)
2455 decoded_frame->pts = av_rescale_q(decoded_frame->pts,
2457 (AVRational){1, ist->st->codec->sample_rate});
2458 for (i = 0; i < ist->nb_filters; i++)
2459 av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0);
2464 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
2466 AVFrame *decoded_frame;
2467 void *buffer_to_free = NULL;
2468 int i, ret = 0, resample_changed;
2469 int64_t best_effort_timestamp;
2470 AVRational *frame_sample_aspect;
2473 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2474 return AVERROR(ENOMEM);
2476 avcodec_get_frame_defaults(ist->decoded_frame);
2477 decoded_frame = ist->decoded_frame;
2478 pkt->dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2480 update_benchmark(NULL);
2481 ret = avcodec_decode_video2(ist->st->codec,
2482 decoded_frame, got_output, pkt);
2483 update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2487 quality = same_quant ? decoded_frame->quality : 0;
2489 /* no picture yet */
2491 for (i = 0; i < ist->nb_filters; i++)
2492 av_buffersrc_add_ref(ist->filters[i]->filter, NULL, AV_BUFFERSRC_FLAG_NO_COPY);
2496 if(ist->top_field_first>=0)
2497 decoded_frame->top_field_first = ist->top_field_first;
2499 best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2500 if(best_effort_timestamp != AV_NOPTS_VALUE)
2501 ist->next_pts = ist->pts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2504 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2506 rate_emu_sleep(ist);
2508 if (ist->st->sample_aspect_ratio.num)
2509 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2511 resample_changed = ist->resample_width != decoded_frame->width ||
2512 ist->resample_height != decoded_frame->height ||
2513 ist->resample_pix_fmt != decoded_frame->format;
2514 if (resample_changed) {
2515 av_log(NULL, AV_LOG_INFO,
2516 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2517 ist->file_index, ist->st->index,
2518 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2519 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2521 ist->resample_width = decoded_frame->width;
2522 ist->resample_height = decoded_frame->height;
2523 ist->resample_pix_fmt = decoded_frame->format;
2525 for (i = 0; i < nb_filtergraphs; i++)
2526 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2527 configure_filtergraph(filtergraphs[i]) < 0) {
2528 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2533 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2534 for (i = 0; i < ist->nb_filters; i++) {
2535 int changed = ist->st->codec->width != ist->filters[i]->filter->outputs[0]->w
2536 || ist->st->codec->height != ist->filters[i]->filter->outputs[0]->h
2537 || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2538 // XXX what an ugly hack
2539 if (ist->filters[i]->graph->nb_outputs == 1)
2540 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2542 if (!frame_sample_aspect->num)
2543 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2544 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2545 FrameBuffer *buf = decoded_frame->opaque;
2546 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2547 decoded_frame->data, decoded_frame->linesize,
2548 AV_PERM_READ | AV_PERM_PRESERVE,
2549 ist->st->codec->width, ist->st->codec->height,
2550 ist->st->codec->pix_fmt);
2552 avfilter_copy_frame_props(fb, decoded_frame);
2553 fb->buf->priv = buf;
2554 fb->buf->free = filter_release_buffer;
2556 av_assert0(buf->refcount>0);
2558 av_buffersrc_add_ref(ist->filters[i]->filter, fb,
2559 AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
2560 AV_BUFFERSRC_FLAG_NO_COPY);
2562 if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0)<0) {
2563 av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2569 av_free(buffer_to_free);
2573 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2575 AVSubtitle subtitle;
2576 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2577 &subtitle, got_output, pkt);
2583 rate_emu_sleep(ist);
2585 for (i = 0; i < nb_output_streams; i++) {
2586 OutputStream *ost = output_streams[i];
2588 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2591 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2594 avsubtitle_free(&subtitle);
2598 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2599 static int output_packet(InputStream *ist, const AVPacket *pkt)
2605 if (!ist->saw_first_ts) {
2606 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;
2608 if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2609 ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2610 ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2612 ist->saw_first_ts = 1;
2615 if (ist->next_dts == AV_NOPTS_VALUE)
2616 ist->next_dts = ist->dts;
2617 if (ist->next_pts == AV_NOPTS_VALUE)
2618 ist->next_pts = ist->pts;
2622 av_init_packet(&avpkt);
2630 if (pkt->dts != AV_NOPTS_VALUE) {
2631 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2632 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2633 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2636 // while we have more to decode or while the decoder did output something on EOF
2637 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2641 ist->pts = ist->next_pts;
2642 ist->dts = ist->next_dts;
2644 if (avpkt.size && avpkt.size != pkt->size) {
2645 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2646 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2647 ist->showed_multi_packet_warning = 1;
2650 switch (ist->st->codec->codec_type) {
2651 case AVMEDIA_TYPE_AUDIO:
2652 ret = decode_audio (ist, &avpkt, &got_output);
2654 case AVMEDIA_TYPE_VIDEO:
2655 ret = decode_video (ist, &avpkt, &got_output);
2656 if (avpkt.duration) {
2657 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2658 } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2659 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2660 duration = ((int64_t)AV_TIME_BASE *
2661 ist->st->codec->time_base.num * ticks) /
2662 ist->st->codec->time_base.den;
2666 if(ist->dts != AV_NOPTS_VALUE && duration) {
2667 ist->next_dts += duration;
2669 ist->next_dts = AV_NOPTS_VALUE;
2672 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2674 case AVMEDIA_TYPE_SUBTITLE:
2675 ret = transcode_subtitles(ist, &avpkt, &got_output);
2685 avpkt.pts= AV_NOPTS_VALUE;
2687 // touch data and size only if not EOF
2689 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2699 /* handle stream copy */
2700 if (!ist->decoding_needed) {
2701 rate_emu_sleep(ist);
2702 ist->dts = ist->next_dts;
2703 switch (ist->st->codec->codec_type) {
2704 case AVMEDIA_TYPE_AUDIO:
2705 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2706 ist->st->codec->sample_rate;
2708 case AVMEDIA_TYPE_VIDEO:
2709 if (pkt->duration) {
2710 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2711 } else if(ist->st->codec->time_base.num != 0) {
2712 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2713 ist->next_dts += ((int64_t)AV_TIME_BASE *
2714 ist->st->codec->time_base.num * ticks) /
2715 ist->st->codec->time_base.den;
2719 ist->pts = ist->dts;
2720 ist->next_pts = ist->next_dts;
2722 for (i = 0; pkt && i < nb_output_streams; i++) {
2723 OutputStream *ost = output_streams[i];
2725 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2728 do_streamcopy(ist, ost, pkt);
2734 static void print_sdp(void)
2738 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2742 for (i = 0; i < nb_output_files; i++)
2743 avc[i] = output_files[i]->ctx;
2745 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2746 printf("SDP:\n%s\n", sdp);
2751 static int init_input_stream(int ist_index, char *error, int error_len)
2753 InputStream *ist = input_streams[ist_index];
2755 if (ist->decoding_needed) {
2756 AVCodec *codec = ist->dec;
2758 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2759 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2760 return AVERROR(EINVAL);
2763 ist->dr1 = (codec->capabilities & CODEC_CAP_DR1) && !do_deinterlace;
2764 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2765 ist->st->codec->get_buffer = codec_get_buffer;
2766 ist->st->codec->release_buffer = codec_release_buffer;
2767 ist->st->codec->opaque = &ist->buffer_pool;
2770 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2771 av_dict_set(&ist->opts, "threads", "auto", 0);
2772 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2773 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2774 ist->file_index, ist->st->index);
2775 return AVERROR(EINVAL);
2777 assert_codec_experimental(ist->st->codec, 0);
2778 assert_avoptions(ist->opts);
2781 ist->next_pts = AV_NOPTS_VALUE;
2782 ist->next_dts = AV_NOPTS_VALUE;
2788 static InputStream *get_input_stream(OutputStream *ost)
2790 if (ost->source_index >= 0)
2791 return input_streams[ost->source_index];
2795 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2796 AVCodecContext *avctx)
2802 for (p = kf; *p; p++)
2805 ost->forced_kf_count = n;
2806 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2807 if (!ost->forced_kf_pts) {
2808 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2813 for (i = 0; i < n; i++) {
2814 char *next = strchr(p, ',');
2819 t = parse_time_or_die("force_key_frames", p, 1);
2820 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2826 static int transcode_init(void)
2828 int ret = 0, i, j, k;
2829 AVFormatContext *oc;
2830 AVCodecContext *codec, *icodec = NULL;
2836 /* init framerate emulation */
2837 for (i = 0; i < nb_input_files; i++) {
2838 InputFile *ifile = input_files[i];
2839 if (ifile->rate_emu)
2840 for (j = 0; j < ifile->nb_streams; j++)
2841 input_streams[j + ifile->ist_index]->start = av_gettime();
2844 /* output stream init */
2845 for (i = 0; i < nb_output_files; i++) {
2846 oc = output_files[i]->ctx;
2847 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2848 av_dump_format(oc, i, oc->filename, 1);
2849 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2850 return AVERROR(EINVAL);
2854 /* init complex filtergraphs */
2855 for (i = 0; i < nb_filtergraphs; i++)
2856 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2859 /* for each output stream, we compute the right encoding parameters */
2860 for (i = 0; i < nb_output_streams; i++) {
2861 ost = output_streams[i];
2862 oc = output_files[ost->file_index]->ctx;
2863 ist = get_input_stream(ost);
2865 if (ost->attachment_filename)
2868 codec = ost->st->codec;
2871 icodec = ist->st->codec;
2873 ost->st->disposition = ist->st->disposition;
2874 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2875 codec->chroma_sample_location = icodec->chroma_sample_location;
2878 if (ost->stream_copy) {
2879 uint64_t extra_size;
2881 av_assert0(ist && !ost->filter);
2883 extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2885 if (extra_size > INT_MAX) {
2886 return AVERROR(EINVAL);
2889 /* if stream_copy is selected, no need to decode or encode */
2890 codec->codec_id = icodec->codec_id;
2891 codec->codec_type = icodec->codec_type;
2893 if (!codec->codec_tag) {
2894 if (!oc->oformat->codec_tag ||
2895 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2896 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2897 codec->codec_tag = icodec->codec_tag;
2900 codec->bit_rate = icodec->bit_rate;
2901 codec->rc_max_rate = icodec->rc_max_rate;
2902 codec->rc_buffer_size = icodec->rc_buffer_size;
2903 codec->field_order = icodec->field_order;
2904 codec->extradata = av_mallocz(extra_size);
2905 if (!codec->extradata) {
2906 return AVERROR(ENOMEM);
2908 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2909 codec->extradata_size= icodec->extradata_size;
2910 codec->bits_per_coded_sample = icodec->bits_per_coded_sample;
2912 codec->time_base = ist->st->time_base;
2914 * Avi is a special case here because it supports variable fps but
2915 * having the fps and timebase differe significantly adds quite some
2918 if(!strcmp(oc->oformat->name, "avi")) {
2919 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2920 && av_q2d(ist->st->time_base) < 1.0/500
2922 codec->time_base = icodec->time_base;
2923 codec->time_base.num *= icodec->ticks_per_frame;
2924 codec->time_base.den *= 2;
2925 codec->ticks_per_frame = 2;
2927 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2928 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2929 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2931 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2932 && av_q2d(ist->st->time_base) < 1.0/500
2934 codec->time_base = icodec->time_base;
2935 codec->time_base.num *= icodec->ticks_per_frame;
2939 if(ost->frame_rate.num)
2940 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2942 av_reduce(&codec->time_base.num, &codec->time_base.den,
2943 codec->time_base.num, codec->time_base.den, INT_MAX);
2945 switch (codec->codec_type) {
2946 case AVMEDIA_TYPE_AUDIO:
2947 if (audio_volume != 256) {
2948 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2951 codec->channel_layout = icodec->channel_layout;
2952 codec->sample_rate = icodec->sample_rate;
2953 codec->channels = icodec->channels;
2954 codec->frame_size = icodec->frame_size;
2955 codec->audio_service_type = icodec->audio_service_type;
2956 codec->block_align = icodec->block_align;
2957 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2958 codec->block_align= 0;
2959 if(codec->codec_id == CODEC_ID_AC3)
2960 codec->block_align= 0;
2962 case AVMEDIA_TYPE_VIDEO:
2963 codec->pix_fmt = icodec->pix_fmt;
2964 codec->width = icodec->width;
2965 codec->height = icodec->height;
2966 codec->has_b_frames = icodec->has_b_frames;
2967 if (!codec->sample_aspect_ratio.num) {
2968 codec->sample_aspect_ratio =
2969 ost->st->sample_aspect_ratio =
2970 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2971 ist->st->codec->sample_aspect_ratio.num ?
2972 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2974 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2976 case AVMEDIA_TYPE_SUBTITLE:
2977 codec->width = icodec->width;
2978 codec->height = icodec->height;
2980 case AVMEDIA_TYPE_DATA:
2981 case AVMEDIA_TYPE_ATTACHMENT:
2988 ost->enc = avcodec_find_encoder(codec->codec_id);
2990 /* should only happen when a default codec is not present. */
2991 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2992 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2993 ret = AVERROR(EINVAL);
2998 ist->decoding_needed = 1;
2999 ost->encoding_needed = 1;
3001 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
3002 if (ost->filter && !ost->frame_rate.num)
3003 ost->frame_rate = av_buffersink_get_frame_rate(ost->filter->filter);
3004 if (ist && !ost->frame_rate.num)
3005 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25, 1};
3006 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3007 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3008 ost->frame_rate = ost->enc->supported_framerates[idx];
3013 (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
3014 codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
3016 fg = init_simple_filtergraph(ist, ost);
3017 if (configure_filtergraph(fg)) {
3018 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3023 switch (codec->codec_type) {
3024 case AVMEDIA_TYPE_AUDIO:
3025 codec->sample_fmt = ost->filter->filter->inputs[0]->format;
3026 codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
3027 codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
3028 codec->channels = av_get_channel_layout_nb_channels(codec->channel_layout);
3029 codec->time_base = (AVRational){ 1, codec->sample_rate };
3031 case AVMEDIA_TYPE_VIDEO:
3032 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3033 if (ost->filter && !(codec->time_base.num && codec->time_base.den))
3034 codec->time_base = ost->filter->filter->inputs[0]->time_base;
3035 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3036 && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3037 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3038 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3040 for (j = 0; j < ost->forced_kf_count; j++)
3041 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3045 codec->width = ost->filter->filter->inputs[0]->w;
3046 codec->height = ost->filter->filter->inputs[0]->h;
3047 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3048 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3049 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3050 ost->filter->filter->inputs[0]->sample_aspect_ratio;
3051 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3054 codec->width != icodec->width ||
3055 codec->height != icodec->height ||
3056 codec->pix_fmt != icodec->pix_fmt) {
3057 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3060 if (ost->forced_keyframes)
3061 parse_forced_key_frames(ost->forced_keyframes, ost,
3064 case AVMEDIA_TYPE_SUBTITLE:
3065 codec->time_base = (AVRational){1, 1000};
3072 if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3073 char logfilename[1024];
3076 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3077 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3079 if (!strcmp(ost->enc->name, "libx264")) {
3080 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3082 if (codec->flags & CODEC_FLAG_PASS2) {
3084 size_t logbuffer_size;
3085 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3086 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3090 codec->stats_in = logbuffer;
3092 if (codec->flags & CODEC_FLAG_PASS1) {
3093 f = fopen(logfilename, "wb");
3095 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3096 logfilename, strerror(errno));
3106 /* open each encoder */
3107 for (i = 0; i < nb_output_streams; i++) {
3108 ost = output_streams[i];
3109 if (ost->encoding_needed) {
3110 AVCodec *codec = ost->enc;
3111 AVCodecContext *dec = NULL;
3113 if ((ist = get_input_stream(ost)))
3114 dec = ist->st->codec;
3115 if (dec && dec->subtitle_header) {
3116 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3117 if (!ost->st->codec->subtitle_header) {
3118 ret = AVERROR(ENOMEM);
3121 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3122 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3124 if (!av_dict_get(ost->opts, "threads", NULL, 0))
3125 av_dict_set(&ost->opts, "threads", "auto", 0);
3126 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3127 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3128 ost->file_index, ost->index);
3129 ret = AVERROR(EINVAL);
3132 if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
3133 !(ost->enc->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE))
3134 av_buffersink_set_frame_size(ost->filter->filter,
3135 ost->st->codec->frame_size);
3136 assert_codec_experimental(ost->st->codec, 1);
3137 assert_avoptions(ost->opts);
3138 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3139 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3140 " It takes bits/s as argument, not kbits/s\n");
3141 extra_size += ost->st->codec->extradata_size;
3143 if (ost->st->codec->me_threshold)
3144 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3148 /* init input streams */
3149 for (i = 0; i < nb_input_streams; i++)
3150 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3153 /* discard unused programs */
3154 for (i = 0; i < nb_input_files; i++) {
3155 InputFile *ifile = input_files[i];
3156 for (j = 0; j < ifile->ctx->nb_programs; j++) {
3157 AVProgram *p = ifile->ctx->programs[j];
3158 int discard = AVDISCARD_ALL;
3160 for (k = 0; k < p->nb_stream_indexes; k++)
3161 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3162 discard = AVDISCARD_DEFAULT;
3165 p->discard = discard;
3169 /* open files and write file headers */
3170 for (i = 0; i < nb_output_files; i++) {
3171 oc = output_files[i]->ctx;
3172 oc->interrupt_callback = int_cb;
3173 if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
3175 const char *errbuf_ptr = errbuf;
3176 if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
3177 errbuf_ptr = strerror(AVUNERROR(ret));
3178 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
3179 ret = AVERROR(EINVAL);
3182 // assert_avoptions(output_files[i]->opts);
3183 if (strcmp(oc->oformat->name, "rtp")) {
3189 /* dump the file output parameters - cannot be done before in case
3191 for (i = 0; i < nb_output_files; i++) {
3192 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3195 /* dump the stream mapping */
3196 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3197 for (i = 0; i < nb_input_streams; i++) {
3198 ist = input_streams[i];
3200 for (j = 0; j < ist->nb_filters; j++) {
3201 if (ist->filters[j]->graph->graph_desc) {
3202 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
3203 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3204 ist->filters[j]->name);
3205 if (nb_filtergraphs > 1)
3206 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3207 av_log(NULL, AV_LOG_INFO, "\n");
3212 for (i = 0; i < nb_output_streams; i++) {
3213 ost = output_streams[i];
3215 if (ost->attachment_filename) {
3216 /* an attached file */
3217 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
3218 ost->attachment_filename, ost->file_index, ost->index);
3222 if (ost->filter && ost->filter->graph->graph_desc) {
3223 /* output from a complex graph */
3224 av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
3225 if (nb_filtergraphs > 1)
3226 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3228 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3229 ost->index, ost->enc ? ost->enc->name : "?");
3233 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
3234 input_streams[ost->source_index]->file_index,
3235 input_streams[ost->source_index]->st->index,
3238 if (ost->sync_ist != input_streams[ost->source_index])
3239 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3240 ost->sync_ist->file_index,
3241 ost->sync_ist->st->index);
3242 if (ost->stream_copy)
3243 av_log(NULL, AV_LOG_INFO, " (copy)");
3245 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3246 input_streams[ost->source_index]->dec->name : "?",
3247 ost->enc ? ost->enc->name : "?");
3248 av_log(NULL, AV_LOG_INFO, "\n");
3252 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3264 * @return 1 if there are still streams where more output is wanted,
3267 static int need_output(void)
3271 for (i = 0; i < nb_output_streams; i++) {
3272 OutputStream *ost = output_streams[i];
3273 OutputFile *of = output_files[ost->file_index];
3274 AVFormatContext *os = output_files[ost->file_index]->ctx;
3276 if (ost->is_past_recording_time ||
3277 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3279 if (ost->frame_number >= ost->max_frames) {
3281 for (j = 0; j < of->ctx->nb_streams; j++)
3282 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3292 static int select_input_file(uint8_t *no_packet)
3294 int64_t ipts_min = INT64_MAX;
3295 int i, file_index = -1;
3297 for (i = 0; i < nb_input_streams; i++) {
3298 InputStream *ist = input_streams[i];
3299 int64_t ipts = ist->pts;
3301 if (ist->discard || no_packet[ist->file_index])
3303 if (!input_files[ist->file_index]->eof_reached) {
3304 if (ipts < ipts_min) {
3306 file_index = ist->file_index;
3314 static int check_keyboard_interaction(int64_t cur_time)
3317 static int64_t last_time;
3318 if (received_nb_signals)
3319 return AVERROR_EXIT;
3320 /* read_key() returns 0 on EOF */
3321 if(cur_time - last_time >= 100000 && !run_as_daemon){
3323 last_time = cur_time;
3327 return AVERROR_EXIT;
3328 if (key == '+') av_log_set_level(av_log_get_level()+10);
3329 if (key == '-') av_log_set_level(av_log_get_level()-10);
3330 if (key == 's') qp_hist ^= 1;
3333 do_hex_dump = do_pkt_dump = 0;
3334 } else if(do_pkt_dump){
3338 av_log_set_level(AV_LOG_DEBUG);
3340 if (key == 'c' || key == 'C'){
3341 char buf[4096], target[64], command[256], arg[256] = {0};
3344 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3346 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3351 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3352 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3353 target, time, command, arg);
3354 for (i = 0; i < nb_filtergraphs; i++) {
3355 FilterGraph *fg = filtergraphs[i];
3358 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3359 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3360 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3362 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3367 av_log(NULL, AV_LOG_ERROR,
3368 "Parse error, at least 3 arguments were expected, "
3369 "only %d given in string '%s'\n", n, buf);
3372 if (key == 'd' || key == 'D'){
3375 debug = input_streams[0]->st->codec->debug<<1;
3376 if(!debug) debug = 1;
3377 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3380 if(scanf("%d", &debug)!=1)
3381 fprintf(stderr,"error parsing debug value\n");
3382 for(i=0;i<nb_input_streams;i++) {
3383 input_streams[i]->st->codec->debug = debug;
3385 for(i=0;i<nb_output_streams;i++) {
3386 OutputStream *ost = output_streams[i];
3387 ost->st->codec->debug = debug;
3389 if(debug) av_log_set_level(AV_LOG_DEBUG);
3390 fprintf(stderr,"debug=%d\n", debug);
3393 fprintf(stderr, "key function\n"
3394 "? show this help\n"
3395 "+ increase verbosity\n"
3396 "- decrease verbosity\n"
3397 "c Send command to filtergraph\n"
3398 "D cycle through available debug modes\n"
3399 "h dump packets/hex press to cycle through the 3 states\n"
3401 "s Show QP histogram\n"
3408 static void *input_thread(void *arg)
3413 while (!transcoding_finished && ret >= 0) {
3415 ret = av_read_frame(f->ctx, &pkt);
3417 if (ret == AVERROR(EAGAIN)) {
3424 pthread_mutex_lock(&f->fifo_lock);
3425 while (!av_fifo_space(f->fifo))
3426 pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
3428 av_dup_packet(&pkt);
3429 av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
3431 pthread_mutex_unlock(&f->fifo_lock);
3438 static void free_input_threads(void)
3442 if (nb_input_files == 1)
3445 transcoding_finished = 1;
3447 for (i = 0; i < nb_input_files; i++) {
3448 InputFile *f = input_files[i];
3451 if (!f->fifo || f->joined)
3454 pthread_mutex_lock(&f->fifo_lock);
3455 while (av_fifo_size(f->fifo)) {
3456 av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
3457 av_free_packet(&pkt);
3459 pthread_cond_signal(&f->fifo_cond);
3460 pthread_mutex_unlock(&f->fifo_lock);
3462 pthread_join(f->thread, NULL);
3465 while (av_fifo_size(f->fifo)) {
3466 av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
3467 av_free_packet(&pkt);
3469 av_fifo_free(f->fifo);
3473 static int init_input_threads(void)
3477 if (nb_input_files == 1)
3480 for (i = 0; i < nb_input_files; i++) {
3481 InputFile *f = input_files[i];
3483 if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
3484 return AVERROR(ENOMEM);
3486 pthread_mutex_init(&f->fifo_lock, NULL);
3487 pthread_cond_init (&f->fifo_cond, NULL);
3489 if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
3490 return AVERROR(ret);
3495 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
3499 pthread_mutex_lock(&f->fifo_lock);
3501 if (av_fifo_size(f->fifo)) {
3502 av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
3503 pthread_cond_signal(&f->fifo_cond);
3508 ret = AVERROR(EAGAIN);
3511 pthread_mutex_unlock(&f->fifo_lock);
3517 static int get_input_packet(InputFile *f, AVPacket *pkt)
3520 if (nb_input_files > 1)
3521 return get_input_packet_mt(f, pkt);
3523 return av_read_frame(f->ctx, pkt);
3527 * The following code is the main loop of the file converter
3529 static int transcode(void)
3532 AVFormatContext *is, *os;
3536 int no_packet_count = 0;
3537 int64_t timer_start;
3539 if (!(no_packet = av_mallocz(nb_input_files)))
3542 ret = transcode_init();
3547 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3550 timer_start = av_gettime();
3553 if ((ret = init_input_threads()) < 0)
3557 for (; received_sigterm == 0;) {
3558 int file_index, ist_index;
3560 int64_t cur_time= av_gettime();
3562 /* if 'q' pressed, exits */
3564 if (check_keyboard_interaction(cur_time) < 0)
3567 /* check if there's any stream where output is still needed */
3568 if (!need_output()) {
3569 av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
3573 /* select the stream that we must read now */
3574 file_index = select_input_file(no_packet);
3575 /* if none, if is finished */
3576 if (file_index < 0) {
3577 if (no_packet_count) {
3578 no_packet_count = 0;
3579 memset(no_packet, 0, nb_input_files);
3583 av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
3587 is = input_files[file_index]->ctx;
3588 ret = get_input_packet(input_files[file_index], &pkt);
3590 if (ret == AVERROR(EAGAIN)) {
3591 no_packet[file_index] = 1;
3596 input_files[file_index]->eof_reached = 1;
3598 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3599 ist = input_streams[input_files[file_index]->ist_index + i];
3600 if (ist->decoding_needed)
3601 output_packet(ist, NULL);
3610 no_packet_count = 0;
3611 memset(no_packet, 0, nb_input_files);
3614 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3615 is->streams[pkt.stream_index]);
3617 /* the following test is needed in case new streams appear
3618 dynamically in stream : we ignore them */
3619 if (pkt.stream_index >= input_files[file_index]->nb_streams)
3620 goto discard_packet;
3621 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3622 ist = input_streams[ist_index];
3624 goto discard_packet;
3626 if (pkt.dts != AV_NOPTS_VALUE)
3627 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3628 if (pkt.pts != AV_NOPTS_VALUE)
3629 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3631 if (pkt.pts != AV_NOPTS_VALUE)
3632 pkt.pts *= ist->ts_scale;
3633 if (pkt.dts != AV_NOPTS_VALUE)
3634 pkt.dts *= ist->ts_scale;
3637 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3638 "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",
3639 ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3640 av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &ist->st->time_base),
3641 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3642 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3643 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3644 input_files[ist->file_index]->ts_offset);
3647 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3648 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3649 int64_t delta = pkt_dts - ist->next_dts;
3650 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3651 if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3652 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3653 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3654 pkt_dts+1<ist->pts){
3655 input_files[ist->file_index]->ts_offset -= delta;
3656 av_log(NULL, AV_LOG_DEBUG,
3657 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3658 delta, input_files[ist->file_index]->ts_offset);
3659 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3660 if (pkt.pts != AV_NOPTS_VALUE)
3661 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3664 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3665 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3666 pkt_dts+1<ist->pts){
3667 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3668 pkt.dts = AV_NOPTS_VALUE;
3670 if (pkt.pts != AV_NOPTS_VALUE){
3671 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3672 delta = pkt_pts - ist->next_dts;
3673 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3674 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3675 pkt_pts+1<ist->pts) {
3676 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3677 pkt.pts = AV_NOPTS_VALUE;
3683 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3684 if ((ret = output_packet(ist, &pkt)) < 0 ||
3685 ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3687 av_strerror(ret, buf, sizeof(buf));
3688 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
3689 ist->file_index, ist->st->index, buf);
3692 av_free_packet(&pkt);
3697 av_free_packet(&pkt);
3699 /* dump report by using the output first video and audio streams */
3700 print_report(0, timer_start, cur_time);
3703 free_input_threads();
3706 /* at the end of stream, we must flush the decoder buffers */
3707 for (i = 0; i < nb_input_streams; i++) {
3708 ist = input_streams[i];
3709 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3710 output_packet(ist, NULL);
3718 /* write the trailer if needed and close file */
3719 for (i = 0; i < nb_output_files; i++) {
3720 os = output_files[i]->ctx;
3721 av_write_trailer(os);
3724 /* dump report by using the first video and audio streams */
3725 print_report(1, timer_start, av_gettime());
3727 /* close each encoder */
3728 for (i = 0; i < nb_output_streams; i++) {
3729 ost = output_streams[i];
3730 if (ost->encoding_needed) {
3731 av_freep(&ost->st->codec->stats_in);
3732 avcodec_close(ost->st->codec);
3736 /* close each decoder */
3737 for (i = 0; i < nb_input_streams; i++) {
3738 ist = input_streams[i];
3739 if (ist->decoding_needed) {
3740 avcodec_close(ist->st->codec);
3748 av_freep(&no_packet);
3750 free_input_threads();
3753 if (output_streams) {
3754 for (i = 0; i < nb_output_streams; i++) {
3755 ost = output_streams[i];
3757 if (ost->stream_copy)
3758 av_freep(&ost->st->codec->extradata);
3760 fclose(ost->logfile);
3761 ost->logfile = NULL;
3763 av_freep(&ost->st->codec->subtitle_header);
3764 av_free(ost->forced_kf_pts);
3765 av_dict_free(&ost->opts);
3772 static int opt_frame_crop(const char *opt, const char *arg)
3774 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3775 return AVERROR(EINVAL);
3778 static int opt_pad(const char *opt, const char *arg)
3780 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3784 static int opt_video_channel(const char *opt, const char *arg)
3786 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3787 return opt_default("channel", arg);
3790 static int opt_video_standard(const char *opt, const char *arg)
3792 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3793 return opt_default("standard", arg);
3796 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3798 audio_codec_name = arg;
3799 return parse_option(o, "codec:a", arg, options);
3802 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3804 video_codec_name = arg;
3805 return parse_option(o, "codec:v", arg, options);
3808 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3810 subtitle_codec_name = arg;
3811 return parse_option(o, "codec:s", arg, options);
3814 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3816 return parse_option(o, "codec:d", arg, options);
3819 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3821 StreamMap *m = NULL;
3822 int i, negative = 0, file_idx;
3823 int sync_file_idx = -1, sync_stream_idx = 0;
3831 map = av_strdup(arg);
3833 /* parse sync stream first, just pick first matching stream */
3834 if (sync = strchr(map, ',')) {
3836 sync_file_idx = strtol(sync + 1, &sync, 0);
3837 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3838 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3843 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3844 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3845 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3846 sync_stream_idx = i;
3849 if (i == input_files[sync_file_idx]->nb_streams) {
3850 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3851 "match any streams.\n", arg);
3857 if (map[0] == '[') {
3858 /* this mapping refers to lavfi output */
3859 const char *c = map + 1;
3860 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3861 &o->nb_stream_maps, o->nb_stream_maps + 1);
3862 m = &o->stream_maps[o->nb_stream_maps - 1];
3863 m->linklabel = av_get_token(&c, "]");
3864 if (!m->linklabel) {
3865 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3869 file_idx = strtol(map, &p, 0);
3870 if (file_idx >= nb_input_files || file_idx < 0) {
3871 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3875 /* disable some already defined maps */
3876 for (i = 0; i < o->nb_stream_maps; i++) {
3877 m = &o->stream_maps[i];
3878 if (file_idx == m->file_index &&
3879 check_stream_specifier(input_files[m->file_index]->ctx,
3880 input_files[m->file_index]->ctx->streams[m->stream_index],
3881 *p == ':' ? p + 1 : p) > 0)
3885 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3886 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3887 *p == ':' ? p + 1 : p) <= 0)
3889 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3890 &o->nb_stream_maps, o->nb_stream_maps + 1);
3891 m = &o->stream_maps[o->nb_stream_maps - 1];
3893 m->file_index = file_idx;
3894 m->stream_index = i;
3896 if (sync_file_idx >= 0) {
3897 m->sync_file_index = sync_file_idx;
3898 m->sync_stream_index = sync_stream_idx;
3900 m->sync_file_index = file_idx;
3901 m->sync_stream_index = i;
3907 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3915 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3917 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3918 &o->nb_attachments, o->nb_attachments + 1);
3919 o->attachments[o->nb_attachments - 1] = arg;
3923 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3929 o->audio_channel_maps =
3930 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3931 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3932 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3934 /* muted channel syntax */
3935 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3936 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3937 m->file_idx = m->stream_idx = -1;
3939 m->ofile_idx = m->ostream_idx = -1;
3944 n = sscanf(arg, "%d.%d.%d:%d.%d",
3945 &m->file_idx, &m->stream_idx, &m->channel_idx,
3946 &m->ofile_idx, &m->ostream_idx);
3948 if (n != 3 && n != 5) {
3949 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3950 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3954 if (n != 5) // only file.stream.channel specified
3955 m->ofile_idx = m->ostream_idx = -1;
3958 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3959 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3963 if (m->stream_idx < 0 ||
3964 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
3965 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3966 m->file_idx, m->stream_idx);
3969 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
3970 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3971 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3972 m->file_idx, m->stream_idx);
3975 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3976 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3977 m->file_idx, m->stream_idx, m->channel_idx);
3984 * Parse a metadata specifier in arg.
3985 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3986 * @param index for type c/p, chapter/program index is written here
3987 * @param stream_spec for type s, the stream specifier is written here
3989 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3997 if (*(++arg) && *arg != ':') {
3998 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
4001 *stream_spec = *arg == ':' ? arg + 1 : "";
4005 if (*(++arg) == ':')
4006 *index = strtol(++arg, NULL, 0);
4009 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
4016 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
4018 AVDictionary **meta_in = NULL;
4019 AVDictionary **meta_out = NULL;
4021 char type_in, type_out;
4022 const char *istream_spec = NULL, *ostream_spec = NULL;
4023 int idx_in = 0, idx_out = 0;
4025 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
4026 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
4029 if (type_out == 'g' || !*outspec)
4030 o->metadata_global_manual = 1;
4031 if (type_out == 's' || !*outspec)
4032 o->metadata_streams_manual = 1;
4033 if (type_out == 'c' || !*outspec)
4034 o->metadata_chapters_manual = 1;
4038 if (type_in == 'g' || type_out == 'g')
4039 o->metadata_global_manual = 1;
4040 if (type_in == 's' || type_out == 's')
4041 o->metadata_streams_manual = 1;
4042 if (type_in == 'c' || type_out == 'c')
4043 o->metadata_chapters_manual = 1;
4045 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4046 if ((index) < 0 || (index) >= (nb_elems)) {\
4047 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
4052 #define SET_DICT(type, meta, context, index)\
4055 meta = &context->metadata;\
4058 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
4059 meta = &context->chapters[index]->metadata;\
4062 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
4063 meta = &context->programs[index]->metadata;\
4065 default: av_assert0(0);\
4068 SET_DICT(type_in, meta_in, ic, idx_in);
4069 SET_DICT(type_out, meta_out, oc, idx_out);
4071 /* for input streams choose first matching stream */
4072 if (type_in == 's') {
4073 for (i = 0; i < ic->nb_streams; i++) {
4074 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
4075 meta_in = &ic->streams[i]->metadata;
4081 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
4086 if (type_out == 's') {
4087 for (i = 0; i < oc->nb_streams; i++) {
4088 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
4089 meta_out = &oc->streams[i]->metadata;
4090 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4095 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4100 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
4103 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
4104 struct tm time = *gmtime((time_t*)&recording_timestamp);
4105 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
4106 parse_option(o, "metadata", buf, options);
4108 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
4109 "tag instead.\n", opt);
4113 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
4115 const char *codec_string = encoder ? "encoder" : "decoder";
4119 avcodec_find_encoder_by_name(name) :
4120 avcodec_find_decoder_by_name(name);
4122 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4125 if (codec->type != type) {
4126 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4132 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4134 char *codec_name = NULL;
4136 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4138 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4139 st->codec->codec_id = codec->id;
4142 return avcodec_find_decoder(st->codec->codec_id);
4146 * Add all the streams from the given input file to the global
4147 * list of input streams.
4149 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4152 char *next, *codec_tag = NULL;
4154 for (i = 0; i < ic->nb_streams; i++) {
4155 AVStream *st = ic->streams[i];
4156 AVCodecContext *dec = st->codec;
4157 InputStream *ist = av_mallocz(sizeof(*ist));
4158 char *framerate = NULL;
4163 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4164 input_streams[nb_input_streams - 1] = ist;
4167 ist->file_index = nb_input_files;
4169 st->discard = AVDISCARD_ALL;
4170 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st, choose_decoder(o, ic, st));
4172 ist->ts_scale = 1.0;
4173 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4175 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4177 uint32_t tag = strtol(codec_tag, &next, 0);
4179 tag = AV_RL32(codec_tag);
4180 st->codec->codec_tag = tag;
4183 ist->dec = choose_decoder(o, ic, st);
4185 switch (dec->codec_type) {
4186 case AVMEDIA_TYPE_VIDEO:
4188 ist->dec = avcodec_find_decoder(dec->codec_id);
4190 dec->flags |= CODEC_FLAG_EMU_EDGE;
4193 ist->resample_height = dec->height;
4194 ist->resample_width = dec->width;
4195 ist->resample_pix_fmt = dec->pix_fmt;
4197 MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
4198 if (framerate && av_parse_video_rate(&ist->framerate,
4200 av_log(NULL, AV_LOG_ERROR, "Error parsing framerate %s.\n",
4205 ist->top_field_first = -1;
4206 MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
4209 case AVMEDIA_TYPE_AUDIO:
4210 guess_input_channel_layout(ist);
4212 ist->resample_sample_fmt = dec->sample_fmt;
4213 ist->resample_sample_rate = dec->sample_rate;
4214 ist->resample_channels = dec->channels;
4215 ist->resample_channel_layout = dec->channel_layout;
4218 case AVMEDIA_TYPE_DATA:
4219 case AVMEDIA_TYPE_SUBTITLE:
4221 ist->dec = avcodec_find_decoder(dec->codec_id);
4223 case AVMEDIA_TYPE_ATTACHMENT:
4224 case AVMEDIA_TYPE_UNKNOWN:
4232 static void assert_file_overwrite(const char *filename)
4234 if ((!file_overwrite || no_file_overwrite) &&
4235 (strchr(filename, ':') == NULL || filename[1] == ':' ||
4236 av_strstart(filename, "file:", NULL))) {
4237 if (avio_check(filename, 0) == 0) {
4238 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
4239 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4242 signal(SIGINT, SIG_DFL);
4243 if (!read_yesno()) {
4244 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4250 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4257 static void dump_attachment(AVStream *st, const char *filename)
4260 AVIOContext *out = NULL;
4261 AVDictionaryEntry *e;
4263 if (!st->codec->extradata_size) {
4264 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4265 nb_input_files - 1, st->index);
4268 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4269 filename = e->value;
4271 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4272 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4276 assert_file_overwrite(filename);
4278 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4279 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4284 avio_write(out, st->codec->extradata, st->codec->extradata_size);
4289 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4291 AVFormatContext *ic;
4292 AVInputFormat *file_iformat = NULL;
4296 AVDictionary **opts;
4297 int orig_nb_streams; // number of streams before avformat_find_stream_info
4300 if (!(file_iformat = av_find_input_format(o->format))) {
4301 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4306 if (!strcmp(filename, "-"))
4309 using_stdin |= !strncmp(filename, "pipe:", 5) ||
4310 !strcmp(filename, "/dev/stdin");
4312 /* get default parameters from command line */
4313 ic = avformat_alloc_context();
4315 print_error(filename, AVERROR(ENOMEM));
4318 if (o->nb_audio_sample_rate) {
4319 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4320 av_dict_set(&format_opts, "sample_rate", buf, 0);
4322 if (o->nb_audio_channels) {
4323 /* because we set audio_channels based on both the "ac" and
4324 * "channel_layout" options, we need to check that the specified
4325 * demuxer actually has the "channels" option before setting it */
4326 if (file_iformat && file_iformat->priv_class &&
4327 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4328 AV_OPT_SEARCH_FAKE_OBJ)) {
4329 snprintf(buf, sizeof(buf), "%d",
4330 o->audio_channels[o->nb_audio_channels - 1].u.i);
4331 av_dict_set(&format_opts, "channels", buf, 0);
4334 if (o->nb_frame_rates) {
4335 /* set the format-level framerate option;
4336 * this is important for video grabbers, e.g. x11 */
4337 if (file_iformat && file_iformat->priv_class &&
4338 av_opt_find(&file_iformat->priv_class, "framerate", NULL, 0,
4339 AV_OPT_SEARCH_FAKE_OBJ)) {
4340 av_dict_set(&format_opts, "framerate",
4341 o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4344 if (o->nb_frame_sizes) {
4345 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4347 if (o->nb_frame_pix_fmts)
4348 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4350 ic->video_codec_id = video_codec_name ?
4351 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
4352 ic->audio_codec_id = audio_codec_name ?
4353 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
4354 ic->subtitle_codec_id= subtitle_codec_name ?
4355 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4356 ic->flags |= AVFMT_FLAG_NONBLOCK;
4357 ic->interrupt_callback = int_cb;
4359 /* open the input file with generic avformat function */
4360 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4362 print_error(filename, err);
4365 assert_avoptions(format_opts);
4367 /* apply forced codec ids */
4368 for (i = 0; i < ic->nb_streams; i++)
4369 choose_decoder(o, ic, ic->streams[i]);
4371 /* Set AVCodecContext options for avformat_find_stream_info */
4372 opts = setup_find_stream_info_opts(ic, codec_opts);
4373 orig_nb_streams = ic->nb_streams;
4375 /* If not enough info to get the stream parameters, we decode the
4376 first frames to get it. (used in mpeg case for example) */
4377 ret = avformat_find_stream_info(ic, opts);
4379 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4380 avformat_close_input(&ic);
4384 timestamp = o->start_time;
4385 /* add the stream start time */
4386 if (ic->start_time != AV_NOPTS_VALUE)
4387 timestamp += ic->start_time;
4389 /* if seeking requested, we execute it */
4390 if (o->start_time != 0) {
4391 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4393 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4394 filename, (double)timestamp / AV_TIME_BASE);
4398 /* update the current parameters so that they match the one of the input stream */
4399 add_input_streams(o, ic);
4401 /* dump the file content */
4402 av_dump_format(ic, nb_input_files, filename, 0);
4404 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4405 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4408 input_files[nb_input_files - 1]->ctx = ic;
4409 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
4410 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4411 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4412 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
4414 for (i = 0; i < o->nb_dump_attachment; i++) {
4417 for (j = 0; j < ic->nb_streams; j++) {
4418 AVStream *st = ic->streams[j];
4420 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4421 dump_attachment(st, o->dump_attachment[i].u.str);
4425 for (i = 0; i < orig_nb_streams; i++)
4426 av_dict_free(&opts[i]);
4429 reset_options(o, 1);
4433 static uint8_t *get_line(AVIOContext *s)
4439 if (avio_open_dyn_buf(&line) < 0) {
4440 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4444 while ((c = avio_r8(s)) && c != '\n')
4447 avio_close_dyn_buf(line, &buf);
4452 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4455 char filename[1000];
4456 const char *base[3] = { getenv("AVCONV_DATADIR"),
4461 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4465 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4466 i != 1 ? "" : "/.avconv", codec_name, preset_name);
4467 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4470 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4471 i != 1 ? "" : "/.avconv", preset_name);
4472 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4478 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4480 char *codec_name = NULL;
4482 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4484 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4485 NULL, ost->st->codec->codec_type);
4486 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4487 } else if (!strcmp(codec_name, "copy"))
4488 ost->stream_copy = 1;
4490 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4491 ost->st->codec->codec_id = ost->enc->id;
4495 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4498 AVStream *st = avformat_new_stream(oc, NULL);
4499 int idx = oc->nb_streams - 1, ret = 0;
4500 char *bsf = NULL, *next, *codec_tag = NULL;
4501 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4503 char *buf = NULL, *arg = NULL, *preset = NULL;
4504 AVIOContext *s = NULL;
4507 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4511 if (oc->nb_streams - 1 < o->nb_streamid_map)
4512 st->id = o->streamid_map[oc->nb_streams - 1];
4514 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4515 nb_output_streams + 1);
4516 if (!(ost = av_mallocz(sizeof(*ost))))
4518 output_streams[nb_output_streams - 1] = ost;
4520 ost->file_index = nb_output_files;
4523 st->codec->codec_type = type;
4524 choose_encoder(o, oc, ost);
4526 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st, ost->enc);
4529 avcodec_get_context_defaults3(st->codec, ost->enc);
4530 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4532 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4533 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4536 if (!buf[0] || buf[0] == '#') {
4540 if (!(arg = strchr(buf, '='))) {
4541 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4545 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4547 } while (!s->eof_reached);
4551 av_log(NULL, AV_LOG_FATAL,
4552 "Preset %s specified for stream %d:%d, but could not be opened.\n",
4553 preset, ost->file_index, ost->index);
4557 ost->max_frames = INT64_MAX;
4558 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4560 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4562 if (next = strchr(bsf, ','))
4564 if (!(bsfc = av_bitstream_filter_init(bsf))) {
4565 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4569 bsfc_prev->next = bsfc;
4571 ost->bitstream_filters = bsfc;
4577 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4579 uint32_t tag = strtol(codec_tag, &next, 0);
4581 tag = AV_RL32(codec_tag);
4582 st->codec->codec_tag = tag;
4585 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4586 if (qscale >= 0 || same_quant) {
4587 st->codec->flags |= CODEC_FLAG_QSCALE;
4588 st->codec->global_quality = FF_QP2LAMBDA * qscale;
4591 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4592 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4594 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4595 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4596 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4598 ost->source_index = source_index;
4599 if (source_index >= 0) {
4600 ost->sync_ist = input_streams[source_index];
4601 input_streams[source_index]->discard = 0;
4602 input_streams[source_index]->st->discard = AVDISCARD_NONE;
4608 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4611 const char *p = str;
4618 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4625 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4629 AVCodecContext *video_enc;
4630 char *frame_rate = NULL;
4632 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4634 video_enc = st->codec;
4636 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4637 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4638 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4642 if (!ost->stream_copy) {
4643 const char *p = NULL;
4644 char *frame_size = NULL;
4645 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4646 char *intra_matrix = NULL, *inter_matrix = NULL;
4647 const char *filters = "null";
4650 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4651 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4652 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4656 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4657 if (frame_aspect_ratio) {
4659 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4660 q.num <= 0 || q.den <= 0) {
4661 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4664 ost->frame_aspect_ratio = av_q2d(q);
4667 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4668 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4669 if (frame_pix_fmt && *frame_pix_fmt == '+') {
4670 ost->keep_pix_fmt = 1;
4671 if (!*++frame_pix_fmt)
4672 frame_pix_fmt = NULL;
4674 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4675 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4678 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4681 video_enc->gop_size = 0;
4682 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4684 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4685 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4688 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4690 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4692 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4693 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4696 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4699 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4700 for (i = 0; p; i++) {
4702 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4704 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4707 /* FIXME realloc failure */
4708 video_enc->rc_override =
4709 av_realloc(video_enc->rc_override,
4710 sizeof(RcOverride) * (i + 1));
4711 video_enc->rc_override[i].start_frame = start;
4712 video_enc->rc_override[i].end_frame = end;
4714 video_enc->rc_override[i].qscale = q;
4715 video_enc->rc_override[i].quality_factor = 1.0;
4718 video_enc->rc_override[i].qscale = 0;
4719 video_enc->rc_override[i].quality_factor = -q/100.0;
4724 video_enc->rc_override_count = i;
4725 if (!video_enc->rc_initial_buffer_occupancy)
4726 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4727 video_enc->intra_dc_precision = intra_dc_precision - 8;
4730 video_enc->flags|= CODEC_FLAG_PSNR;
4735 video_enc->flags |= CODEC_FLAG_PASS1;
4738 video_enc->flags |= CODEC_FLAG_PASS2;
4742 MATCH_PER_STREAM_OPT(forced_key_frames, str, ost->forced_keyframes, oc, st);
4743 if (ost->forced_keyframes)
4744 ost->forced_keyframes = av_strdup(ost->forced_keyframes);
4746 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4748 ost->top_field_first = -1;
4749 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4751 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4752 ost->avfilter = av_strdup(filters);
4754 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4760 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4765 AVCodecContext *audio_enc;
4767 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4770 audio_enc = st->codec;
4771 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4773 if (!ost->stream_copy) {
4774 char *sample_fmt = NULL;
4775 const char *filters = "anull";
4777 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4779 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4781 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4782 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4786 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4788 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4790 av_assert1(filters);
4791 ost->avfilter = av_strdup(filters);
4793 /* check for channel mapping for this audio stream */
4794 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4795 AudioChannelMap *map = &o->audio_channel_maps[n];
4796 InputStream *ist = input_streams[ost->source_index];
4797 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4798 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4799 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4800 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4801 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4803 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4804 ost->file_index, ost->st->index);
4812 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4816 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4817 if (!ost->stream_copy) {
4818 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4825 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4827 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4828 ost->stream_copy = 1;
4832 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4836 AVCodecContext *subtitle_enc;
4838 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4840 subtitle_enc = st->codec;
4842 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4844 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4849 /* arg format is "output-stream-index:streamid-value". */
4850 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4856 av_strlcpy(idx_str, arg, sizeof(idx_str));
4857 p = strchr(idx_str, ':');
4859 av_log(NULL, AV_LOG_FATAL,
4860 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4865 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4866 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4867 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4871 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4873 AVFormatContext *is = ifile->ctx;
4874 AVFormatContext *os = ofile->ctx;
4877 for (i = 0; i < is->nb_chapters; i++) {
4878 AVChapter *in_ch = is->chapters[i], *out_ch;
4879 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4880 AV_TIME_BASE_Q, in_ch->time_base);
4881 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4882 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4885 if (in_ch->end < ts_off)
4887 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4890 out_ch = av_mallocz(sizeof(AVChapter));
4892 return AVERROR(ENOMEM);
4894 out_ch->id = in_ch->id;
4895 out_ch->time_base = in_ch->time_base;
4896 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4897 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4900 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4903 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4905 return AVERROR(ENOMEM);
4906 os->chapters[os->nb_chapters - 1] = out_ch;
4911 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4914 AVFormatContext *ic = avformat_alloc_context();
4916 ic->interrupt_callback = int_cb;
4917 err = avformat_open_input(&ic, filename, NULL, NULL);
4920 /* copy stream format */
4921 for(i=0;i<ic->nb_streams;i++) {
4925 AVCodecContext *avctx;
4927 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4928 ost = new_output_stream(o, s, codec->type, -1);
4933 // FIXME: a more elegant solution is needed
4934 memcpy(st, ic->streams[i], sizeof(AVStream));
4936 st->info = av_malloc(sizeof(*st->info));
4937 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4939 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4941 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4942 choose_sample_fmt(st, codec);
4943 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4944 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4947 avformat_close_input(&ic);
4951 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4952 AVFormatContext *oc)
4956 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
4957 ofilter->out_tmp->pad_idx)) {
4958 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, -1); break;
4959 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, -1); break;
4961 av_log(NULL, AV_LOG_FATAL, "Only video and audio filters are supported "
4966 ost->source_index = -1;
4967 ost->filter = ofilter;
4971 if (ost->stream_copy) {
4972 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4973 "which is fed from a complex filtergraph. Filtering and streamcopy "
4974 "cannot be used together.\n", ost->file_index, ost->index);
4977 if (o->recording_time != INT64_MAX)
4978 av_log(NULL, AV_LOG_WARNING,
4979 "-t does not work with -filter_complex (yet).\n");
4981 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4982 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4985 avfilter_inout_free(&ofilter->out_tmp);
4988 static void opt_output_file(void *optctx, const char *filename)
4990 OptionsContext *o = optctx;
4991 AVFormatContext *oc;
4993 AVOutputFormat *file_oformat;
4997 if (configure_complex_filters() < 0) {
4998 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
5002 if (!strcmp(filename, "-"))
5005 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
5007 print_error(filename, err);
5010 file_oformat= oc->oformat;
5011 oc->interrupt_callback = int_cb;
5013 /* create streams for all unlabeled output pads */
5014 for (i = 0; i < nb_filtergraphs; i++) {
5015 FilterGraph *fg = filtergraphs[i];
5016 for (j = 0; j < fg->nb_outputs; j++) {
5017 OutputFilter *ofilter = fg->outputs[j];
5019 if (!ofilter->out_tmp || ofilter->out_tmp->name)
5022 switch (avfilter_pad_get_type(ofilter->out_tmp->filter_ctx->output_pads,
5023 ofilter->out_tmp->pad_idx)) {
5024 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
5025 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
5026 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
5028 init_output_filter(ofilter, o, oc);
5032 if (!strcmp(file_oformat->name, "ffm") &&
5033 av_strstart(filename, "http:", NULL)) {
5035 /* special case for files sent to ffserver: we get the stream
5036 parameters from ffserver */
5037 int err = read_ffserver_streams(o, oc, filename);
5039 print_error(filename, err);
5042 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
5043 ost = output_streams[j];
5044 for (i = 0; i < nb_input_streams; i++) {
5045 ist = input_streams[i];
5046 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
5048 ost->source_index= i;
5049 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) ost->avfilter = av_strdup("anull");
5050 if(ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) ost->avfilter = av_strdup("null");
5052 ist->st->discard = AVDISCARD_NONE;
5057 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));
5061 } else if (!o->nb_stream_maps) {
5062 /* pick the "best" stream of each type */
5064 /* video: highest resolution */
5065 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
5066 int area = 0, idx = -1;
5067 for (i = 0; i < nb_input_streams; i++) {
5068 ist = input_streams[i];
5069 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
5070 ist->st->codec->width * ist->st->codec->height > area) {
5071 area = ist->st->codec->width * ist->st->codec->height;
5076 new_video_stream(o, oc, idx);
5079 /* audio: most channels */
5080 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
5081 int channels = 0, idx = -1;
5082 for (i = 0; i < nb_input_streams; i++) {
5083 ist = input_streams[i];
5084 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
5085 ist->st->codec->channels > channels) {
5086 channels = ist->st->codec->channels;
5091 new_audio_stream(o, oc, idx);
5094 /* subtitles: pick first */
5095 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
5096 for (i = 0; i < nb_input_streams; i++)
5097 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
5098 new_subtitle_stream(o, oc, i);
5102 /* do something with data? */
5104 for (i = 0; i < o->nb_stream_maps; i++) {
5105 StreamMap *map = &o->stream_maps[i];
5106 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5111 if (map->linklabel) {
5113 OutputFilter *ofilter = NULL;
5116 for (j = 0; j < nb_filtergraphs; j++) {
5117 fg = filtergraphs[j];
5118 for (k = 0; k < fg->nb_outputs; k++) {
5119 AVFilterInOut *out = fg->outputs[k]->out_tmp;
5120 if (out && !strcmp(out->name, map->linklabel)) {
5121 ofilter = fg->outputs[k];
5128 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5129 "in any defined filter graph.\n", map->linklabel);
5132 init_output_filter(ofilter, o, oc);
5134 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5135 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5137 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5139 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5141 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5144 switch (ist->st->codec->codec_type) {
5145 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
5146 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
5147 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
5148 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
5149 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5151 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5152 map->file_index, map->stream_index);
5160 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5161 AVDictionaryEntry *e;
5162 ost = output_streams[i];
5164 if ( ost->stream_copy
5165 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5166 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5167 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5171 /* handle attached files */
5172 for (i = 0; i < o->nb_attachments; i++) {
5174 uint8_t *attachment;
5178 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5179 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5183 if ((len = avio_size(pb)) <= 0) {
5184 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5188 if (!(attachment = av_malloc(len))) {
5189 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5193 avio_read(pb, attachment, len);
5195 ost = new_attachment_stream(o, oc, -1);
5196 ost->stream_copy = 0;
5197 ost->attachment_filename = o->attachments[i];
5198 ost->st->codec->extradata = attachment;
5199 ost->st->codec->extradata_size = len;
5201 p = strrchr(o->attachments[i], '/');
5202 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5206 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5207 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5210 output_files[nb_output_files - 1]->ctx = oc;
5211 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
5212 output_files[nb_output_files - 1]->recording_time = o->recording_time;
5213 if (o->recording_time != INT64_MAX)
5214 oc->duration = o->recording_time;
5215 output_files[nb_output_files - 1]->start_time = o->start_time;
5216 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5217 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5219 /* check filename in case of an image number is expected */
5220 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5221 if (!av_filename_number_test(oc->filename)) {
5222 print_error(oc->filename, AVERROR(EINVAL));
5227 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5228 /* test if it already exists to avoid losing precious files */
5229 assert_file_overwrite(filename);
5232 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5233 &oc->interrupt_callback,
5234 &output_files[nb_output_files - 1]->opts)) < 0) {
5235 print_error(filename, err);
5240 if (o->mux_preload) {
5242 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5243 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5245 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5248 for (i = 0; i < o->nb_metadata_map; i++) {
5250 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5252 if (in_file_index >= nb_input_files) {
5253 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5256 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5260 if (o->chapters_input_file >= nb_input_files) {
5261 if (o->chapters_input_file == INT_MAX) {
5262 /* copy chapters from the first input file that has them*/
5263 o->chapters_input_file = -1;
5264 for (i = 0; i < nb_input_files; i++)
5265 if (input_files[i]->ctx->nb_chapters) {
5266 o->chapters_input_file = i;
5270 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5271 o->chapters_input_file);
5275 if (o->chapters_input_file >= 0)
5276 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5277 !o->metadata_chapters_manual);
5279 /* copy global metadata by default */
5280 if (!o->metadata_global_manual && nb_input_files){
5281 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5282 AV_DICT_DONT_OVERWRITE);
5283 if(o->recording_time != INT64_MAX)
5284 av_dict_set(&oc->metadata, "duration", NULL, 0);
5285 av_dict_set(&oc->metadata, "creation_time", NULL, 0);
5287 if (!o->metadata_streams_manual)
5288 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5290 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
5292 ist = input_streams[output_streams[i]->source_index];
5293 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5296 /* process manually set metadata */
5297 for (i = 0; i < o->nb_metadata; i++) {
5300 const char *stream_spec;
5301 int index = 0, j, ret = 0;
5303 val = strchr(o->metadata[i].u.str, '=');
5305 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5306 o->metadata[i].u.str);
5311 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5313 for (j = 0; j < oc->nb_streams; j++) {
5314 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5315 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5326 if (index < 0 || index >= oc->nb_chapters) {
5327 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5330 m = &oc->chapters[index]->metadata;
5333 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5336 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5340 reset_options(o, 0);
5343 /* same option as mencoder */
5344 static int opt_pass(const char *opt, const char *arg)
5346 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5350 static int64_t getmaxrss(void)
5352 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5353 struct rusage rusage;
5354 getrusage(RUSAGE_SELF, &rusage);
5355 return (int64_t)rusage.ru_maxrss * 1024;
5356 #elif HAVE_GETPROCESSMEMORYINFO
5358 PROCESS_MEMORY_COUNTERS memcounters;
5359 proc = GetCurrentProcess();
5360 memcounters.cb = sizeof(memcounters);
5361 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5362 return memcounters.PeakPagefileUsage;
5368 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5370 return parse_option(o, "q:a", arg, options);
5373 static void show_usage(void)
5375 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5376 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5377 av_log(NULL, AV_LOG_INFO, "\n");
5380 static int opt_help(const char *opt, const char *arg)
5382 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5383 av_log_set_callback(log_callback_help);
5385 show_help_options(options, "Main options:\n",
5386 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5387 show_help_options(options, "\nAdvanced options:\n",
5388 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5390 show_help_options(options, "\nVideo options:\n",
5391 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5393 show_help_options(options, "\nAdvanced Video options:\n",
5394 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5395 OPT_VIDEO | OPT_EXPERT);
5396 show_help_options(options, "\nAudio options:\n",
5397 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5399 show_help_options(options, "\nAdvanced Audio options:\n",
5400 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5401 OPT_AUDIO | OPT_EXPERT);
5402 show_help_options(options, "\nSubtitle options:\n",
5403 OPT_SUBTITLE | OPT_GRAB,
5405 show_help_options(options, "\nAudio/Video grab options:\n",
5409 show_help_children(avcodec_get_class(), flags);
5410 show_help_children(avformat_get_class(), flags);
5411 show_help_children(sws_get_class(), flags);
5412 show_help_children(swr_get_class(), AV_OPT_FLAG_AUDIO_PARAM);
5417 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5419 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5420 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5422 if (!strncmp(arg, "pal-", 4)) {
5425 } else if (!strncmp(arg, "ntsc-", 5)) {
5428 } else if (!strncmp(arg, "film-", 5)) {
5432 /* Try to determine PAL/NTSC by peeking in the input files */
5433 if (nb_input_files) {
5435 for (j = 0; j < nb_input_files; j++) {
5436 for (i = 0; i < input_files[j]->nb_streams; i++) {
5437 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5438 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5440 fr = c->time_base.den * 1000 / c->time_base.num;
5444 } else if ((fr == 29970) || (fr == 23976)) {
5449 if (norm != UNKNOWN)
5453 if (norm != UNKNOWN)
5454 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5457 if (norm == UNKNOWN) {
5458 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5459 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5460 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5464 if (!strcmp(arg, "vcd")) {
5465 opt_video_codec(o, "c:v", "mpeg1video");
5466 opt_audio_codec(o, "c:a", "mp2");
5467 parse_option(o, "f", "vcd", options);
5469 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5470 parse_option(o, "r", frame_rates[norm], options);
5471 opt_default("g", norm == PAL ? "15" : "18");
5473 opt_default("b:v", "1150000");
5474 opt_default("maxrate", "1150000");
5475 opt_default("minrate", "1150000");
5476 opt_default("bufsize", "327680"); // 40*1024*8;
5478 opt_default("b:a", "224000");
5479 parse_option(o, "ar", "44100", options);
5480 parse_option(o, "ac", "2", options);
5482 opt_default("packetsize", "2324");
5483 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5485 /* We have to offset the PTS, so that it is consistent with the SCR.
5486 SCR starts at 36000, but the first two packs contain only padding
5487 and the first pack from the other stream, respectively, may also have
5488 been written before.
5489 So the real data starts at SCR 36000+3*1200. */
5490 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5491 } else if (!strcmp(arg, "svcd")) {
5493 opt_video_codec(o, "c:v", "mpeg2video");
5494 opt_audio_codec(o, "c:a", "mp2");
5495 parse_option(o, "f", "svcd", options);
5497 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5498 parse_option(o, "r", frame_rates[norm], options);
5499 parse_option(o, "pix_fmt", "yuv420p", options);
5500 opt_default("g", norm == PAL ? "15" : "18");
5502 opt_default("b:v", "2040000");
5503 opt_default("maxrate", "2516000");
5504 opt_default("minrate", "0"); // 1145000;
5505 opt_default("bufsize", "1835008"); // 224*1024*8;
5506 opt_default("scan_offset", "1");
5509 opt_default("b:a", "224000");
5510 parse_option(o, "ar", "44100", options);
5512 opt_default("packetsize", "2324");
5514 } else if (!strcmp(arg, "dvd")) {
5516 opt_video_codec(o, "c:v", "mpeg2video");
5517 opt_audio_codec(o, "c:a", "ac3");
5518 parse_option(o, "f", "dvd", options);
5520 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5521 parse_option(o, "r", frame_rates[norm], options);
5522 parse_option(o, "pix_fmt", "yuv420p", options);
5523 opt_default("g", norm == PAL ? "15" : "18");
5525 opt_default("b:v", "6000000");
5526 opt_default("maxrate", "9000000");
5527 opt_default("minrate", "0"); // 1500000;
5528 opt_default("bufsize", "1835008"); // 224*1024*8;
5530 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5531 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5533 opt_default("b:a", "448000");
5534 parse_option(o, "ar", "48000", options);
5536 } else if (!strncmp(arg, "dv", 2)) {
5538 parse_option(o, "f", "dv", options);
5540 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5541 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5542 norm == PAL ? "yuv420p" : "yuv411p", options);
5543 parse_option(o, "r", frame_rates[norm], options);
5545 parse_option(o, "ar", "48000", options);
5546 parse_option(o, "ac", "2", options);
5549 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5550 return AVERROR(EINVAL);
5555 static int opt_vstats_file(const char *opt, const char *arg)
5557 av_free (vstats_filename);
5558 vstats_filename = av_strdup (arg);
5562 static int opt_vstats(const char *opt, const char *arg)
5565 time_t today2 = time(NULL);
5566 struct tm *today = localtime(&today2);
5568 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5570 return opt_vstats_file(opt, filename);
5573 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5575 return parse_option(o, "frames:v", arg, options);
5578 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5580 return parse_option(o, "frames:a", arg, options);
5583 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5585 return parse_option(o, "frames:d", arg, options);
5588 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5591 char filename[1000], line[1000], tmp_line[1000];
5592 const char *codec_name = *opt == 'v' ? video_codec_name :
5593 *opt == 'a' ? audio_codec_name :
5594 subtitle_codec_name;
5596 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5597 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5598 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5600 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5604 while (fgets(line, sizeof(line), f)) {
5605 char *key = tmp_line, *value, *endptr;
5607 if (strcspn(line, "#\n\r") == 0)
5609 strcpy(tmp_line, line);
5610 if (!av_strtok(key, "=", &value) ||
5611 !av_strtok(value, "\r\n", &endptr)) {
5612 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5615 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
5617 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
5618 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
5619 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
5620 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
5621 else if (opt_default(key, value) < 0) {
5622 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
5623 filename, line, key, value);
5633 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5637 static int opt_passlogfile(const char *opt, const char *arg)
5639 pass_logfilename_prefix = arg;
5640 #if CONFIG_LIBX264_ENCODER
5641 return opt_default(opt, arg);
5647 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5649 char *s = av_asprintf("%s:%c", opt + 1, *opt);
5650 int ret = parse_option(o, s, arg, options);
5655 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5657 if(!strcmp(opt, "b")){
5658 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5659 return parse_option(o, "b:v", arg, options);
5661 return opt_default(opt, arg);
5664 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5668 if(!strcmp(opt, "qscale")){
5669 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5670 return parse_option(o, "q:v", arg, options);
5672 s = av_asprintf("q%s", opt + 6);
5673 ret = parse_option(o, s, arg, options);
5678 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5680 if(!strcmp(opt, "profile")){
5681 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5682 return parse_option(o, "profile:v", arg, options);
5684 return opt_default(opt, arg);
5687 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5689 return parse_option(o, "filter:v", arg, options);
5692 static int opt_audio_filters(OptionsContext *o, const char *opt, const char *arg)
5694 return parse_option(o, "filter:a", arg, options);
5697 static int opt_vsync(const char *opt, const char *arg)
5699 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
5700 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
5701 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5702 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
5704 if (video_sync_method == VSYNC_AUTO)
5705 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5709 static int opt_deinterlace(const char *opt, const char *arg)
5711 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5716 static int opt_timecode(OptionsContext *o, const char *opt, const char *arg)
5718 char *tcr = av_asprintf("timecode=%s", arg);
5719 int ret = parse_option(o, "metadata:g", tcr, options);
5721 ret = opt_default("gop_timecode", arg);
5726 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5728 int idx = locate_option(argc, argv, options, "cpuflags");
5729 if (idx && argv[idx + 1])
5730 opt_cpuflags("cpuflags", argv[idx + 1]);
5733 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5735 char layout_str[32];
5738 int ret, channels, ac_str_size;
5741 layout = av_get_channel_layout(arg);
5743 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5744 return AVERROR(EINVAL);
5746 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5747 ret = opt_default(opt, layout_str);
5751 /* set 'ac' option based on channel layout */
5752 channels = av_get_channel_layout_nb_channels(layout);
5753 snprintf(layout_str, sizeof(layout_str), "%d", channels);
5754 stream_str = strchr(opt, ':');
5755 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5756 ac_str = av_mallocz(ac_str_size);
5758 return AVERROR(ENOMEM);
5759 av_strlcpy(ac_str, "ac", 3);
5761 av_strlcat(ac_str, stream_str, ac_str_size);
5762 ret = parse_option(o, ac_str, layout_str, options);
5768 static int opt_filter_complex(const char *opt, const char *arg)
5770 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5771 &nb_filtergraphs, nb_filtergraphs + 1);
5772 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5773 return AVERROR(ENOMEM);
5774 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
5775 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5779 #define OFFSET(x) offsetof(OptionsContext, x)
5780 static const OptionDef options[] = {
5782 #include "cmdutils_common_opts.h"
5783 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5784 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5785 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5786 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5787 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5788 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5789 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5790 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5791 { "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]" },
5792 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5793 "outfile[,metadata]:infile[,metadata]" },
5794 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
5795 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5796 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5797 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5798 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5799 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5800 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5801 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5802 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5803 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5804 "add timings for benchmarking" },
5805 { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5806 "add timings for each task" },
5807 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5808 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5809 "dump each input packet" },
5810 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5811 "when dumping packets, also dump the payload" },
5812 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5813 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5814 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5815 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5816 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5817 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
5818 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
5819 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5820 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5821 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5822 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5823 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5824 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5825 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5826 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5827 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5828 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5829 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5830 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5831 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5832 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5833 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5834 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5837 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5838 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5839 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5840 { "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" },
5841 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5842 { "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" },
5843 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5844 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5845 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5846 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5847 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5848 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5849 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5850 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5851 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5852 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5853 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5854 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5855 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5856 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5857 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5858 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5859 "use same quantizer as source (implies VBR)" },
5860 { "timecode", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_timecode}, "set initial TimeCode value.", "hh:mm:ss[:;.]ff" },
5861 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5862 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5863 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5864 "this option is deprecated, use the yadif filter instead" },
5865 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5866 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5867 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5868 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5869 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5870 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5871 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5872 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5873 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5874 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5875 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5876 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5877 { "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" },
5878 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5881 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5882 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5883 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5884 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5885 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5886 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5887 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5888 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5889 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5890 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5891 { "af", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_filters}, "audio filters", "filter list" },
5893 /* subtitle options */
5894 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5895 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5896 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5899 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5900 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5901 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5904 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5905 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5907 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5908 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5909 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5911 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5912 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5913 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5914 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5915 /* data codec support */
5916 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5917 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5919 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5923 int main(int argc, char **argv)
5925 OptionsContext o = { 0 };
5928 reset_options(&o, 0);
5930 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5931 parse_loglevel(argc, argv, options);
5933 if(argc>1 && !strcmp(argv[1], "-d")){
5935 av_log_set_callback(log_callback_null);
5940 avcodec_register_all();
5942 avdevice_register_all();
5944 avfilter_register_all();
5946 avformat_network_init();
5948 show_banner(argc, argv, options);
5952 parse_cpuflags(argc, argv, options);
5955 parse_options(&o, argc, argv, options, opt_output_file);
5957 if (nb_output_files <= 0 && nb_input_files == 0) {
5959 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5963 /* file converter / grab */
5964 if (nb_output_files <= 0) {
5965 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5969 if (nb_input_files == 0) {
5970 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5974 current_time = ti = getutime();
5975 if (transcode() < 0)
5977 ti = getutime() - ti;
5979 int maxrss = getmaxrss() / 1024;
5980 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);