2 * Copyright (c) 2000-2003 Fabrice Bellard
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * multimedia converter based on the FFmpeg libraries
35 #include "libavformat/avformat.h"
36 #include "libavdevice/avdevice.h"
37 #include "libswscale/swscale.h"
38 #include "libavutil/opt.h"
39 #include "libavutil/audioconvert.h"
40 #include "libavutil/parseutils.h"
41 #include "libavutil/samplefmt.h"
42 #include "libavutil/colorspace.h"
43 #include "libavutil/fifo.h"
44 #include "libavutil/intreadwrite.h"
45 #include "libavutil/dict.h"
46 #include "libavutil/mathematics.h"
47 #include "libavutil/pixdesc.h"
48 #include "libavutil/avstring.h"
49 #include "libavutil/libm.h"
50 #include "libavutil/imgutils.h"
51 #include "libavutil/timestamp.h"
52 #include "libavformat/os_support.h"
53 #include "libswresample/swresample.h"
55 #include "libavformat/ffm.h" // not public API
57 # include "libavfilter/avcodec.h"
58 # include "libavfilter/avfilter.h"
59 # include "libavfilter/avfiltergraph.h"
60 # include "libavfilter/buffersink.h"
61 # include "libavfilter/buffersrc.h"
63 #if HAVE_SYS_RESOURCE_H
64 #include <sys/types.h>
66 #include <sys/resource.h>
67 #elif HAVE_GETPROCESSTIMES
70 #if HAVE_GETPROCESSMEMORYINFO
76 #include <sys/select.h>
81 #include <sys/ioctl.h>
91 #include "libavutil/avassert.h"
94 #define VSYNC_PASSTHROUGH 0
97 #define VSYNC_DROP 0xff
99 const char program_name[] = "ffmpeg";
100 const int program_birth_year = 2000;
102 /* select an input stream for an output stream */
103 typedef struct StreamMap {
104 int disabled; /** 1 is this mapping is disabled by a negative map */
108 int sync_stream_index;
109 char *linklabel; /** name of an output link, for mapping lavfi outputs */
113 int file_idx, stream_idx, channel_idx; // input
114 int ofile_idx, ostream_idx; // output
117 static const OptionDef options[];
119 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
121 static int frame_bits_per_raw_sample = 0;
122 static int video_discard = 0;
123 static int same_quant = 0;
124 static int do_deinterlace = 0;
125 static int intra_dc_precision = 8;
126 static int qp_hist = 0;
127 static int intra_only = 0;
128 static const char *video_codec_name = NULL;
129 static const char *audio_codec_name = NULL;
130 static const char *subtitle_codec_name = NULL;
132 static int file_overwrite = 0;
133 static int no_file_overwrite = 0;
134 static int do_benchmark = 0;
135 static int do_benchmark_all = 0;
136 static int do_hex_dump = 0;
137 static int do_pkt_dump = 0;
138 static int do_psnr = 0;
139 static int do_pass = 0;
140 static const char *pass_logfilename_prefix;
141 static int video_sync_method = VSYNC_AUTO;
142 static int audio_sync_method = 0;
143 static float audio_drift_threshold = 0.1;
144 static int copy_ts = 0;
145 static int copy_tb = -1;
146 static int opt_shortest = 0;
147 static char *vstats_filename;
148 static FILE *vstats_file;
150 static int audio_volume = 256;
152 static int exit_on_error = 0;
153 static int using_stdin = 0;
154 static int run_as_daemon = 0;
155 static volatile int received_nb_signals = 0;
156 static int64_t video_size = 0;
157 static int64_t audio_size = 0;
158 static int64_t extra_size = 0;
159 static int nb_frames_dup = 0;
160 static int nb_frames_drop = 0;
161 static int input_sync;
163 static float dts_delta_threshold = 10;
164 static float dts_error_threshold = 3600*30;
166 static int print_stats = 1;
167 static int debug_ts = 0;
168 static int current_time;
170 static uint8_t *audio_buf;
171 static unsigned int allocated_audio_buf_size;
172 static uint8_t *async_buf;
173 static unsigned int allocated_async_buf_size;
175 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
177 typedef struct InputFilter {
178 AVFilterContext *filter;
179 struct InputStream *ist;
180 struct FilterGraph *graph;
183 typedef struct OutputFilter {
184 AVFilterContext *filter;
185 struct OutputStream *ost;
186 struct FilterGraph *graph;
188 /* temporary storage until stream maps are processed */
189 AVFilterInOut *out_tmp;
192 typedef struct FilterGraph {
194 const char *graph_desc;
196 AVFilterGraph *graph;
198 InputFilter **inputs;
200 OutputFilter **outputs;
204 typedef struct FrameBuffer {
210 enum PixelFormat pix_fmt;
213 struct InputStream *ist;
214 struct FrameBuffer *next;
217 typedef struct InputStream {
220 int discard; /* true if stream data should be discarded */
221 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
223 AVFrame *decoded_frame;
225 int64_t start; /* time when read started */
226 /* predicted dts of the next packet read for this stream or (when there are
227 * several frames in a packet) of the next frame in current packet */
229 /* dts of the last packet read for this stream */
232 int64_t next_pts; ///< synthetic pts for the next decode frame
233 int64_t pts; ///< current pts of the decoded frame
235 int is_start; /* is 1 at the start and after a discontinuity */
237 int showed_multi_packet_warning;
242 int resample_pix_fmt;
244 /* a pool of free buffers for decoded data */
245 FrameBuffer *buffer_pool;
248 /* decoded data from this stream goes into all those filters
249 * currently video only */
250 InputFilter **filters;
254 typedef struct InputFile {
255 AVFormatContext *ctx;
256 int eof_reached; /* true if eof reached */
257 int ist_index; /* index of first stream in input_streams */
258 int buffer_size; /* current total buffer size */
260 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
261 from ctx.nb_streams if new streams appear during av_read_frame() */
265 typedef struct OutputStream {
266 int file_index; /* file index */
267 int index; /* stream index in the output file */
268 int source_index; /* InputStream index */
269 AVStream *st; /* stream in the output file */
270 int encoding_needed; /* true if encoding needed for this stream */
272 /* input pts and corresponding output pts
274 struct InputStream *sync_ist; /* input stream to sync against */
275 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
276 AVBitStreamFilterContext *bitstream_filters;
279 AVFrame *output_frame;
280 AVFrame *filtered_frame;
283 AVRational frame_rate;
287 float frame_aspect_ratio;
290 /* forced key frames */
291 int64_t *forced_kf_pts;
297 int audio_channels_map[SWR_CH_MAX]; ///< list of the channels id to pick from the source stream
298 int audio_channels_mapped; ///< number of channels in audio_channels_map
299 int resample_sample_fmt;
300 int resample_channels;
301 uint64_t resample_channel_layout;
302 int resample_sample_rate;
303 float rematrix_volume;
304 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
309 OutputFilter *filter;
313 int64_t swr_dither_method;
314 double swr_dither_scale;
316 int is_past_recording_time;
318 const char *attachment_filename;
319 int copy_initial_nonkeyframes;
321 enum PixelFormat pix_fmts[2];
327 /* init terminal so that we can grab keys */
328 static struct termios oldtty;
329 static int restore_tty;
332 typedef struct OutputFile {
333 AVFormatContext *ctx;
335 int ost_index; /* index of the first stream in output_streams */
336 int64_t recording_time; /* desired length of the resulting file in microseconds */
337 int64_t start_time; /* start time in microseconds */
338 uint64_t limit_filesize; /* filesize limit expressed in bytes */
341 static InputStream **input_streams = NULL;
342 static int nb_input_streams = 0;
343 static InputFile **input_files = NULL;
344 static int nb_input_files = 0;
346 static OutputStream **output_streams = NULL;
347 static int nb_output_streams = 0;
348 static OutputFile **output_files = NULL;
349 static int nb_output_files = 0;
351 static FilterGraph **filtergraphs;
354 typedef struct OptionsContext {
355 /* input/output options */
359 SpecifierOpt *codec_names;
361 SpecifierOpt *audio_channels;
362 int nb_audio_channels;
363 SpecifierOpt *audio_sample_rate;
364 int nb_audio_sample_rate;
365 SpecifierOpt *rematrix_volume;
366 int nb_rematrix_volume;
367 SpecifierOpt *frame_rates;
369 SpecifierOpt *frame_sizes;
371 SpecifierOpt *frame_pix_fmts;
372 int nb_frame_pix_fmts;
375 int64_t input_ts_offset;
378 SpecifierOpt *ts_scale;
380 SpecifierOpt *dump_attachment;
381 int nb_dump_attachment;
384 StreamMap *stream_maps;
386 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
387 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
388 int metadata_global_manual;
389 int metadata_streams_manual;
390 int metadata_chapters_manual;
391 const char **attachments;
394 int chapters_input_file;
396 int64_t recording_time;
397 uint64_t limit_filesize;
403 int subtitle_disable;
406 /* indexed by output file stream index */
410 SpecifierOpt *metadata;
412 SpecifierOpt *max_frames;
414 SpecifierOpt *bitstream_filters;
415 int nb_bitstream_filters;
416 SpecifierOpt *codec_tags;
418 SpecifierOpt *sample_fmts;
420 SpecifierOpt *qscale;
422 SpecifierOpt *forced_key_frames;
423 int nb_forced_key_frames;
424 SpecifierOpt *force_fps;
426 SpecifierOpt *frame_aspect_ratios;
427 int nb_frame_aspect_ratios;
428 SpecifierOpt *rc_overrides;
430 SpecifierOpt *intra_matrices;
431 int nb_intra_matrices;
432 SpecifierOpt *inter_matrices;
433 int nb_inter_matrices;
434 SpecifierOpt *top_field_first;
435 int nb_top_field_first;
436 SpecifierOpt *metadata_map;
438 SpecifierOpt *presets;
440 SpecifierOpt *copy_initial_nonkeyframes;
441 int nb_copy_initial_nonkeyframes;
442 SpecifierOpt *filters;
446 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
449 for (i = 0; i < o->nb_ ## name; i++) {\
450 char *spec = o->name[i].specifier;\
451 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
452 outvar = o->name[i].u.type;\
458 static int64_t getutime(void)
461 struct rusage rusage;
463 getrusage(RUSAGE_SELF, &rusage);
464 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
465 #elif HAVE_GETPROCESSTIMES
468 proc = GetCurrentProcess();
469 GetProcessTimes(proc, &c, &e, &k, &u);
470 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
476 static void update_benchmark(const char *fmt, ...)
478 if (do_benchmark_all) {
479 int64_t t = getutime();
485 vsnprintf(buf, sizeof(buf), fmt, va);
487 printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
493 static void reset_options(OptionsContext *o, int is_input)
495 const OptionDef *po = options;
496 OptionsContext bak= *o;
499 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
501 void *dst = (uint8_t*)o + po->u.off;
503 if (po->flags & OPT_SPEC) {
504 SpecifierOpt **so = dst;
505 int i, *count = (int*)(so + 1);
506 for (i = 0; i < *count; i++) {
507 av_freep(&(*so)[i].specifier);
508 if (po->flags & OPT_STRING)
509 av_freep(&(*so)[i].u.str);
513 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
518 for (i = 0; i < o->nb_stream_maps; i++)
519 av_freep(&o->stream_maps[i].linklabel);
520 av_freep(&o->stream_maps);
521 av_freep(&o->audio_channel_maps);
522 av_freep(&o->streamid_map);
524 memset(o, 0, sizeof(*o));
526 if(is_input) o->recording_time = bak.recording_time;
527 else o->recording_time = INT64_MAX;
528 o->mux_max_delay = 0.7;
529 o->limit_filesize = UINT64_MAX;
530 o->chapters_input_file = INT_MAX;
536 static int alloc_buffer(InputStream *ist, AVCodecContext *s, FrameBuffer **pbuf)
538 FrameBuffer *buf = av_mallocz(sizeof(*buf));
540 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
541 int h_chroma_shift, v_chroma_shift;
542 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
543 int w = s->width, h = s->height;
546 return AVERROR(ENOMEM);
548 avcodec_align_dimensions(s, &w, &h);
550 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
555 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
556 s->pix_fmt, 32)) < 0) {
560 /* XXX this shouldn't be needed, but some tests break without this line
561 * those decoders are buggy and need to be fixed.
562 * the following tests fail:
563 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
565 memset(buf->base[0], 128, ret);
567 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
568 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
569 const int h_shift = i==0 ? 0 : h_chroma_shift;
570 const int v_shift = i==0 ? 0 : v_chroma_shift;
571 if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1] || !buf->base[i])
572 buf->data[i] = buf->base[i];
574 buf->data[i] = buf->base[i] +
575 FFALIGN((buf->linesize[i]*edge >> v_shift) +
576 (pixel_size*edge >> h_shift), 32);
580 buf->pix_fmt = s->pix_fmt;
587 static void free_buffer_pool(InputStream *ist)
589 FrameBuffer *buf = ist->buffer_pool;
591 ist->buffer_pool = buf->next;
592 av_freep(&buf->base[0]);
594 buf = ist->buffer_pool;
598 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
600 av_assert0(buf->refcount > 0);
602 if (!buf->refcount) {
604 for(tmp= ist->buffer_pool; tmp; tmp= tmp->next)
605 av_assert1(tmp != buf);
606 buf->next = ist->buffer_pool;
607 ist->buffer_pool = buf;
611 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
613 InputStream *ist = s->opaque;
617 if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0)
620 if (!ist->buffer_pool && (ret = alloc_buffer(ist, s, &ist->buffer_pool)) < 0)
623 buf = ist->buffer_pool;
624 ist->buffer_pool = buf->next;
626 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
627 av_freep(&buf->base[0]);
629 if ((ret = alloc_buffer(ist, s, &buf)) < 0)
632 av_assert0(!buf->refcount);
636 frame->type = FF_BUFFER_TYPE_USER;
637 frame->extended_data = frame->data;
638 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
639 frame->width = buf->w;
640 frame->height = buf->h;
641 frame->format = buf->pix_fmt;
642 frame->sample_aspect_ratio = s->sample_aspect_ratio;
644 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
645 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
646 frame->data[i] = buf->data[i];
647 frame->linesize[i] = buf->linesize[i];
653 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
655 InputStream *ist = s->opaque;
656 FrameBuffer *buf = frame->opaque;
659 if(frame->type!=FF_BUFFER_TYPE_USER)
660 return avcodec_default_release_buffer(s, frame);
662 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
663 frame->data[i] = NULL;
665 unref_buffer(ist, buf);
668 static void filter_release_buffer(AVFilterBuffer *fb)
670 FrameBuffer *buf = fb->priv;
672 unref_buffer(buf->ist, buf);
675 static enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target)
677 if (codec && codec->pix_fmts) {
678 const enum PixelFormat *p = codec->pix_fmts;
679 int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0;
680 enum PixelFormat best= PIX_FMT_NONE;
681 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
682 if (st->codec->codec_id == CODEC_ID_MJPEG) {
683 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
684 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
685 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
686 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
689 for (; *p != PIX_FMT_NONE; p++) {
690 best= avcodec_find_best_pix_fmt2(best, *p, target, has_alpha, NULL);
694 if (*p == PIX_FMT_NONE) {
695 if (target != PIX_FMT_NONE)
696 av_log(NULL, AV_LOG_WARNING,
697 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
698 av_pix_fmt_descriptors[target].name,
700 av_pix_fmt_descriptors[best].name);
707 static const enum PixelFormat *choose_pixel_fmts(OutputStream *ost)
709 if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
710 ost->pix_fmts[0] = choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt);
711 return ost->pix_fmts;
712 } else if (ost->enc->pix_fmts) {
713 if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
714 if (ost->st->codec->codec_id == CODEC_ID_MJPEG) {
715 return (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
716 } else if (ost->st->codec->codec_id == CODEC_ID_LJPEG) {
717 return (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
718 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
721 return ost->enc->pix_fmts;
726 static int configure_video_filters(FilterGraph *fg)
728 InputStream *ist = fg->inputs[0]->ist;
729 OutputStream *ost = fg->outputs[0]->ost;
730 AVFilterContext *last_filter, *filter;
731 AVCodecContext *codec = ost->st->codec;
732 enum PixelFormat *pix_fmts = choose_pixel_fmts(ost);
733 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
734 AVRational sample_aspect_ratio;
738 avfilter_graph_free(&fg->graph);
739 fg->graph = avfilter_graph_alloc();
741 return AVERROR(ENOMEM);
743 if (ist->st->sample_aspect_ratio.num) {
744 sample_aspect_ratio = ist->st->sample_aspect_ratio;
746 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
748 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,
749 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
750 sample_aspect_ratio.num, sample_aspect_ratio.den, SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
752 ret = avfilter_graph_create_filter(&fg->inputs[0]->filter,
753 avfilter_get_by_name("buffer"),
754 "src", args, NULL, fg->graph);
758 #if FF_API_OLD_VSINK_API
759 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),
760 "out", NULL, pix_fmts, fg->graph);
762 buffersink_params->pixel_fmts = pix_fmts;
763 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),
764 "out", NULL, buffersink_params, fg->graph);
766 av_freep(&buffersink_params);
770 last_filter = fg->inputs[0]->filter;
772 if (codec->width || codec->height) {
773 snprintf(args, 255, "%d:%d:flags=0x%X",
776 (unsigned)ost->sws_flags);
777 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
778 NULL, args, NULL, fg->graph)) < 0)
780 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
782 last_filter = filter;
785 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
786 fg->graph->scale_sws_opts = av_strdup(args);
789 AVFilterInOut *outputs = avfilter_inout_alloc();
790 AVFilterInOut *inputs = avfilter_inout_alloc();
792 outputs->name = av_strdup("in");
793 outputs->filter_ctx = last_filter;
794 outputs->pad_idx = 0;
795 outputs->next = NULL;
797 inputs->name = av_strdup("out");
798 inputs->filter_ctx = fg->outputs[0]->filter;
802 if ((ret = avfilter_graph_parse(fg->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
804 av_freep(&ost->avfilter);
806 if ((ret = avfilter_link(last_filter, 0, fg->outputs[0]->filter, 0)) < 0)
810 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
813 ost->filter = fg->outputs[0];
818 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
820 FilterGraph *fg = av_mallocz(sizeof(*fg));
824 fg->index = nb_filtergraphs;
826 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
828 if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
830 fg->outputs[0]->ost = ost;
831 fg->outputs[0]->graph = fg;
833 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
835 if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
837 fg->inputs[0]->ist = ist;
838 fg->inputs[0]->graph = fg;
840 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
841 &ist->nb_filters, ist->nb_filters + 1);
842 ist->filters[ist->nb_filters - 1] = fg->inputs[0];
844 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
845 &nb_filtergraphs, nb_filtergraphs + 1);
846 filtergraphs[nb_filtergraphs - 1] = fg;
851 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
854 enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
857 // TODO: support other filter types
858 if (type != AVMEDIA_TYPE_VIDEO) {
859 av_log(NULL, AV_LOG_FATAL, "Only video filters supported currently.\n");
867 int file_idx = strtol(in->name, &p, 0);
869 if (file_idx < 0 || file_idx >= nb_input_files) {
870 av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n",
871 file_idx, fg->graph_desc);
874 s = input_files[file_idx]->ctx;
876 for (i = 0; i < s->nb_streams; i++) {
877 if (s->streams[i]->codec->codec_type != type)
879 if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
885 av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
886 "matches no streams.\n", p, fg->graph_desc);
889 ist = input_streams[input_files[file_idx]->ist_index + st->index];
891 /* find the first unused stream of corresponding type */
892 for (i = 0; i < nb_input_streams; i++) {
893 ist = input_streams[i];
894 if (ist->st->codec->codec_type == type && ist->discard)
897 if (i == nb_input_streams) {
898 av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
899 "unlabeled input pad %d on filter %s", in->pad_idx,
900 in->filter_ctx->name);
905 ist->decoding_needed = 1;
906 ist->st->discard = AVDISCARD_NONE;
908 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
909 &fg->nb_inputs, fg->nb_inputs + 1);
910 if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
912 fg->inputs[fg->nb_inputs - 1]->ist = ist;
913 fg->inputs[fg->nb_inputs - 1]->graph = fg;
915 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
916 &ist->nb_filters, ist->nb_filters + 1);
917 ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
920 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
922 AVCodecContext *codec = ofilter->ost->st->codec;
923 AVFilterContext *last_filter = out->filter_ctx;
924 int pad_idx = out->pad_idx;
926 enum PixelFormat *pix_fmts = choose_pixel_fmts(ofilter->ost);
927 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
929 #if FF_API_OLD_VSINK_API
930 ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),
931 "out", NULL, pix_fmts, fg->graph);
933 buffersink_params->pixel_fmts = pix_fmts;
934 ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),
935 "out", NULL, buffersink_params, fg->graph);
937 av_freep(&buffersink_params);
942 if (codec->width || codec->height) {
944 snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
947 (unsigned)ofilter->ost->sws_flags);
948 if ((ret = avfilter_graph_create_filter(&last_filter, avfilter_get_by_name("scale"),
949 NULL, args, NULL, fg->graph)) < 0)
951 if ((ret = avfilter_link(out->filter_ctx, out->pad_idx, last_filter, 0)) < 0)
956 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
962 static int configure_complex_filter(FilterGraph *fg)
964 AVFilterInOut *inputs, *outputs, *cur;
965 int ret, i, init = !fg->graph;
967 avfilter_graph_free(&fg->graph);
968 if (!(fg->graph = avfilter_graph_alloc()))
969 return AVERROR(ENOMEM);
971 if ((ret = avfilter_graph_parse2(fg->graph, fg->graph_desc, &inputs, &outputs)) < 0)
974 for (cur = inputs; init && cur; cur = cur->next)
975 init_input_filter(fg, cur);
977 for (cur = inputs, i = 0; cur; cur = cur->next, i++) {
978 InputFilter *ifilter = fg->inputs[i];
979 InputStream *ist = ifilter->ist;
983 sar = ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
984 ist->st->codec->sample_aspect_ratio;
985 snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
986 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
989 if ((ret = avfilter_graph_create_filter(&ifilter->filter,
990 avfilter_get_by_name("buffer"), cur->name,
991 args, NULL, fg->graph)) < 0)
993 if ((ret = avfilter_link(ifilter->filter, 0,
994 cur->filter_ctx, cur->pad_idx)) < 0)
997 avfilter_inout_free(&inputs);
1000 /* we already know the mappings between lavfi outputs and output streams,
1001 * so we can finish the setup */
1002 for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1003 configure_output_filter(fg, fg->outputs[i], cur);
1004 avfilter_inout_free(&outputs);
1006 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1009 /* wait until output mappings are processed */
1010 for (cur = outputs; cur;) {
1011 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1012 &fg->nb_outputs, fg->nb_outputs + 1);
1013 if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1015 fg->outputs[fg->nb_outputs - 1]->graph = fg;
1016 fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1018 fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1025 static int configure_complex_filters(void)
1029 for (i = 0; i < nb_filtergraphs; i++)
1030 if (!filtergraphs[i]->graph &&
1031 (ret = configure_complex_filter(filtergraphs[i])) < 0)
1036 static int configure_filtergraph(FilterGraph *fg)
1038 return fg->graph_desc ? configure_complex_filter(fg) : configure_video_filters(fg);
1041 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1044 for (i = 0; i < fg->nb_inputs; i++)
1045 if (fg->inputs[i]->ist == ist)
1050 static void term_exit(void)
1052 av_log(NULL, AV_LOG_QUIET, "%s", "");
1055 tcsetattr (0, TCSANOW, &oldtty);
1059 static volatile int received_sigterm = 0;
1061 static void sigterm_handler(int sig)
1063 received_sigterm = sig;
1064 received_nb_signals++;
1066 if(received_nb_signals > 3)
1070 static void term_init(void)
1076 if (tcgetattr (0, &tty) == 0) {
1081 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1082 |INLCR|IGNCR|ICRNL|IXON);
1083 tty.c_oflag |= OPOST;
1084 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1085 tty.c_cflag &= ~(CSIZE|PARENB);
1088 tty.c_cc[VTIME] = 0;
1090 tcsetattr (0, TCSANOW, &tty);
1092 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
1095 avformat_network_deinit();
1097 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
1098 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
1100 signal(SIGXCPU, sigterm_handler);
1104 /* read a key without blocking */
1105 static int read_key(void)
1117 n = select(1, &rfds, NULL, NULL, &tv);
1119 n = read(0, &ch, 1);
1126 # if HAVE_PEEKNAMEDPIPE
1128 static HANDLE input_handle;
1131 input_handle = GetStdHandle(STD_INPUT_HANDLE);
1132 is_pipe = !GetConsoleMode(input_handle, &dw);
1135 if (stdin->_cnt > 0) {
1140 /* When running under a GUI, you will end here. */
1141 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
1158 static int decode_interrupt_cb(void *ctx)
1160 return received_nb_signals > 1;
1163 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1165 void av_noreturn exit_program(int ret)
1169 for (i = 0; i < nb_filtergraphs; i++) {
1170 avfilter_graph_free(&filtergraphs[i]->graph);
1171 for (j = 0; j < filtergraphs[i]->nb_inputs; j++)
1172 av_freep(&filtergraphs[i]->inputs[j]);
1173 av_freep(&filtergraphs[i]->inputs);
1174 for (j = 0; j < filtergraphs[i]->nb_outputs; j++)
1175 av_freep(&filtergraphs[i]->outputs[j]);
1176 av_freep(&filtergraphs[i]->outputs);
1177 av_freep(&filtergraphs[i]);
1179 av_freep(&filtergraphs);
1182 for (i = 0; i < nb_output_files; i++) {
1183 AVFormatContext *s = output_files[i]->ctx;
1184 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1186 avformat_free_context(s);
1187 av_dict_free(&output_files[i]->opts);
1188 av_freep(&output_files[i]);
1190 for (i = 0; i < nb_output_streams; i++) {
1191 AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1193 AVBitStreamFilterContext *next = bsfc->next;
1194 av_bitstream_filter_close(bsfc);
1197 output_streams[i]->bitstream_filters = NULL;
1199 if (output_streams[i]->output_frame) {
1200 AVFrame *frame = output_streams[i]->output_frame;
1201 if (frame->extended_data != frame->data)
1202 av_freep(&frame->extended_data);
1205 av_freep(&output_streams[i]->filtered_frame);
1206 av_freep(&output_streams[i]);
1208 for (i = 0; i < nb_input_files; i++) {
1209 avformat_close_input(&input_files[i]->ctx);
1210 av_freep(&input_files[i]);
1212 for (i = 0; i < nb_input_streams; i++) {
1213 av_freep(&input_streams[i]->decoded_frame);
1214 av_dict_free(&input_streams[i]->opts);
1215 free_buffer_pool(input_streams[i]);
1216 av_freep(&input_streams[i]->filters);
1217 av_freep(&input_streams[i]);
1221 fclose(vstats_file);
1222 av_free(vstats_filename);
1224 av_freep(&input_streams);
1225 av_freep(&input_files);
1226 av_freep(&output_streams);
1227 av_freep(&output_files);
1230 av_freep(&audio_buf);
1231 allocated_audio_buf_size = 0;
1232 av_freep(&async_buf);
1233 allocated_async_buf_size = 0;
1236 avformat_network_deinit();
1238 if (received_sigterm) {
1239 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1240 (int) received_sigterm);
1244 exit(ret); /* not all OS-es handle main() return value */
1247 static void assert_avoptions(AVDictionary *m)
1249 AVDictionaryEntry *t;
1250 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1251 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1256 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1258 const char *codec_string = encoder ? "encoder" : "decoder";
1260 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1261 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1262 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1263 "results.\nAdd '-strict experimental' if you want to use it.\n",
1264 codec_string, c->codec->name);
1265 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1266 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1267 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1268 codec_string, codec->name);
1273 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
1275 if (codec && codec->sample_fmts) {
1276 const enum AVSampleFormat *p = codec->sample_fmts;
1277 for (; *p != -1; p++) {
1278 if (*p == st->codec->sample_fmt)
1282 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
1283 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
1284 if(av_get_sample_fmt_name(st->codec->sample_fmt))
1285 av_log(NULL, AV_LOG_WARNING,
1286 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
1287 av_get_sample_fmt_name(st->codec->sample_fmt),
1289 av_get_sample_fmt_name(codec->sample_fmts[0]));
1290 st->codec->sample_fmt = codec->sample_fmts[0];
1295 static void choose_sample_rate(AVStream *st, AVCodec *codec)
1297 if (codec && codec->supported_samplerates) {
1298 const int *p = codec->supported_samplerates;
1300 int best_dist = INT_MAX;
1302 int dist = abs(st->codec->sample_rate - *p);
1303 if (dist < best_dist) {
1310 const int *sample_rates = codec->supported_samplerates;
1311 av_log(st->codec, AV_LOG_WARNING,
1312 "Requested sampling rate (%dHz) unsupported, using %dHz instead\n"
1313 "Available sampling rates for %s:",
1314 st->codec->sample_rate, best, codec->name);
1315 for (i = 0; sample_rates[i]; i++) {
1316 if (!sample_rates[i + 1]) av_log(st->codec, AV_LOG_WARNING, " and");
1317 else if (i) av_log(st->codec, AV_LOG_WARNING, ",");
1318 av_log(st->codec, AV_LOG_WARNING, " %d", sample_rates[i]);
1320 av_log(st->codec, AV_LOG_WARNING, ".\n");
1322 st->codec->sample_rate = best;
1327 get_sync_ipts(const OutputStream *ost, int64_t pts)
1329 OutputFile *of = output_files[ost->file_index];
1330 return (double)(pts - of->start_time) / AV_TIME_BASE;
1333 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1335 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1336 AVCodecContext *avctx = ost->st->codec;
1339 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1340 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1341 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1344 * Audio encoders may split the packets -- #frames in != #packets out.
1345 * But there is no reordering, so we can limit the number of output packets
1346 * by simply dropping them here.
1347 * Counting encoded video frames needs to be done separately because of
1348 * reordering, see do_video_out()
1350 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1351 if (ost->frame_number >= ost->max_frames) {
1352 av_free_packet(pkt);
1355 ost->frame_number++;
1359 AVPacket new_pkt = *pkt;
1360 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1361 &new_pkt.data, &new_pkt.size,
1362 pkt->data, pkt->size,
1363 pkt->flags & AV_PKT_FLAG_KEY);
1365 av_free_packet(pkt);
1366 new_pkt.destruct = av_destruct_packet;
1368 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1369 bsfc->filter->name, pkt->stream_index,
1370 avctx->codec ? avctx->codec->name : "copy");
1380 pkt->stream_index = ost->index;
1381 ret = av_interleaved_write_frame(s, pkt);
1383 print_error("av_interleaved_write_frame()", ret);
1388 static void get_default_channel_layouts(OutputStream *ost, InputStream *ist)
1390 char layout_name[256];
1391 AVCodecContext *enc = ost->st->codec;
1392 AVCodecContext *dec = ist->st->codec;
1394 if (dec->channel_layout &&
1395 av_get_channel_layout_nb_channels(dec->channel_layout) != dec->channels) {
1396 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1397 dec->channels, dec->channel_layout);
1398 av_log(NULL, AV_LOG_ERROR, "New channel layout (%s) is invalid\n",
1400 dec->channel_layout = 0;
1402 if (!dec->channel_layout) {
1403 if (enc->channel_layout && dec->channels == enc->channels) {
1404 dec->channel_layout = enc->channel_layout;
1406 dec->channel_layout = av_get_default_channel_layout(dec->channels);
1408 if (!dec->channel_layout) {
1409 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1410 "layout for Input Stream #%d.%d\n", ist->file_index,
1415 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1416 dec->channels, dec->channel_layout);
1417 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
1418 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1420 if (!enc->channel_layout) {
1421 if (dec->channels == enc->channels) {
1422 enc->channel_layout = dec->channel_layout;
1425 enc->channel_layout = av_get_default_channel_layout(enc->channels);
1427 if (!enc->channel_layout) {
1428 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel layout "
1429 "for Output Stream #%d.%d\n", ost->file_index,
1433 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1434 enc->channels, enc->channel_layout);
1435 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Output Stream "
1436 "#%d.%d : %s\n", ost->file_index, ost->st->index, layout_name);
1440 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1442 int fill_char = 0x00;
1443 if (sample_fmt == AV_SAMPLE_FMT_U8)
1445 memset(buf, fill_char, size);
1448 static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,
1449 const uint8_t *buf, int buf_size)
1451 AVCodecContext *enc = ost->st->codec;
1452 AVFrame *frame = NULL;
1454 int ret, got_packet;
1456 av_init_packet(&pkt);
1460 if (buf && buf_size) {
1461 if (!ost->output_frame) {
1462 ost->output_frame = avcodec_alloc_frame();
1463 if (!ost->output_frame) {
1464 av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");
1468 frame = ost->output_frame;
1469 if (frame->extended_data != frame->data)
1470 av_freep(&frame->extended_data);
1471 avcodec_get_frame_defaults(frame);
1473 frame->nb_samples = buf_size /
1474 (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
1475 if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,
1476 buf, buf_size, 1)) < 0) {
1477 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_fill_audio_frame)\n");
1481 frame->pts = ost->sync_opts;
1482 ost->sync_opts += frame->nb_samples;
1486 update_benchmark(NULL);
1487 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1488 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1491 update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
1496 if (pkt.pts != AV_NOPTS_VALUE)
1497 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1498 if (pkt.dts != AV_NOPTS_VALUE) {
1499 int64_t max = ost->st->cur_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
1500 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1501 if (ost->st->cur_dts && ost->st->cur_dts != AV_NOPTS_VALUE && max > pkt.dts) {
1502 av_log(s, max - pkt.dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG, "Audio timestamp %"PRId64" < %"PRId64" invalid, cliping\n", pkt.dts, max);
1503 pkt.pts = pkt.dts = max;
1506 if (pkt.duration > 0)
1507 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1509 write_frame(s, &pkt, ost);
1511 audio_size += pkt.size;
1513 av_free_packet(&pkt);
1517 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1518 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1519 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1520 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1526 static int alloc_audio_output_buf(AVCodecContext *dec, AVCodecContext *enc,
1527 int nb_samples, int *buf_linesize)
1529 int64_t audio_buf_samples;
1532 /* calculate required number of samples to allocate */
1533 audio_buf_samples = ((int64_t)nb_samples * enc->sample_rate + dec->sample_rate) /
1535 audio_buf_samples = 4 * audio_buf_samples + 10000; // safety factors for resampling
1536 audio_buf_samples = FFMAX(audio_buf_samples, enc->frame_size);
1537 if (audio_buf_samples > INT_MAX)
1538 return AVERROR(EINVAL);
1540 audio_buf_size = av_samples_get_buffer_size(buf_linesize, enc->channels,
1542 enc->sample_fmt, 0);
1543 if (audio_buf_size < 0)
1544 return audio_buf_size;
1546 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
1548 return AVERROR(ENOMEM);
1553 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1554 InputStream *ist, AVFrame *decoded_frame)
1559 int frame_bytes, resample_changed, ret;
1560 AVCodecContext *enc = ost->st->codec;
1561 AVCodecContext *dec = ist->st->codec;
1562 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1563 int isize = av_get_bytes_per_sample(dec->sample_fmt);
1564 uint8_t *buf[AV_NUM_DATA_POINTERS];
1565 int size = decoded_frame->nb_samples * dec->channels * isize;
1566 int planes = av_sample_fmt_is_planar(dec->sample_fmt) ? dec->channels : 1;
1568 int out_linesize = 0;
1569 int buf_linesize = decoded_frame->linesize[0];
1571 av_assert0(planes <= AV_NUM_DATA_POINTERS);
1573 for(i=0; i<planes; i++)
1574 buf[i]= decoded_frame->data[i];
1577 get_default_channel_layouts(ost, ist);
1579 if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples, &out_linesize) < 0) {
1580 av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1584 if (audio_sync_method > 1 ||
1585 enc->channels != dec->channels ||
1586 enc->channel_layout != dec->channel_layout ||
1587 enc->sample_rate != dec->sample_rate ||
1588 dec->sample_fmt != enc->sample_fmt)
1589 ost->audio_resample = 1;
1591 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1592 ost->resample_channels != dec->channels ||
1593 ost->resample_channel_layout != dec->channel_layout ||
1594 ost->resample_sample_rate != dec->sample_rate;
1596 if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
1598 if (resample_changed) {
1599 av_log(NULL, AV_LOG_INFO, "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:0x%"PRIx64" to rate:%d fmt:%s ch:%d chl:0x%"PRIx64"\n",
1600 ist->file_index, ist->st->index,
1601 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt),
1602 ost->resample_channels, ost->resample_channel_layout,
1603 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt),
1604 dec->channels, dec->channel_layout);
1605 ost->resample_sample_fmt = dec->sample_fmt;
1606 ost->resample_channels = dec->channels;
1607 ost->resample_channel_layout = dec->channel_layout;
1608 ost->resample_sample_rate = dec->sample_rate;
1609 swr_free(&ost->swr);
1611 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1612 if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
1613 ost->resample_sample_fmt == enc->sample_fmt &&
1614 ost->resample_channels == enc->channels &&
1615 ost->resample_channel_layout == enc->channel_layout &&
1616 ost->resample_sample_rate == enc->sample_rate) {
1618 ost->audio_resample = 0;
1620 ost->swr = swr_alloc_set_opts(ost->swr,
1621 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
1622 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
1624 av_opt_set_int(ost->swr, "dither_method", ost->swr_dither_method,0);
1625 av_opt_set_double(ost->swr, "dither_scale", ost->swr_dither_scale,0);
1626 if (ost->audio_channels_mapped)
1627 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
1628 av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
1629 if (ost->audio_channels_mapped) {
1630 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
1631 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
1633 if (av_opt_set_int(ost->swr, "ich", dec->channels, 0) < 0) {
1634 av_log(NULL, AV_LOG_FATAL, "Unsupported number of input channels\n");
1637 if (av_opt_set_int(ost->swr, "och", enc->channels, 0) < 0) {
1638 av_log(NULL, AV_LOG_FATAL, "Unsupported number of output channels\n");
1641 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
1642 if(ost->swr && swr_init(ost->swr) < 0){
1643 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
1644 swr_free(&ost->swr);
1648 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1649 dec->channels, dec->sample_rate,
1650 enc->channels, enc->sample_rate);
1656 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1658 if (audio_sync_method > 0) {
1659 double delta = get_sync_ipts(ost, ist->pts) * enc->sample_rate - ost->sync_opts -
1660 av_fifo_size(ost->fifo) / (enc->channels * osize);
1661 int idelta = delta * dec->sample_rate / enc->sample_rate;
1662 int byte_delta = idelta * isize * dec->channels;
1664 // FIXME resample delay
1665 if (fabs(delta) > 50) {
1666 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1667 if (byte_delta < 0) {
1668 byte_delta = FFMAX(byte_delta, -size);
1670 for (i=0; i<planes; i++)
1671 buf[i] -= byte_delta/planes;
1672 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1673 -byte_delta / (isize * dec->channels));
1678 av_fast_malloc(&async_buf, &allocated_async_buf_size,
1681 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1685 if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples + idelta, &out_linesize) < 0) {
1686 av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1691 for (i=0; i<planes; i++) {
1692 uint8_t *t = async_buf + i*((byte_delta + size)/planes);
1693 generate_silence(t, dec->sample_fmt, byte_delta/planes);
1694 memcpy(t + byte_delta/planes, buf[i], size/planes);
1698 buf_linesize = allocated_async_buf_size;
1699 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1701 } else if (audio_sync_method > 1) {
1702 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1703 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1704 delta, comp, enc->sample_rate);
1705 // fprintf(stderr, "drift:%f len:%d opts:%"PRId64" ipts:%"PRId64" fifo:%d\n", delta, -1, ost->sync_opts, (int64_t)(get_sync_ipts(ost) * enc->sample_rate), av_fifo_size(ost->fifo)/(ost->st->codec->channels * 2));
1706 swr_set_compensation(ost->swr, comp, enc->sample_rate);
1709 } else if (audio_sync_method == 0)
1710 ost->sync_opts = lrintf(get_sync_ipts(ost, ist->pts) * enc->sample_rate) -
1711 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1713 if (ost->audio_resample || ost->audio_channels_mapped) {
1715 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp},
1716 allocated_audio_buf_size / (enc->channels * osize),
1718 size / (dec->channels * isize));
1720 av_log(NULL, AV_LOG_FATAL, "swr_convert failed\n");
1723 size_out = size_out * enc->channels * osize;
1729 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1731 /* now encode as many frames as possible */
1732 if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1733 /* output resampled raw samples */
1734 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1735 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1738 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1740 frame_bytes = enc->frame_size * osize * enc->channels;
1742 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1743 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1744 encode_audio_frame(s, ost, audio_buf, frame_bytes);
1747 encode_audio_frame(s, ost, buftmp, size_out);
1751 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1753 AVCodecContext *dec;
1754 AVPicture *picture2;
1755 AVPicture picture_tmp;
1758 dec = ist->st->codec;
1760 /* deinterlace : must be done before any resize */
1761 if (do_deinterlace) {
1764 /* create temporary picture */
1765 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1766 buf = av_malloc(size);
1770 picture2 = &picture_tmp;
1771 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1773 if (avpicture_deinterlace(picture2, picture,
1774 dec->pix_fmt, dec->width, dec->height) < 0) {
1775 /* if error, do not deinterlace */
1776 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1785 if (picture != picture2)
1786 *picture = *picture2;
1790 static void do_subtitle_out(AVFormatContext *s,
1796 static uint8_t *subtitle_out = NULL;
1797 int subtitle_out_max_size = 1024 * 1024;
1798 int subtitle_out_size, nb, i;
1799 AVCodecContext *enc;
1802 if (pts == AV_NOPTS_VALUE) {
1803 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1809 enc = ost->st->codec;
1811 if (!subtitle_out) {
1812 subtitle_out = av_malloc(subtitle_out_max_size);
1815 /* Note: DVB subtitle need one packet to draw them and one other
1816 packet to clear them */
1817 /* XXX: signal it in the codec context ? */
1818 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1823 for (i = 0; i < nb; i++) {
1824 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1826 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1827 // start_display_time is required to be 0
1828 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1829 sub->end_display_time -= sub->start_display_time;
1830 sub->start_display_time = 0;
1831 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1832 subtitle_out_max_size, sub);
1833 if (subtitle_out_size < 0) {
1834 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1838 av_init_packet(&pkt);
1839 pkt.data = subtitle_out;
1840 pkt.size = subtitle_out_size;
1841 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1842 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1843 /* XXX: the pts correction is handled here. Maybe handling
1844 it in the codec would be better */
1846 pkt.pts += 90 * sub->start_display_time;
1848 pkt.pts += 90 * sub->end_display_time;
1850 write_frame(s, &pkt, ost);
1854 static double psnr(double d)
1856 return -10.0 * log(d) / log(10.0);
1859 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1862 AVCodecContext *enc;
1864 double ti1, bitrate, avg_bitrate;
1866 /* this is executed just the first time do_video_stats is called */
1868 vstats_file = fopen(vstats_filename, "w");
1875 enc = ost->st->codec;
1876 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1877 frame_number = ost->frame_number;
1878 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1879 if (enc->flags&CODEC_FLAG_PSNR)
1880 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1882 fprintf(vstats_file,"f_size= %6d ", frame_size);
1883 /* compute pts value */
1884 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1888 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1889 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1890 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1891 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1892 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1897 static void do_video_out(AVFormatContext *s, OutputStream *ost,
1898 AVFrame *in_picture, float quality)
1900 int nb_frames, i, ret, format_video_sync;
1901 AVCodecContext *enc;
1902 double sync_ipts, delta;
1903 double duration = 0;
1905 InputStream *ist = NULL;
1907 if (ost->source_index >= 0)
1908 ist = input_streams[ost->source_index];
1910 enc = ost->st->codec;
1912 if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1913 duration = 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base));
1915 sync_ipts = get_sync_ipts(ost, in_picture->pts) / av_q2d(enc->time_base);
1916 delta = sync_ipts - ost->sync_opts + duration;
1918 /* by default, we output a single frame */
1921 format_video_sync = video_sync_method;
1922 if (format_video_sync == VSYNC_AUTO)
1923 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1925 switch (format_video_sync) {
1927 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1930 else if (delta > 1.1)
1931 nb_frames = lrintf(delta);
1936 else if (delta > 0.6)
1937 ost->sync_opts = lrintf(sync_ipts);
1940 case VSYNC_PASSTHROUGH:
1941 ost->sync_opts = lrintf(sync_ipts);
1947 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1948 if (nb_frames == 0) {
1950 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1952 } else if (nb_frames > 1) {
1953 nb_frames_dup += nb_frames - 1;
1954 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1957 /* duplicates frame if needed */
1958 for (i = 0; i < nb_frames; i++) {
1960 av_init_packet(&pkt);
1964 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1965 enc->codec->id == CODEC_ID_RAWVIDEO) {
1966 /* raw pictures are written as AVPicture structure to
1967 avoid any copies. We support temporarily the older
1969 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1970 enc->coded_frame->top_field_first = in_picture->top_field_first;
1971 pkt.data = (uint8_t *)in_picture;
1972 pkt.size = sizeof(AVPicture);
1973 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1974 pkt.flags |= AV_PKT_FLAG_KEY;
1976 write_frame(s, &pkt, ost);
1979 AVFrame big_picture;
1981 big_picture = *in_picture;
1982 /* better than nothing: use input picture interlaced
1984 big_picture.interlaced_frame = in_picture->interlaced_frame;
1985 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1986 if (ost->top_field_first == -1)
1987 big_picture.top_field_first = in_picture->top_field_first;
1989 big_picture.top_field_first = !!ost->top_field_first;
1992 /* handles same_quant here. This is not correct because it may
1993 not be a global option */
1994 big_picture.quality = quality;
1995 if (!enc->me_threshold)
1996 big_picture.pict_type = 0;
1997 big_picture.pts = ost->sync_opts;
1998 if (ost->forced_kf_index < ost->forced_kf_count &&
1999 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
2000 big_picture.pict_type = AV_PICTURE_TYPE_I;
2001 ost->forced_kf_index++;
2003 update_benchmark(NULL);
2004 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
2005 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
2007 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
2012 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
2013 pkt.pts = ost->sync_opts;
2015 if (pkt.pts != AV_NOPTS_VALUE)
2016 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2017 if (pkt.dts != AV_NOPTS_VALUE)
2018 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2021 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
2022 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
2023 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
2024 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
2027 write_frame(s, &pkt, ost);
2028 frame_size = pkt.size;
2029 video_size += pkt.size;
2030 av_free_packet(&pkt);
2032 /* if two pass, output log */
2033 if (ost->logfile && enc->stats_out) {
2034 fprintf(ost->logfile, "%s", enc->stats_out);
2040 * For video, number of frames in == number of packets out.
2041 * But there may be reordering, so we can't throw away frames on encoder
2042 * flush, we need to limit them here, before they go into encoder.
2044 ost->frame_number++;
2046 if (vstats_filename && frame_size)
2047 do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
2050 /* check for new output on any of the filtergraphs */
2051 static int poll_filters(void)
2053 AVFilterBufferRef *picref;
2054 AVFrame *filtered_frame = NULL;
2055 int i, ret, ret_all;
2056 unsigned nb_success, nb_eof;
2059 /* Reap all buffers present in the buffer sinks */
2060 for (i = 0; i < nb_output_streams; i++) {
2061 OutputStream *ost = output_streams[i];
2062 OutputFile *of = output_files[ost->file_index];
2064 if (!ost->filter || ost->is_past_recording_time)
2067 if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
2068 return AVERROR(ENOMEM);
2070 avcodec_get_frame_defaults(ost->filtered_frame);
2071 filtered_frame = ost->filtered_frame;
2074 AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base;
2075 ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
2076 AV_BUFFERSINK_FLAG_NO_REQUEST);
2078 if (ret != AVERROR(EAGAIN)) {
2080 av_strerror(ret, buf, sizeof(buf));
2081 av_log(NULL, AV_LOG_WARNING,
2082 "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
2086 filtered_frame->pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2087 //if (ost->source_index >= 0)
2088 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
2090 if (of->start_time && filtered_frame->pts < of->start_time)
2093 switch (ost->filter->filter->inputs[0]->type) {
2094 case AVMEDIA_TYPE_VIDEO:
2095 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);
2096 if (!ost->frame_aspect_ratio)
2097 ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
2099 do_video_out(of->ctx, ost, filtered_frame,
2100 same_quant ? ost->last_quality :
2101 ost->st->codec->global_quality);
2104 // TODO support audio/subtitle filters
2108 avfilter_unref_buffer(picref);
2111 /* Request frames through all the graphs */
2112 ret_all = nb_success = nb_eof = 0;
2113 for (i = 0; i < nb_filtergraphs; i++) {
2114 ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
2117 } else if (ret == AVERROR_EOF) {
2119 } else if (ret != AVERROR(EAGAIN)) {
2121 av_strerror(ret, buf, sizeof(buf));
2122 av_log(NULL, AV_LOG_WARNING,
2123 "Error in request_frame(): %s\n", buf);
2129 /* Try again if anything succeeded */
2131 return nb_eof == nb_filtergraphs ? AVERROR_EOF : ret_all;
2134 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
2138 AVFormatContext *oc;
2140 AVCodecContext *enc;
2141 int frame_number, vid, i;
2143 int64_t pts = INT64_MAX;
2144 static int64_t last_time = -1;
2145 static int qp_histogram[52];
2146 int hours, mins, secs, us;
2148 if (!print_stats && !is_last_report)
2151 if (!is_last_report) {
2152 if (last_time == -1) {
2153 last_time = cur_time;
2156 if ((cur_time - last_time) < 500000)
2158 last_time = cur_time;
2162 oc = output_files[0]->ctx;
2164 total_size = avio_size(oc->pb);
2165 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
2166 total_size = avio_tell(oc->pb);
2173 for (i = 0; i < nb_output_streams; i++) {
2175 ost = output_streams[i];
2176 enc = ost->st->codec;
2177 if (!ost->stream_copy && enc->coded_frame)
2178 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
2179 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2180 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
2182 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2183 float fps, t = (cur_time-timer_start) / 1000000.0;
2185 frame_number = ost->frame_number;
2186 fps = t > 1 ? frame_number / t : 0;
2187 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
2188 frame_number, fps < 9.95, fps, q);
2190 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
2194 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
2196 for (j = 0; j < 32; j++)
2197 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
2199 if (enc->flags&CODEC_FLAG_PSNR) {
2201 double error, error_sum = 0;
2202 double scale, scale_sum = 0;
2203 char type[3] = { 'Y','U','V' };
2204 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
2205 for (j = 0; j < 3; j++) {
2206 if (is_last_report) {
2207 error = enc->error[j];
2208 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
2210 error = enc->coded_frame->error[j];
2211 scale = enc->width * enc->height * 255.0 * 255.0;
2217 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
2219 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
2223 /* compute min output value */
2224 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
2225 ost->st->time_base, AV_TIME_BASE_Q));
2228 secs = pts / AV_TIME_BASE;
2229 us = pts % AV_TIME_BASE;
2235 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
2237 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2238 "size=%8.0fkB time=", total_size / 1024.0);
2239 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2240 "%02d:%02d:%02d.%02d ", hours, mins, secs,
2241 (100 * us) / AV_TIME_BASE);
2242 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2243 "bitrate=%6.1fkbits/s", bitrate);
2245 if (nb_frames_dup || nb_frames_drop)
2246 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
2247 nb_frames_dup, nb_frames_drop);
2249 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
2253 if (is_last_report) {
2254 int64_t raw= audio_size + video_size + extra_size;
2255 av_log(NULL, AV_LOG_INFO, "\n");
2256 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
2257 video_size / 1024.0,
2258 audio_size / 1024.0,
2259 extra_size / 1024.0,
2260 100.0 * (total_size - raw) / raw
2262 if(video_size + audio_size + extra_size == 0){
2263 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
2268 static void flush_encoders(void)
2272 for (i = 0; i < nb_output_streams; i++) {
2273 OutputStream *ost = output_streams[i];
2274 AVCodecContext *enc = ost->st->codec;
2275 AVFormatContext *os = output_files[ost->file_index]->ctx;
2276 int stop_encoding = 0;
2278 if (!ost->encoding_needed)
2281 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
2283 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
2288 int fifo_bytes, got_packet;
2289 av_init_packet(&pkt);
2293 switch (ost->st->codec->codec_type) {
2294 case AVMEDIA_TYPE_AUDIO:
2295 fifo_bytes = av_fifo_size(ost->fifo);
2296 if (fifo_bytes > 0) {
2297 /* encode any samples remaining in fifo */
2298 int frame_bytes = fifo_bytes;
2300 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
2302 /* pad last frame with silence if needed */
2303 if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
2304 frame_bytes = enc->frame_size * enc->channels *
2305 av_get_bytes_per_sample(enc->sample_fmt);
2306 if (allocated_audio_buf_size < frame_bytes)
2308 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
2310 encode_audio_frame(os, ost, audio_buf, frame_bytes);
2312 /* flush encoder with NULL frames until it is done
2313 returning packets */
2314 if (encode_audio_frame(os, ost, NULL, 0) == 0) {
2320 case AVMEDIA_TYPE_VIDEO:
2321 update_benchmark(NULL);
2322 ret = avcodec_encode_video2(enc, &pkt, NULL, &got_packet);
2323 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
2325 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
2328 video_size += pkt.size;
2329 if (ost->logfile && enc->stats_out) {
2330 fprintf(ost->logfile, "%s", enc->stats_out);
2336 if (pkt.pts != AV_NOPTS_VALUE)
2337 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2338 if (pkt.dts != AV_NOPTS_VALUE)
2339 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2340 write_frame(os, &pkt, ost);
2352 * Check whether a packet from ist should be written into ost at this time
2354 static int check_output_constraints(InputStream *ist, OutputStream *ost)
2356 OutputFile *of = output_files[ost->file_index];
2357 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
2359 if (ost->source_index != ist_index)
2362 if (of->start_time && ist->pts < of->start_time)
2365 if (of->recording_time != INT64_MAX &&
2366 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
2367 (AVRational){ 1, 1000000 }) >= 0) {
2368 ost->is_past_recording_time = 1;
2375 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2377 OutputFile *of = output_files[ost->file_index];
2378 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
2382 av_init_packet(&opkt);
2384 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2385 !ost->copy_initial_nonkeyframes)
2388 /* force the input stream PTS */
2389 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2390 audio_size += pkt->size;
2391 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2392 video_size += pkt->size;
2396 if (pkt->pts != AV_NOPTS_VALUE)
2397 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
2399 opkt.pts = AV_NOPTS_VALUE;
2401 if (pkt->dts == AV_NOPTS_VALUE)
2402 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
2404 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
2405 opkt.dts -= ost_tb_start_time;
2407 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
2408 opkt.flags = pkt->flags;
2410 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2411 if ( ost->st->codec->codec_id != CODEC_ID_H264
2412 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
2413 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
2414 && ost->st->codec->codec_id != CODEC_ID_VC1
2416 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
2417 opkt.destruct = av_destruct_packet;
2419 opkt.data = pkt->data;
2420 opkt.size = pkt->size;
2422 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2423 /* store AVPicture in AVPacket, as expected by the output format */
2424 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2425 opkt.data = (uint8_t *)&pict;
2426 opkt.size = sizeof(AVPicture);
2427 opkt.flags |= AV_PKT_FLAG_KEY;
2430 write_frame(of->ctx, &opkt, ost);
2431 ost->st->codec->frame_number++;
2432 av_free_packet(&opkt);
2435 static void rate_emu_sleep(InputStream *ist)
2437 if (input_files[ist->file_index]->rate_emu) {
2438 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2439 int64_t now = av_gettime() - ist->start;
2445 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2447 AVFrame *decoded_frame;
2448 AVCodecContext *avctx = ist->st->codec;
2449 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
2452 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2453 return AVERROR(ENOMEM);
2455 avcodec_get_frame_defaults(ist->decoded_frame);
2456 decoded_frame = ist->decoded_frame;
2458 update_benchmark(NULL);
2459 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2460 update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2464 if (avctx->sample_rate <= 0) {
2465 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2466 return AVERROR_INVALIDDATA;
2470 /* no audio frame */
2474 /* if the decoder provides a pts, use it instead of the last packet pts.
2475 the decoder could be delaying output by a packet or more. */
2476 if (decoded_frame->pts != AV_NOPTS_VALUE)
2477 ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2479 /* increment next_dts to use for the case where the input stream does not
2480 have timestamps or there are multiple frames in the packet */
2481 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2483 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2487 // preprocess audio (volume)
2488 if (audio_volume != 256) {
2489 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
2490 void *samples = decoded_frame->data[0];
2491 switch (avctx->sample_fmt) {
2492 case AV_SAMPLE_FMT_U8:
2494 uint8_t *volp = samples;
2495 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2496 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
2497 *volp++ = av_clip_uint8(v);
2501 case AV_SAMPLE_FMT_S16:
2503 int16_t *volp = samples;
2504 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2505 int v = ((*volp) * audio_volume + 128) >> 8;
2506 *volp++ = av_clip_int16(v);
2510 case AV_SAMPLE_FMT_S32:
2512 int32_t *volp = samples;
2513 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2514 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
2515 *volp++ = av_clipl_int32(v);
2519 case AV_SAMPLE_FMT_FLT:
2521 float *volp = samples;
2522 float scale = audio_volume / 256.f;
2523 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2528 case AV_SAMPLE_FMT_DBL:
2530 double *volp = samples;
2531 double scale = audio_volume / 256.;
2532 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2538 av_log(NULL, AV_LOG_FATAL,
2539 "Audio volume adjustment on sample format %s is not supported.\n",
2540 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
2545 rate_emu_sleep(ist);
2547 for (i = 0; i < nb_output_streams; i++) {
2548 OutputStream *ost = output_streams[i];
2550 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2552 do_audio_out(output_files[ost->file_index]->ctx, ost, ist, decoded_frame);
2558 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
2560 AVFrame *decoded_frame;
2561 void *buffer_to_free = NULL;
2562 int i, ret = 0, resample_changed;
2563 int64_t best_effort_timestamp;
2564 AVRational *frame_sample_aspect;
2567 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2568 return AVERROR(ENOMEM);
2570 avcodec_get_frame_defaults(ist->decoded_frame);
2571 decoded_frame = ist->decoded_frame;
2572 pkt->pts = *pkt_pts;
2573 pkt->dts = ist->dts;
2574 *pkt_pts = AV_NOPTS_VALUE;
2576 update_benchmark(NULL);
2577 ret = avcodec_decode_video2(ist->st->codec,
2578 decoded_frame, got_output, pkt);
2579 update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2583 quality = same_quant ? decoded_frame->quality : 0;
2585 /* no picture yet */
2587 for (i = 0; i < ist->nb_filters; i++)
2588 av_buffersrc_add_ref(ist->filters[i]->filter, NULL, 0);
2592 best_effort_timestamp= av_frame_get_best_effort_timestamp(decoded_frame);
2593 if(best_effort_timestamp != AV_NOPTS_VALUE)
2594 ist->next_pts = ist->pts = decoded_frame->pts = best_effort_timestamp;
2598 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2600 rate_emu_sleep(ist);
2602 if (ist->st->sample_aspect_ratio.num)
2603 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2605 resample_changed = ist->resample_width != decoded_frame->width ||
2606 ist->resample_height != decoded_frame->height ||
2607 ist->resample_pix_fmt != decoded_frame->format;
2608 if (resample_changed) {
2609 av_log(NULL, AV_LOG_INFO,
2610 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2611 ist->file_index, ist->st->index,
2612 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2613 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2615 ist->resample_width = decoded_frame->width;
2616 ist->resample_height = decoded_frame->height;
2617 ist->resample_pix_fmt = decoded_frame->format;
2619 for (i = 0; i < nb_filtergraphs; i++)
2620 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2621 configure_filtergraph(filtergraphs[i]) < 0) {
2622 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2627 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2628 for (i = 0; i < ist->nb_filters; i++) {
2629 int changed = ist->st->codec->width != ist->filters[i]->filter->outputs[0]->w
2630 || ist->st->codec->height != ist->filters[i]->filter->outputs[0]->h
2631 || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2632 // XXX what an ugly hack
2633 if (ist->filters[i]->graph->nb_outputs == 1)
2634 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2636 if (!frame_sample_aspect->num)
2637 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2638 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2639 FrameBuffer *buf = decoded_frame->opaque;
2640 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2641 decoded_frame->data, decoded_frame->linesize,
2642 AV_PERM_READ | AV_PERM_PRESERVE,
2643 ist->st->codec->width, ist->st->codec->height,
2644 ist->st->codec->pix_fmt);
2646 avfilter_copy_frame_props(fb, decoded_frame);
2647 fb->buf->priv = buf;
2648 fb->buf->free = filter_release_buffer;
2650 av_assert0(buf->refcount>0);
2652 av_buffersrc_add_ref(ist->filters[i]->filter, fb,
2653 AV_BUFFERSRC_FLAG_NO_CHECK_FORMAT |
2654 AV_BUFFERSRC_FLAG_NO_COPY);
2656 if(av_buffersrc_add_frame(ist->filters[i]->filter, decoded_frame, 0)<0) {
2657 av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2663 av_free(buffer_to_free);
2667 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2669 AVSubtitle subtitle;
2670 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2671 &subtitle, got_output, pkt);
2677 rate_emu_sleep(ist);
2679 for (i = 0; i < nb_output_streams; i++) {
2680 OutputStream *ost = output_streams[i];
2682 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2685 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2688 avsubtitle_free(&subtitle);
2692 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2693 static int output_packet(InputStream *ist, const AVPacket *pkt)
2697 int64_t pkt_pts = AV_NOPTS_VALUE;
2700 if (!ist->saw_first_ts) {
2701 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;
2703 if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2704 ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2705 ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2707 ist->saw_first_ts = 1;
2710 if (ist->next_dts == AV_NOPTS_VALUE)
2711 ist->next_dts = ist->dts;
2712 if (ist->next_pts == AV_NOPTS_VALUE)
2713 ist->next_pts = ist->pts;
2717 av_init_packet(&avpkt);
2725 if (pkt->dts != AV_NOPTS_VALUE) {
2726 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2727 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2728 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2730 if(pkt->pts != AV_NOPTS_VALUE)
2731 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2733 // while we have more to decode or while the decoder did output something on EOF
2734 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2738 ist->pts = ist->next_pts;
2739 ist->dts = ist->next_dts;
2741 if (avpkt.size && avpkt.size != pkt->size) {
2742 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2743 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2744 ist->showed_multi_packet_warning = 1;
2747 switch (ist->st->codec->codec_type) {
2748 case AVMEDIA_TYPE_AUDIO:
2749 ret = transcode_audio (ist, &avpkt, &got_output);
2751 case AVMEDIA_TYPE_VIDEO:
2752 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
2753 if (avpkt.duration) {
2754 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2755 } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2756 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2757 duration = ((int64_t)AV_TIME_BASE *
2758 ist->st->codec->time_base.num * ticks) /
2759 ist->st->codec->time_base.den;
2763 if(ist->dts != AV_NOPTS_VALUE && duration) {
2764 ist->next_dts += duration;
2766 ist->next_dts = AV_NOPTS_VALUE;
2769 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2771 case AVMEDIA_TYPE_SUBTITLE:
2772 ret = transcode_subtitles(ist, &avpkt, &got_output);
2782 avpkt.pts= AV_NOPTS_VALUE;
2784 // touch data and size only if not EOF
2786 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2796 /* handle stream copy */
2797 if (!ist->decoding_needed) {
2798 rate_emu_sleep(ist);
2799 ist->dts = ist->next_dts;
2800 switch (ist->st->codec->codec_type) {
2801 case AVMEDIA_TYPE_AUDIO:
2802 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2803 ist->st->codec->sample_rate;
2805 case AVMEDIA_TYPE_VIDEO:
2806 if (pkt->duration) {
2807 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2808 } else if(ist->st->codec->time_base.num != 0) {
2809 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2810 ist->next_dts += ((int64_t)AV_TIME_BASE *
2811 ist->st->codec->time_base.num * ticks) /
2812 ist->st->codec->time_base.den;
2816 ist->pts = ist->dts;
2817 ist->next_pts = ist->next_dts;
2819 for (i = 0; pkt && i < nb_output_streams; i++) {
2820 OutputStream *ost = output_streams[i];
2822 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2825 do_streamcopy(ist, ost, pkt);
2831 static void print_sdp(void)
2835 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2839 for (i = 0; i < nb_output_files; i++)
2840 avc[i] = output_files[i]->ctx;
2842 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2843 printf("SDP:\n%s\n", sdp);
2848 static int init_input_stream(int ist_index, char *error, int error_len)
2851 InputStream *ist = input_streams[ist_index];
2853 if (ist->decoding_needed) {
2854 AVCodec *codec = ist->dec;
2856 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2857 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2858 return AVERROR(EINVAL);
2861 ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
2862 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2863 ist->st->codec->get_buffer = codec_get_buffer;
2864 ist->st->codec->release_buffer = codec_release_buffer;
2865 ist->st->codec->opaque = ist;
2868 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2869 av_dict_set(&ist->opts, "threads", "auto", 0);
2870 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2871 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2872 ist->file_index, ist->st->index);
2873 return AVERROR(EINVAL);
2875 assert_codec_experimental(ist->st->codec, 0);
2876 assert_avoptions(ist->opts);
2878 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2879 for (i = 0; i < nb_output_streams; i++) {
2880 OutputStream *ost = output_streams[i];
2881 if (ost->source_index == ist_index) {
2882 if (!ist->st->codec->channel_layout || !ost->st->codec->channel_layout)
2883 get_default_channel_layouts(ost, ist);
2890 ist->next_pts = AV_NOPTS_VALUE;
2891 ist->next_dts = AV_NOPTS_VALUE;
2897 static InputStream *get_input_stream(OutputStream *ost)
2899 if (ost->source_index >= 0)
2900 return input_streams[ost->source_index];
2903 FilterGraph *fg = ost->filter->graph;
2906 for (i = 0; i < fg->nb_inputs; i++)
2907 if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2908 return fg->inputs[i]->ist;
2914 static int transcode_init(void)
2916 int ret = 0, i, j, k;
2917 AVFormatContext *oc;
2918 AVCodecContext *codec, *icodec;
2924 /* init framerate emulation */
2925 for (i = 0; i < nb_input_files; i++) {
2926 InputFile *ifile = input_files[i];
2927 if (ifile->rate_emu)
2928 for (j = 0; j < ifile->nb_streams; j++)
2929 input_streams[j + ifile->ist_index]->start = av_gettime();
2932 /* output stream init */
2933 for (i = 0; i < nb_output_files; i++) {
2934 oc = output_files[i]->ctx;
2935 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2936 av_dump_format(oc, i, oc->filename, 1);
2937 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2938 return AVERROR(EINVAL);
2942 /* init complex filtergraphs */
2943 for (i = 0; i < nb_filtergraphs; i++)
2944 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2947 /* for each output stream, we compute the right encoding parameters */
2948 for (i = 0; i < nb_output_streams; i++) {
2949 ost = output_streams[i];
2950 oc = output_files[ost->file_index]->ctx;
2951 ist = get_input_stream(ost);
2953 if (ost->attachment_filename)
2956 codec = ost->st->codec;
2959 icodec = ist->st->codec;
2961 ost->st->disposition = ist->st->disposition;
2962 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2963 codec->chroma_sample_location = icodec->chroma_sample_location;
2966 if (ost->stream_copy) {
2967 uint64_t extra_size;
2969 av_assert0(ist && !ost->filter);
2971 extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2973 if (extra_size > INT_MAX) {
2974 return AVERROR(EINVAL);
2977 /* if stream_copy is selected, no need to decode or encode */
2978 codec->codec_id = icodec->codec_id;
2979 codec->codec_type = icodec->codec_type;
2981 if (!codec->codec_tag) {
2982 if (!oc->oformat->codec_tag ||
2983 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2984 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2985 codec->codec_tag = icodec->codec_tag;
2988 codec->bit_rate = icodec->bit_rate;
2989 codec->rc_max_rate = icodec->rc_max_rate;
2990 codec->rc_buffer_size = icodec->rc_buffer_size;
2991 codec->field_order = icodec->field_order;
2992 codec->extradata = av_mallocz(extra_size);
2993 if (!codec->extradata) {
2994 return AVERROR(ENOMEM);
2996 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2997 codec->extradata_size= icodec->extradata_size;
2999 codec->time_base = ist->st->time_base;
3001 * Avi is a special case here because it supports variable fps but
3002 * having the fps and timebase differe significantly adds quite some
3005 if(!strcmp(oc->oformat->name, "avi")) {
3006 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
3007 && av_q2d(ist->st->time_base) < 1.0/500
3009 codec->time_base = icodec->time_base;
3010 codec->time_base.num *= icodec->ticks_per_frame;
3011 codec->time_base.den *= 2;
3012 codec->ticks_per_frame = 2;
3014 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
3015 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
3016 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
3018 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
3019 && av_q2d(ist->st->time_base) < 1.0/500
3021 codec->time_base = icodec->time_base;
3022 codec->time_base.num *= icodec->ticks_per_frame;
3025 av_reduce(&codec->time_base.num, &codec->time_base.den,
3026 codec->time_base.num, codec->time_base.den, INT_MAX);
3028 switch (codec->codec_type) {
3029 case AVMEDIA_TYPE_AUDIO:
3030 if (audio_volume != 256) {
3031 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3034 codec->channel_layout = icodec->channel_layout;
3035 codec->sample_rate = icodec->sample_rate;
3036 codec->channels = icodec->channels;
3037 codec->frame_size = icodec->frame_size;
3038 codec->audio_service_type = icodec->audio_service_type;
3039 codec->block_align = icodec->block_align;
3041 case AVMEDIA_TYPE_VIDEO:
3042 codec->pix_fmt = icodec->pix_fmt;
3043 codec->width = icodec->width;
3044 codec->height = icodec->height;
3045 codec->has_b_frames = icodec->has_b_frames;
3046 if (!codec->sample_aspect_ratio.num) {
3047 codec->sample_aspect_ratio =
3048 ost->st->sample_aspect_ratio =
3049 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
3050 ist->st->codec->sample_aspect_ratio.num ?
3051 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
3053 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3055 case AVMEDIA_TYPE_SUBTITLE:
3056 codec->width = icodec->width;
3057 codec->height = icodec->height;
3059 case AVMEDIA_TYPE_DATA:
3060 case AVMEDIA_TYPE_ATTACHMENT:
3067 ost->enc = avcodec_find_encoder(codec->codec_id);
3069 /* should only happen when a default codec is not present. */
3070 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3071 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3072 ret = AVERROR(EINVAL);
3077 ist->decoding_needed = 1;
3078 ost->encoding_needed = 1;
3080 switch (codec->codec_type) {
3081 case AVMEDIA_TYPE_AUDIO:
3082 ost->fifo = av_fifo_alloc(1024);
3084 return AVERROR(ENOMEM);
3087 if (!codec->sample_rate)
3088 codec->sample_rate = icodec->sample_rate;
3089 choose_sample_rate(ost->st, ost->enc);
3090 codec->time_base = (AVRational){ 1, codec->sample_rate };
3092 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
3093 codec->sample_fmt = icodec->sample_fmt;
3094 choose_sample_fmt(ost->st, ost->enc);
3096 if (ost->audio_channels_mapped) {
3097 /* the requested output channel is set to the number of
3098 * -map_channel only if no -ac are specified */
3099 if (!codec->channels) {
3100 codec->channels = ost->audio_channels_mapped;
3101 codec->channel_layout = av_get_default_channel_layout(codec->channels);
3102 if (!codec->channel_layout) {
3103 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
3107 /* fill unused channel mapping with -1 (which means a muted
3108 * channel in case the number of output channels is bigger
3109 * than the number of mapped channel) */
3110 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
3111 ost->audio_channels_map[j] = -1;
3112 } else if (!codec->channels) {
3113 codec->channels = icodec->channels;
3114 codec->channel_layout = icodec->channel_layout;
3116 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
3117 codec->channel_layout = 0;
3120 // ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
3121 // ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
3122 // || codec->channel_layout != icodec->channel_layout;
3123 icodec->request_channels = codec-> channels;
3124 ost->resample_sample_fmt = icodec->sample_fmt;
3125 ost->resample_sample_rate = icodec->sample_rate;
3126 ost->resample_channels = icodec->channels;
3127 ost->resample_channel_layout = icodec->channel_layout;
3129 case AVMEDIA_TYPE_VIDEO:
3132 fg = init_simple_filtergraph(ist, ost);
3133 if (configure_video_filters(fg)) {
3134 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3139 if (ist && !ost->frame_rate.num)
3140 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
3141 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3142 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3143 ost->frame_rate = ost->enc->supported_framerates[idx];
3145 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3146 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3147 && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3148 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3149 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3151 for (j = 0; j < ost->forced_kf_count; j++)
3152 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3156 codec->width = ost->filter->filter->inputs[0]->w;
3157 codec->height = ost->filter->filter->inputs[0]->h;
3158 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3159 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3160 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3161 ost->filter->filter->inputs[0]->sample_aspect_ratio;
3162 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3164 if (codec->width != icodec->width ||
3165 codec->height != icodec->height ||
3166 codec->pix_fmt != icodec->pix_fmt) {
3167 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3171 case AVMEDIA_TYPE_SUBTITLE:
3172 codec->time_base = (AVRational){1, 1000};
3179 if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3180 char logfilename[1024];
3183 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3184 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3186 if (!strcmp(ost->enc->name, "libx264")) {
3187 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3189 if (codec->flags & CODEC_FLAG_PASS2) {
3191 size_t logbuffer_size;
3192 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3193 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3197 codec->stats_in = logbuffer;
3199 if (codec->flags & CODEC_FLAG_PASS1) {
3200 f = fopen(logfilename, "wb");
3202 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3203 logfilename, strerror(errno));
3213 /* open each encoder */
3214 for (i = 0; i < nb_output_streams; i++) {
3215 ost = output_streams[i];
3216 if (ost->encoding_needed) {
3217 AVCodec *codec = ost->enc;
3218 AVCodecContext *dec = NULL;
3220 if ((ist = get_input_stream(ost)))
3221 dec = ist->st->codec;
3222 if (dec && dec->subtitle_header) {
3223 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3224 if (!ost->st->codec->subtitle_header) {
3225 ret = AVERROR(ENOMEM);
3228 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3229 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3231 if (!av_dict_get(ost->opts, "threads", NULL, 0))
3232 av_dict_set(&ost->opts, "threads", "auto", 0);
3233 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3234 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3235 ost->file_index, ost->index);
3236 ret = AVERROR(EINVAL);
3239 assert_codec_experimental(ost->st->codec, 1);
3240 assert_avoptions(ost->opts);
3241 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3242 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3243 " It takes bits/s as argument, not kbits/s\n");
3244 extra_size += ost->st->codec->extradata_size;
3246 if (ost->st->codec->me_threshold)
3247 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3251 /* init input streams */
3252 for (i = 0; i < nb_input_streams; i++)
3253 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3256 /* discard unused programs */
3257 for (i = 0; i < nb_input_files; i++) {
3258 InputFile *ifile = input_files[i];
3259 for (j = 0; j < ifile->ctx->nb_programs; j++) {
3260 AVProgram *p = ifile->ctx->programs[j];
3261 int discard = AVDISCARD_ALL;
3263 for (k = 0; k < p->nb_stream_indexes; k++)
3264 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3265 discard = AVDISCARD_DEFAULT;
3268 p->discard = discard;
3272 /* open files and write file headers */
3273 for (i = 0; i < nb_output_files; i++) {
3274 oc = output_files[i]->ctx;
3275 oc->interrupt_callback = int_cb;
3276 if (avformat_write_header(oc, &output_files[i]->opts) < 0) {
3277 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
3278 ret = AVERROR(EINVAL);
3281 // assert_avoptions(output_files[i]->opts);
3282 if (strcmp(oc->oformat->name, "rtp")) {
3288 /* dump the file output parameters - cannot be done before in case
3290 for (i = 0; i < nb_output_files; i++) {
3291 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3294 /* dump the stream mapping */
3295 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3296 for (i = 0; i < nb_input_streams; i++) {
3297 ist = input_streams[i];
3299 for (j = 0; j < ist->nb_filters; j++) {
3300 AVFilterLink *link = ist->filters[j]->filter->outputs[0];
3301 if (ist->filters[j]->graph->graph_desc) {
3302 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
3303 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3304 link->dst->filter->name);
3305 if (link->dst->input_count > 1)
3306 av_log(NULL, AV_LOG_INFO, ":%s", link->dstpad->name);
3307 if (nb_filtergraphs > 1)
3308 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3309 av_log(NULL, AV_LOG_INFO, "\n");
3314 for (i = 0; i < nb_output_streams; i++) {
3315 ost = output_streams[i];
3317 if (ost->attachment_filename) {
3318 /* an attached file */
3319 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
3320 ost->attachment_filename, ost->file_index, ost->index);
3324 if (ost->filter && ost->filter->graph->graph_desc) {
3325 /* output from a complex graph */
3326 AVFilterLink *link = ost->filter->filter->inputs[0];
3327 av_log(NULL, AV_LOG_INFO, " %s", link->src->filter->name);
3328 if (link->src->output_count > 1)
3329 av_log(NULL, AV_LOG_INFO, ":%s", link->srcpad->name);
3330 if (nb_filtergraphs > 1)
3331 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3333 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3334 ost->index, ost->enc ? ost->enc->name : "?");
3338 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
3339 input_streams[ost->source_index]->file_index,
3340 input_streams[ost->source_index]->st->index,
3343 if (ost->audio_channels_mapped) {
3344 av_log(NULL, AV_LOG_INFO, " [ch:");
3345 for (j = 0; j < ost->audio_channels_mapped; j++)
3346 if (ost->audio_channels_map[j] == -1)
3347 av_log(NULL, AV_LOG_INFO, " M");
3349 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
3350 av_log(NULL, AV_LOG_INFO, "]");
3352 if (ost->sync_ist != input_streams[ost->source_index])
3353 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3354 ost->sync_ist->file_index,
3355 ost->sync_ist->st->index);
3356 if (ost->stream_copy)
3357 av_log(NULL, AV_LOG_INFO, " (copy)");
3359 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3360 input_streams[ost->source_index]->dec->name : "?",
3361 ost->enc ? ost->enc->name : "?");
3362 av_log(NULL, AV_LOG_INFO, "\n");
3366 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3378 * The following code is the main loop of the file converter
3380 static int transcode(void)
3383 AVFormatContext *is, *os;
3387 int no_packet_count = 0;
3388 int64_t timer_start;
3391 if (!(no_packet = av_mallocz(nb_input_files)))
3394 ret = transcode_init();
3399 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3402 timer_start = av_gettime();
3404 for (; received_sigterm == 0;) {
3405 int file_index, ist_index, past_recording_time = 1;
3408 int64_t cur_time= av_gettime();
3410 ipts_min = INT64_MAX;
3411 /* if 'q' pressed, exits */
3413 static int64_t last_time;
3414 if (received_nb_signals)
3416 /* read_key() returns 0 on EOF */
3417 if(cur_time - last_time >= 100000 && !run_as_daemon){
3419 last_time = cur_time;
3424 if (key == '+') av_log_set_level(av_log_get_level()+10);
3425 if (key == '-') av_log_set_level(av_log_get_level()-10);
3426 if (key == 's') qp_hist ^= 1;
3429 do_hex_dump = do_pkt_dump = 0;
3430 } else if(do_pkt_dump){
3434 av_log_set_level(AV_LOG_DEBUG);
3436 if (key == 'c' || key == 'C'){
3437 char buf[4096], target[64], command[256], arg[256] = {0};
3440 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3442 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3447 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3448 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3449 target, time, command, arg);
3450 for (i = 0; i < nb_filtergraphs; i++) {
3451 FilterGraph *fg = filtergraphs[i];
3454 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3455 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3456 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3458 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3463 av_log(NULL, AV_LOG_ERROR,
3464 "Parse error, at least 3 arguments were expected, "
3465 "only %d given in string '%s'\n", n, buf);
3468 if (key == 'd' || key == 'D'){
3471 debug = input_streams[0]->st->codec->debug<<1;
3472 if(!debug) debug = 1;
3473 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3476 if(scanf("%d", &debug)!=1)
3477 fprintf(stderr,"error parsing debug value\n");
3478 for(i=0;i<nb_input_streams;i++) {
3479 input_streams[i]->st->codec->debug = debug;
3481 for(i=0;i<nb_output_streams;i++) {
3482 ost = output_streams[i];
3483 ost->st->codec->debug = debug;
3485 if(debug) av_log_set_level(AV_LOG_DEBUG);
3486 fprintf(stderr,"debug=%d\n", debug);
3489 fprintf(stderr, "key function\n"
3490 "? show this help\n"
3491 "+ increase verbosity\n"
3492 "- decrease verbosity\n"
3493 "c Send command to filtergraph\n"
3494 "D cycle through available debug modes\n"
3495 "h dump packets/hex press to cycle through the 3 states\n"
3497 "s Show QP histogram\n"
3502 /* check if there's any stream where output is still needed */
3503 for (i = 0; i < nb_output_streams; i++) {
3505 ost = output_streams[i];
3506 of = output_files[ost->file_index];
3507 os = output_files[ost->file_index]->ctx;
3508 if (ost->is_past_recording_time ||
3509 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3511 if (ost->frame_number >= ost->max_frames) {
3513 for (j = 0; j < of->ctx->nb_streams; j++)
3514 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3517 past_recording_time = 0;
3519 if (past_recording_time)
3522 /* select the stream that we must read now by looking at the
3523 smallest output pts */
3525 for (i = 0; i < nb_input_streams; i++) {
3527 ist = input_streams[i];
3529 if (ist->discard || no_packet[ist->file_index])
3531 if (!input_files[ist->file_index]->eof_reached) {
3532 if (ipts < ipts_min) {
3534 file_index = ist->file_index;
3538 /* if none, if is finished */
3539 if (file_index < 0) {
3540 if (no_packet_count) {
3541 no_packet_count = 0;
3542 memset(no_packet, 0, nb_input_files);
3549 /* read a frame from it and output it in the fifo */
3550 is = input_files[file_index]->ctx;
3551 ret = av_read_frame(is, &pkt);
3552 if (ret == AVERROR(EAGAIN)) {
3553 no_packet[file_index] = 1;
3558 input_files[file_index]->eof_reached = 1;
3560 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3561 ist = input_streams[input_files[file_index]->ist_index + i];
3562 if (ist->decoding_needed)
3563 output_packet(ist, NULL);
3572 no_packet_count = 0;
3573 memset(no_packet, 0, nb_input_files);
3576 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3577 is->streams[pkt.stream_index]);
3579 /* the following test is needed in case new streams appear
3580 dynamically in stream : we ignore them */
3581 if (pkt.stream_index >= input_files[file_index]->nb_streams)
3582 goto discard_packet;
3583 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3584 ist = input_streams[ist_index];
3586 goto discard_packet;
3588 if (pkt.dts != AV_NOPTS_VALUE)
3589 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3590 if (pkt.pts != AV_NOPTS_VALUE)
3591 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3593 if (pkt.pts != AV_NOPTS_VALUE)
3594 pkt.pts *= ist->ts_scale;
3595 if (pkt.dts != AV_NOPTS_VALUE)
3596 pkt.dts *= ist->ts_scale;
3599 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3600 "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",
3601 ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3602 av_ts2str(ist->next_dts), av_ts2timestr(ist->next_dts, &ist->st->time_base),
3603 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3604 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3605 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3606 input_files[ist->file_index]->ts_offset);
3609 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3610 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3611 int64_t delta = pkt_dts - ist->next_dts;
3612 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3613 if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3614 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3615 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3616 pkt_dts+1<ist->pts){
3617 input_files[ist->file_index]->ts_offset -= delta;
3618 av_log(NULL, AV_LOG_DEBUG,
3619 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3620 delta, input_files[ist->file_index]->ts_offset);
3621 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3622 if (pkt.pts != AV_NOPTS_VALUE)
3623 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3626 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3627 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3628 pkt_dts+1<ist->pts){
3629 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3630 pkt.dts = AV_NOPTS_VALUE;
3632 if (pkt.pts != AV_NOPTS_VALUE){
3633 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3634 delta = pkt_pts - ist->next_dts;
3635 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3636 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3637 pkt_pts+1<ist->pts) {
3638 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3639 pkt.pts = AV_NOPTS_VALUE;
3645 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3646 if (output_packet(ist, &pkt) < 0 ||
3647 ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3648 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3649 ist->file_index, ist->st->index);
3652 av_free_packet(&pkt);
3657 av_free_packet(&pkt);
3659 /* dump report by using the output first video and audio streams */
3660 print_report(0, timer_start, cur_time);
3663 /* at the end of stream, we must flush the decoder buffers */
3664 for (i = 0; i < nb_input_streams; i++) {
3665 ist = input_streams[i];
3666 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3667 output_packet(ist, NULL);
3675 /* write the trailer if needed and close file */
3676 for (i = 0; i < nb_output_files; i++) {
3677 os = output_files[i]->ctx;
3678 av_write_trailer(os);
3681 /* dump report by using the first video and audio streams */
3682 print_report(1, timer_start, av_gettime());
3684 /* close each encoder */
3685 for (i = 0; i < nb_output_streams; i++) {
3686 ost = output_streams[i];
3687 if (ost->encoding_needed) {
3688 av_freep(&ost->st->codec->stats_in);
3689 avcodec_close(ost->st->codec);
3693 /* close each decoder */
3694 for (i = 0; i < nb_input_streams; i++) {
3695 ist = input_streams[i];
3696 if (ist->decoding_needed) {
3697 avcodec_close(ist->st->codec);
3705 av_freep(&no_packet);
3707 if (output_streams) {
3708 for (i = 0; i < nb_output_streams; i++) {
3709 ost = output_streams[i];
3711 if (ost->stream_copy)
3712 av_freep(&ost->st->codec->extradata);
3714 fclose(ost->logfile);
3715 ost->logfile = NULL;
3717 av_fifo_free(ost->fifo); /* works even if fifo is not
3718 initialized but set to zero */
3719 av_freep(&ost->st->codec->subtitle_header);
3720 av_free(ost->forced_kf_pts);
3721 swr_free(&ost->swr);
3722 av_dict_free(&ost->opts);
3729 static int opt_frame_crop(const char *opt, const char *arg)
3731 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3732 return AVERROR(EINVAL);
3735 static int opt_pad(const char *opt, const char *arg)
3737 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3741 static int opt_video_channel(const char *opt, const char *arg)
3743 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3744 return opt_default("channel", arg);
3747 static int opt_video_standard(const char *opt, const char *arg)
3749 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3750 return opt_default("standard", arg);
3753 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3755 audio_codec_name = arg;
3756 return parse_option(o, "codec:a", arg, options);
3759 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3761 video_codec_name = arg;
3762 return parse_option(o, "codec:v", arg, options);
3765 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3767 subtitle_codec_name = arg;
3768 return parse_option(o, "codec:s", arg, options);
3771 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3773 return parse_option(o, "codec:d", arg, options);
3776 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3778 StreamMap *m = NULL;
3779 int i, negative = 0, file_idx;
3780 int sync_file_idx = -1, sync_stream_idx = 0;
3788 map = av_strdup(arg);
3790 /* parse sync stream first, just pick first matching stream */
3791 if (sync = strchr(map, ',')) {
3793 sync_file_idx = strtol(sync + 1, &sync, 0);
3794 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3795 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3800 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3801 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3802 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3803 sync_stream_idx = i;
3806 if (i == input_files[sync_file_idx]->nb_streams) {
3807 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3808 "match any streams.\n", arg);
3814 if (map[0] == '[') {
3815 /* this mapping refers to lavfi output */
3816 const char *c = map + 1;
3817 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3818 &o->nb_stream_maps, o->nb_stream_maps + 1);
3819 m = &o->stream_maps[o->nb_stream_maps - 1];
3820 m->linklabel = av_get_token(&c, "]");
3821 if (!m->linklabel) {
3822 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3826 file_idx = strtol(map, &p, 0);
3827 if (file_idx >= nb_input_files || file_idx < 0) {
3828 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3832 /* disable some already defined maps */
3833 for (i = 0; i < o->nb_stream_maps; i++) {
3834 m = &o->stream_maps[i];
3835 if (file_idx == m->file_index &&
3836 check_stream_specifier(input_files[m->file_index]->ctx,
3837 input_files[m->file_index]->ctx->streams[m->stream_index],
3838 *p == ':' ? p + 1 : p) > 0)
3842 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3843 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3844 *p == ':' ? p + 1 : p) <= 0)
3846 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3847 &o->nb_stream_maps, o->nb_stream_maps + 1);
3848 m = &o->stream_maps[o->nb_stream_maps - 1];
3850 m->file_index = file_idx;
3851 m->stream_index = i;
3853 if (sync_file_idx >= 0) {
3854 m->sync_file_index = sync_file_idx;
3855 m->sync_stream_index = sync_stream_idx;
3857 m->sync_file_index = file_idx;
3858 m->sync_stream_index = i;
3864 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3872 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3874 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3875 &o->nb_attachments, o->nb_attachments + 1);
3876 o->attachments[o->nb_attachments - 1] = arg;
3880 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3886 o->audio_channel_maps =
3887 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3888 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3889 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3891 /* muted channel syntax */
3892 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3893 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3894 m->file_idx = m->stream_idx = -1;
3896 m->ofile_idx = m->ostream_idx = -1;
3901 n = sscanf(arg, "%d.%d.%d:%d.%d",
3902 &m->file_idx, &m->stream_idx, &m->channel_idx,
3903 &m->ofile_idx, &m->ostream_idx);
3905 if (n != 3 && n != 5) {
3906 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3907 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3911 if (n != 5) // only file.stream.channel specified
3912 m->ofile_idx = m->ostream_idx = -1;
3915 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3916 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3920 if (m->stream_idx < 0 ||
3921 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
3922 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3923 m->file_idx, m->stream_idx);
3926 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
3927 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3928 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3929 m->file_idx, m->stream_idx);
3932 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3933 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3934 m->file_idx, m->stream_idx, m->channel_idx);
3941 * Parse a metadata specifier in arg.
3942 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3943 * @param index for type c/p, chapter/program index is written here
3944 * @param stream_spec for type s, the stream specifier is written here
3946 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3954 if (*(++arg) && *arg != ':') {
3955 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3958 *stream_spec = *arg == ':' ? arg + 1 : "";
3962 if (*(++arg) == ':')
3963 *index = strtol(++arg, NULL, 0);
3966 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3973 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3975 AVDictionary **meta_in = NULL;
3976 AVDictionary **meta_out = NULL;
3978 char type_in, type_out;
3979 const char *istream_spec = NULL, *ostream_spec = NULL;
3980 int idx_in = 0, idx_out = 0;
3982 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3983 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3986 if (type_out == 'g' || !*outspec)
3987 o->metadata_global_manual = 1;
3988 if (type_out == 's' || !*outspec)
3989 o->metadata_streams_manual = 1;
3990 if (type_out == 'c' || !*outspec)
3991 o->metadata_chapters_manual = 1;
3995 if (type_in == 'g' || type_out == 'g')
3996 o->metadata_global_manual = 1;
3997 if (type_in == 's' || type_out == 's')
3998 o->metadata_streams_manual = 1;
3999 if (type_in == 'c' || type_out == 'c')
4000 o->metadata_chapters_manual = 1;
4002 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4003 if ((index) < 0 || (index) >= (nb_elems)) {\
4004 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
4009 #define SET_DICT(type, meta, context, index)\
4012 meta = &context->metadata;\
4015 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
4016 meta = &context->chapters[index]->metadata;\
4019 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
4020 meta = &context->programs[index]->metadata;\
4024 SET_DICT(type_in, meta_in, ic, idx_in);
4025 SET_DICT(type_out, meta_out, oc, idx_out);
4027 /* for input streams choose first matching stream */
4028 if (type_in == 's') {
4029 for (i = 0; i < ic->nb_streams; i++) {
4030 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
4031 meta_in = &ic->streams[i]->metadata;
4037 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
4042 if (type_out == 's') {
4043 for (i = 0; i < oc->nb_streams; i++) {
4044 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
4045 meta_out = &oc->streams[i]->metadata;
4046 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4051 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4056 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
4059 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
4060 struct tm time = *gmtime((time_t*)&recording_timestamp);
4061 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
4062 parse_option(o, "metadata", buf, options);
4064 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
4065 "tag instead.\n", opt);
4069 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
4071 const char *codec_string = encoder ? "encoder" : "decoder";
4075 avcodec_find_encoder_by_name(name) :
4076 avcodec_find_decoder_by_name(name);
4078 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4081 if (codec->type != type) {
4082 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4088 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4090 char *codec_name = NULL;
4092 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4094 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4095 st->codec->codec_id = codec->id;
4098 return avcodec_find_decoder(st->codec->codec_id);
4102 * Add all the streams from the given input file to the global
4103 * list of input streams.
4105 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4108 char *next, *codec_tag = NULL;
4110 for (i = 0; i < ic->nb_streams; i++) {
4111 AVStream *st = ic->streams[i];
4112 AVCodecContext *dec = st->codec;
4113 InputStream *ist = av_mallocz(sizeof(*ist));
4118 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4119 input_streams[nb_input_streams - 1] = ist;
4122 ist->file_index = nb_input_files;
4124 st->discard = AVDISCARD_ALL;
4125 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
4127 ist->ts_scale = 1.0;
4128 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4130 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4132 uint32_t tag = strtol(codec_tag, &next, 0);
4134 tag = AV_RL32(codec_tag);
4135 st->codec->codec_tag = tag;
4138 ist->dec = choose_decoder(o, ic, st);
4140 switch (dec->codec_type) {
4141 case AVMEDIA_TYPE_VIDEO:
4143 ist->dec = avcodec_find_decoder(dec->codec_id);
4145 dec->flags |= CODEC_FLAG_EMU_EDGE;
4148 ist->resample_height = dec->height;
4149 ist->resample_width = dec->width;
4150 ist->resample_pix_fmt = dec->pix_fmt;
4153 case AVMEDIA_TYPE_AUDIO:
4154 case AVMEDIA_TYPE_DATA:
4155 case AVMEDIA_TYPE_SUBTITLE:
4157 ist->dec = avcodec_find_decoder(dec->codec_id);
4159 case AVMEDIA_TYPE_ATTACHMENT:
4160 case AVMEDIA_TYPE_UNKNOWN:
4168 static void assert_file_overwrite(const char *filename)
4170 if ((!file_overwrite || no_file_overwrite) &&
4171 (strchr(filename, ':') == NULL || filename[1] == ':' ||
4172 av_strstart(filename, "file:", NULL))) {
4173 if (avio_check(filename, 0) == 0) {
4174 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
4175 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4178 signal(SIGINT, SIG_DFL);
4179 if (!read_yesno()) {
4180 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4186 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4193 static void dump_attachment(AVStream *st, const char *filename)
4196 AVIOContext *out = NULL;
4197 AVDictionaryEntry *e;
4199 if (!st->codec->extradata_size) {
4200 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4201 nb_input_files - 1, st->index);
4204 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4205 filename = e->value;
4207 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4208 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4212 assert_file_overwrite(filename);
4214 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4215 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4220 avio_write(out, st->codec->extradata, st->codec->extradata_size);
4225 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4227 AVFormatContext *ic;
4228 AVInputFormat *file_iformat = NULL;
4232 AVDictionary **opts;
4233 int orig_nb_streams; // number of streams before avformat_find_stream_info
4236 if (!(file_iformat = av_find_input_format(o->format))) {
4237 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4242 if (!strcmp(filename, "-"))
4245 using_stdin |= !strncmp(filename, "pipe:", 5) ||
4246 !strcmp(filename, "/dev/stdin");
4248 /* get default parameters from command line */
4249 ic = avformat_alloc_context();
4251 print_error(filename, AVERROR(ENOMEM));
4254 if (o->nb_audio_sample_rate) {
4255 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4256 av_dict_set(&format_opts, "sample_rate", buf, 0);
4258 if (o->nb_audio_channels) {
4259 /* because we set audio_channels based on both the "ac" and
4260 * "channel_layout" options, we need to check that the specified
4261 * demuxer actually has the "channels" option before setting it */
4262 if (file_iformat && file_iformat->priv_class &&
4263 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4264 AV_OPT_SEARCH_FAKE_OBJ)) {
4265 snprintf(buf, sizeof(buf), "%d",
4266 o->audio_channels[o->nb_audio_channels - 1].u.i);
4267 av_dict_set(&format_opts, "channels", buf, 0);
4270 if (o->nb_frame_rates) {
4271 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4273 if (o->nb_frame_sizes) {
4274 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4276 if (o->nb_frame_pix_fmts)
4277 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4279 ic->video_codec_id = video_codec_name ?
4280 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
4281 ic->audio_codec_id = audio_codec_name ?
4282 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
4283 ic->subtitle_codec_id= subtitle_codec_name ?
4284 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4285 ic->flags |= AVFMT_FLAG_NONBLOCK;
4286 ic->interrupt_callback = int_cb;
4288 /* open the input file with generic avformat function */
4289 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4291 print_error(filename, err);
4294 assert_avoptions(format_opts);
4296 /* apply forced codec ids */
4297 for (i = 0; i < ic->nb_streams; i++)
4298 choose_decoder(o, ic, ic->streams[i]);
4300 /* Set AVCodecContext options for avformat_find_stream_info */
4301 opts = setup_find_stream_info_opts(ic, codec_opts);
4302 orig_nb_streams = ic->nb_streams;
4304 /* If not enough info to get the stream parameters, we decode the
4305 first frames to get it. (used in mpeg case for example) */
4306 ret = avformat_find_stream_info(ic, opts);
4308 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4309 avformat_close_input(&ic);
4313 timestamp = o->start_time;
4314 /* add the stream start time */
4315 if (ic->start_time != AV_NOPTS_VALUE)
4316 timestamp += ic->start_time;
4318 /* if seeking requested, we execute it */
4319 if (o->start_time != 0) {
4320 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4322 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4323 filename, (double)timestamp / AV_TIME_BASE);
4327 /* update the current parameters so that they match the one of the input stream */
4328 add_input_streams(o, ic);
4330 /* dump the file content */
4331 av_dump_format(ic, nb_input_files, filename, 0);
4333 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4334 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4337 input_files[nb_input_files - 1]->ctx = ic;
4338 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
4339 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4340 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4341 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
4343 for (i = 0; i < o->nb_dump_attachment; i++) {
4346 for (j = 0; j < ic->nb_streams; j++) {
4347 AVStream *st = ic->streams[j];
4349 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4350 dump_attachment(st, o->dump_attachment[i].u.str);
4354 for (i = 0; i < orig_nb_streams; i++)
4355 av_dict_free(&opts[i]);
4358 reset_options(o, 1);
4362 static void parse_forced_key_frames(char *kf, OutputStream *ost)
4367 for (p = kf; *p; p++)
4370 ost->forced_kf_count = n;
4371 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
4372 if (!ost->forced_kf_pts) {
4373 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
4377 for (i = 0; i < n; i++) {
4378 char *next = strchr(p, ',');
4379 if (next) *next++ = 0;
4380 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
4385 static uint8_t *get_line(AVIOContext *s)
4391 if (avio_open_dyn_buf(&line) < 0) {
4392 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4396 while ((c = avio_r8(s)) && c != '\n')
4399 avio_close_dyn_buf(line, &buf);
4404 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4407 char filename[1000];
4408 const char *base[3] = { getenv("AVCONV_DATADIR"),
4413 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4417 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4418 i != 1 ? "" : "/.avconv", codec_name, preset_name);
4419 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4422 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4423 i != 1 ? "" : "/.avconv", preset_name);
4424 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4430 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4432 char *codec_name = NULL;
4434 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4436 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4437 NULL, ost->st->codec->codec_type);
4438 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4439 } else if (!strcmp(codec_name, "copy"))
4440 ost->stream_copy = 1;
4442 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4443 ost->st->codec->codec_id = ost->enc->id;
4447 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4450 AVStream *st = avformat_new_stream(oc, NULL);
4451 int idx = oc->nb_streams - 1, ret = 0;
4452 char *bsf = NULL, *next, *codec_tag = NULL;
4453 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4455 char *buf = NULL, *arg = NULL, *preset = NULL;
4456 AVIOContext *s = NULL;
4459 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4463 if (oc->nb_streams - 1 < o->nb_streamid_map)
4464 st->id = o->streamid_map[oc->nb_streams - 1];
4466 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4467 nb_output_streams + 1);
4468 if (!(ost = av_mallocz(sizeof(*ost))))
4470 output_streams[nb_output_streams - 1] = ost;
4472 ost->file_index = nb_output_files;
4475 st->codec->codec_type = type;
4476 choose_encoder(o, oc, ost);
4478 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
4481 avcodec_get_context_defaults3(st->codec, ost->enc);
4482 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4484 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4485 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4488 if (!buf[0] || buf[0] == '#') {
4492 if (!(arg = strchr(buf, '='))) {
4493 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4497 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4499 } while (!s->eof_reached);
4503 av_log(NULL, AV_LOG_FATAL,
4504 "Preset %s specified for stream %d:%d, but could not be opened.\n",
4505 preset, ost->file_index, ost->index);
4509 ost->max_frames = INT64_MAX;
4510 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4512 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4514 if (next = strchr(bsf, ','))
4516 if (!(bsfc = av_bitstream_filter_init(bsf))) {
4517 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4521 bsfc_prev->next = bsfc;
4523 ost->bitstream_filters = bsfc;
4529 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4531 uint32_t tag = strtol(codec_tag, &next, 0);
4533 tag = AV_RL32(codec_tag);
4534 st->codec->codec_tag = tag;
4537 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4538 if (qscale >= 0 || same_quant) {
4539 st->codec->flags |= CODEC_FLAG_QSCALE;
4540 st->codec->global_quality = FF_QP2LAMBDA * qscale;
4543 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4544 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4546 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4547 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4548 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4550 ost->source_index = source_index;
4551 if (source_index >= 0) {
4552 ost->sync_ist = input_streams[source_index];
4553 input_streams[source_index]->discard = 0;
4554 input_streams[source_index]->st->discard = AVDISCARD_NONE;
4557 ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
4562 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4565 const char *p = str;
4572 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4579 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4583 AVCodecContext *video_enc;
4585 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4587 video_enc = st->codec;
4589 if (!ost->stream_copy) {
4590 const char *p = NULL;
4591 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
4592 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4593 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
4596 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4597 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4598 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4602 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4603 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4604 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4608 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4609 if (frame_aspect_ratio) {
4611 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4612 q.num <= 0 || q.den <= 0) {
4613 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4616 ost->frame_aspect_ratio = av_q2d(q);
4619 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4620 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4621 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4622 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4625 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4628 video_enc->gop_size = 0;
4629 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4631 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4632 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4635 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4637 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4639 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4640 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4643 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4646 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4647 for (i = 0; p; i++) {
4649 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4651 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4654 /* FIXME realloc failure */
4655 video_enc->rc_override =
4656 av_realloc(video_enc->rc_override,
4657 sizeof(RcOverride) * (i + 1));
4658 video_enc->rc_override[i].start_frame = start;
4659 video_enc->rc_override[i].end_frame = end;
4661 video_enc->rc_override[i].qscale = q;
4662 video_enc->rc_override[i].quality_factor = 1.0;
4665 video_enc->rc_override[i].qscale = 0;
4666 video_enc->rc_override[i].quality_factor = -q/100.0;
4671 video_enc->rc_override_count = i;
4672 if (!video_enc->rc_initial_buffer_occupancy)
4673 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4674 video_enc->intra_dc_precision = intra_dc_precision - 8;
4677 video_enc->flags|= CODEC_FLAG_PSNR;
4682 video_enc->flags |= CODEC_FLAG_PASS1;
4685 video_enc->flags |= CODEC_FLAG_PASS2;
4689 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4690 if (forced_key_frames)
4691 parse_forced_key_frames(forced_key_frames, ost);
4693 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4695 ost->top_field_first = -1;
4696 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4698 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4700 ost->avfilter = av_strdup(filters);
4702 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4708 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4713 AVCodecContext *audio_enc;
4715 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4718 audio_enc = st->codec;
4719 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4721 if (!ost->stream_copy) {
4722 char *sample_fmt = NULL;
4724 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4726 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4728 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4729 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4733 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4735 ost->rematrix_volume=1.0;
4736 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4739 /* check for channel mapping for this audio stream */
4740 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4741 AudioChannelMap *map = &o->audio_channel_maps[n];
4742 InputStream *ist = input_streams[ost->source_index];
4743 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4744 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4745 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4746 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4747 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4749 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4750 ost->file_index, ost->st->index);
4757 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4761 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4762 if (!ost->stream_copy) {
4763 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4770 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4772 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4773 ost->stream_copy = 1;
4777 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4781 AVCodecContext *subtitle_enc;
4783 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4785 subtitle_enc = st->codec;
4787 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4789 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4794 /* arg format is "output-stream-index:streamid-value". */
4795 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4801 av_strlcpy(idx_str, arg, sizeof(idx_str));
4802 p = strchr(idx_str, ':');
4804 av_log(NULL, AV_LOG_FATAL,
4805 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4810 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4811 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4812 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4816 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4818 AVFormatContext *is = ifile->ctx;
4819 AVFormatContext *os = ofile->ctx;
4822 for (i = 0; i < is->nb_chapters; i++) {
4823 AVChapter *in_ch = is->chapters[i], *out_ch;
4824 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4825 AV_TIME_BASE_Q, in_ch->time_base);
4826 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4827 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4830 if (in_ch->end < ts_off)
4832 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4835 out_ch = av_mallocz(sizeof(AVChapter));
4837 return AVERROR(ENOMEM);
4839 out_ch->id = in_ch->id;
4840 out_ch->time_base = in_ch->time_base;
4841 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4842 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4845 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4848 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4850 return AVERROR(ENOMEM);
4851 os->chapters[os->nb_chapters - 1] = out_ch;
4856 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4859 AVFormatContext *ic = avformat_alloc_context();
4861 ic->interrupt_callback = int_cb;
4862 err = avformat_open_input(&ic, filename, NULL, NULL);
4865 /* copy stream format */
4866 for(i=0;i<ic->nb_streams;i++) {
4870 AVCodecContext *avctx;
4872 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4873 ost = new_output_stream(o, s, codec->type, -1);
4878 // FIXME: a more elegant solution is needed
4879 memcpy(st, ic->streams[i], sizeof(AVStream));
4881 st->info = av_malloc(sizeof(*st->info));
4882 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4884 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4886 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4887 choose_sample_fmt(st, codec);
4888 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4889 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4892 avformat_close_input(&ic);
4896 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4897 AVFormatContext *oc)
4901 if (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type != AVMEDIA_TYPE_VIDEO) {
4902 av_log(NULL, AV_LOG_FATAL, "Only video filters are supported currently.\n");
4906 ost = new_video_stream(o, oc, -1);
4907 ost->source_index = -1;
4908 ost->filter = ofilter;
4912 if (ost->stream_copy) {
4913 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4914 "which is fed from a complex filtergraph. Filtering and streamcopy "
4915 "cannot be used together.\n", ost->file_index, ost->index);
4919 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4920 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4923 avfilter_inout_free(&ofilter->out_tmp);
4926 static void opt_output_file(void *optctx, const char *filename)
4928 OptionsContext *o = optctx;
4929 AVFormatContext *oc;
4931 AVOutputFormat *file_oformat;
4935 if (configure_complex_filters() < 0) {
4936 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4940 if (!strcmp(filename, "-"))
4943 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4945 print_error(filename, err);
4948 file_oformat= oc->oformat;
4949 oc->interrupt_callback = int_cb;
4951 /* create streams for all unlabeled output pads */
4952 for (i = 0; i < nb_filtergraphs; i++) {
4953 FilterGraph *fg = filtergraphs[i];
4954 for (j = 0; j < fg->nb_outputs; j++) {
4955 OutputFilter *ofilter = fg->outputs[j];
4957 if (!ofilter->out_tmp || ofilter->out_tmp->name)
4960 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4961 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
4962 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
4963 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
4965 init_output_filter(ofilter, o, oc);
4969 if (!strcmp(file_oformat->name, "ffm") &&
4970 av_strstart(filename, "http:", NULL)) {
4972 /* special case for files sent to ffserver: we get the stream
4973 parameters from ffserver */
4974 int err = read_ffserver_streams(o, oc, filename);
4976 print_error(filename, err);
4979 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4980 ost = output_streams[j];
4981 for (i = 0; i < nb_input_streams; i++) {
4982 ist = input_streams[i];
4983 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4985 ost->source_index= i;
4987 ist->st->discard = AVDISCARD_NONE;
4992 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));
4996 } else if (!o->nb_stream_maps) {
4997 /* pick the "best" stream of each type */
4999 /* video: highest resolution */
5000 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
5001 int area = 0, idx = -1;
5002 for (i = 0; i < nb_input_streams; i++) {
5003 ist = input_streams[i];
5004 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
5005 ist->st->codec->width * ist->st->codec->height > area) {
5006 area = ist->st->codec->width * ist->st->codec->height;
5011 new_video_stream(o, oc, idx);
5014 /* audio: most channels */
5015 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
5016 int channels = 0, idx = -1;
5017 for (i = 0; i < nb_input_streams; i++) {
5018 ist = input_streams[i];
5019 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
5020 ist->st->codec->channels > channels) {
5021 channels = ist->st->codec->channels;
5026 new_audio_stream(o, oc, idx);
5029 /* subtitles: pick first */
5030 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
5031 for (i = 0; i < nb_input_streams; i++)
5032 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
5033 new_subtitle_stream(o, oc, i);
5037 /* do something with data? */
5039 for (i = 0; i < o->nb_stream_maps; i++) {
5040 StreamMap *map = &o->stream_maps[i];
5041 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5046 if (map->linklabel) {
5048 OutputFilter *ofilter = NULL;
5051 for (j = 0; j < nb_filtergraphs; j++) {
5052 fg = filtergraphs[j];
5053 for (k = 0; k < fg->nb_outputs; k++) {
5054 AVFilterInOut *out = fg->outputs[k]->out_tmp;
5055 if (out && !strcmp(out->name, map->linklabel)) {
5056 ofilter = fg->outputs[k];
5063 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5064 "in any defined filter graph.\n", map->linklabel);
5067 init_output_filter(ofilter, o, oc);
5069 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5070 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5072 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5074 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5076 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5079 switch (ist->st->codec->codec_type) {
5080 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
5081 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
5082 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
5083 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
5084 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5086 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5087 map->file_index, map->stream_index);
5095 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5096 AVDictionaryEntry *e;
5097 ost = output_streams[i];
5099 if ( ost->stream_copy
5100 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5101 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5102 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5106 /* handle attached files */
5107 for (i = 0; i < o->nb_attachments; i++) {
5109 uint8_t *attachment;
5113 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5114 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5118 if ((len = avio_size(pb)) <= 0) {
5119 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5123 if (!(attachment = av_malloc(len))) {
5124 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5128 avio_read(pb, attachment, len);
5130 ost = new_attachment_stream(o, oc, -1);
5131 ost->stream_copy = 0;
5132 ost->attachment_filename = o->attachments[i];
5133 ost->st->codec->extradata = attachment;
5134 ost->st->codec->extradata_size = len;
5136 p = strrchr(o->attachments[i], '/');
5137 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5141 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5142 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5145 output_files[nb_output_files - 1]->ctx = oc;
5146 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
5147 output_files[nb_output_files - 1]->recording_time = o->recording_time;
5148 if (o->recording_time != INT64_MAX)
5149 oc->duration = o->recording_time;
5150 output_files[nb_output_files - 1]->start_time = o->start_time;
5151 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5152 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5154 /* check filename in case of an image number is expected */
5155 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5156 if (!av_filename_number_test(oc->filename)) {
5157 print_error(oc->filename, AVERROR(EINVAL));
5162 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5163 /* test if it already exists to avoid losing precious files */
5164 assert_file_overwrite(filename);
5167 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5168 &oc->interrupt_callback,
5169 &output_files[nb_output_files - 1]->opts)) < 0) {
5170 print_error(filename, err);
5175 if (o->mux_preload) {
5177 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5178 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5180 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5183 for (i = 0; i < o->nb_metadata_map; i++) {
5185 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5187 if (in_file_index >= nb_input_files) {
5188 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5191 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5195 if (o->chapters_input_file >= nb_input_files) {
5196 if (o->chapters_input_file == INT_MAX) {
5197 /* copy chapters from the first input file that has them*/
5198 o->chapters_input_file = -1;
5199 for (i = 0; i < nb_input_files; i++)
5200 if (input_files[i]->ctx->nb_chapters) {
5201 o->chapters_input_file = i;
5205 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5206 o->chapters_input_file);
5210 if (o->chapters_input_file >= 0)
5211 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5212 !o->metadata_chapters_manual);
5214 /* copy global metadata by default */
5215 if (!o->metadata_global_manual && nb_input_files){
5216 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5217 AV_DICT_DONT_OVERWRITE);
5218 if(o->recording_time != INT64_MAX)
5219 av_dict_set(&oc->metadata, "duration", NULL, 0);
5221 if (!o->metadata_streams_manual)
5222 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5224 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
5226 ist = input_streams[output_streams[i]->source_index];
5227 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5230 /* process manually set metadata */
5231 for (i = 0; i < o->nb_metadata; i++) {
5234 const char *stream_spec;
5235 int index = 0, j, ret = 0;
5237 val = strchr(o->metadata[i].u.str, '=');
5239 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5240 o->metadata[i].u.str);
5245 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5247 for (j = 0; j < oc->nb_streams; j++) {
5248 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5249 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5253 printf("ret %d, stream_spec %s\n", ret, stream_spec);
5261 if (index < 0 || index >= oc->nb_chapters) {
5262 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5265 m = &oc->chapters[index]->metadata;
5268 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5271 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5275 reset_options(o, 0);
5278 /* same option as mencoder */
5279 static int opt_pass(const char *opt, const char *arg)
5281 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5285 static int64_t getmaxrss(void)
5287 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5288 struct rusage rusage;
5289 getrusage(RUSAGE_SELF, &rusage);
5290 return (int64_t)rusage.ru_maxrss * 1024;
5291 #elif HAVE_GETPROCESSMEMORYINFO
5293 PROCESS_MEMORY_COUNTERS memcounters;
5294 proc = GetCurrentProcess();
5295 memcounters.cb = sizeof(memcounters);
5296 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5297 return memcounters.PeakPagefileUsage;
5303 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5305 return parse_option(o, "q:a", arg, options);
5308 static void show_usage(void)
5310 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5311 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5312 av_log(NULL, AV_LOG_INFO, "\n");
5315 static int opt_help(const char *opt, const char *arg)
5317 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5318 av_log_set_callback(log_callback_help);
5320 show_help_options(options, "Main options:\n",
5321 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5322 show_help_options(options, "\nAdvanced options:\n",
5323 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5325 show_help_options(options, "\nVideo options:\n",
5326 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5328 show_help_options(options, "\nAdvanced Video options:\n",
5329 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5330 OPT_VIDEO | OPT_EXPERT);
5331 show_help_options(options, "\nAudio options:\n",
5332 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5334 show_help_options(options, "\nAdvanced Audio options:\n",
5335 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5336 OPT_AUDIO | OPT_EXPERT);
5337 show_help_options(options, "\nSubtitle options:\n",
5338 OPT_SUBTITLE | OPT_GRAB,
5340 show_help_options(options, "\nAudio/Video grab options:\n",
5344 show_help_children(avcodec_get_class(), flags);
5345 show_help_children(avformat_get_class(), flags);
5346 show_help_children(sws_get_class(), flags);
5351 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5353 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5354 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5356 if (!strncmp(arg, "pal-", 4)) {
5359 } else if (!strncmp(arg, "ntsc-", 5)) {
5362 } else if (!strncmp(arg, "film-", 5)) {
5366 /* Try to determine PAL/NTSC by peeking in the input files */
5367 if (nb_input_files) {
5369 for (j = 0; j < nb_input_files; j++) {
5370 for (i = 0; i < input_files[j]->nb_streams; i++) {
5371 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5372 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5374 fr = c->time_base.den * 1000 / c->time_base.num;
5378 } else if ((fr == 29970) || (fr == 23976)) {
5383 if (norm != UNKNOWN)
5387 if (norm != UNKNOWN)
5388 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5391 if (norm == UNKNOWN) {
5392 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5393 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5394 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5398 if (!strcmp(arg, "vcd")) {
5399 opt_video_codec(o, "c:v", "mpeg1video");
5400 opt_audio_codec(o, "c:a", "mp2");
5401 parse_option(o, "f", "vcd", options);
5403 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5404 parse_option(o, "r", frame_rates[norm], options);
5405 opt_default("g", norm == PAL ? "15" : "18");
5407 opt_default("b:v", "1150000");
5408 opt_default("maxrate", "1150000");
5409 opt_default("minrate", "1150000");
5410 opt_default("bufsize", "327680"); // 40*1024*8;
5412 opt_default("b:a", "224000");
5413 parse_option(o, "ar", "44100", options);
5414 parse_option(o, "ac", "2", options);
5416 opt_default("packetsize", "2324");
5417 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5419 /* We have to offset the PTS, so that it is consistent with the SCR.
5420 SCR starts at 36000, but the first two packs contain only padding
5421 and the first pack from the other stream, respectively, may also have
5422 been written before.
5423 So the real data starts at SCR 36000+3*1200. */
5424 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5425 } else if (!strcmp(arg, "svcd")) {
5427 opt_video_codec(o, "c:v", "mpeg2video");
5428 opt_audio_codec(o, "c:a", "mp2");
5429 parse_option(o, "f", "svcd", options);
5431 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5432 parse_option(o, "r", frame_rates[norm], options);
5433 parse_option(o, "pix_fmt", "yuv420p", options);
5434 opt_default("g", norm == PAL ? "15" : "18");
5436 opt_default("b:v", "2040000");
5437 opt_default("maxrate", "2516000");
5438 opt_default("minrate", "0"); // 1145000;
5439 opt_default("bufsize", "1835008"); // 224*1024*8;
5440 opt_default("scan_offset", "1");
5443 opt_default("b:a", "224000");
5444 parse_option(o, "ar", "44100", options);
5446 opt_default("packetsize", "2324");
5448 } else if (!strcmp(arg, "dvd")) {
5450 opt_video_codec(o, "c:v", "mpeg2video");
5451 opt_audio_codec(o, "c:a", "ac3");
5452 parse_option(o, "f", "dvd", options);
5454 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5455 parse_option(o, "r", frame_rates[norm], options);
5456 parse_option(o, "pix_fmt", "yuv420p", options);
5457 opt_default("g", norm == PAL ? "15" : "18");
5459 opt_default("b:v", "6000000");
5460 opt_default("maxrate", "9000000");
5461 opt_default("minrate", "0"); // 1500000;
5462 opt_default("bufsize", "1835008"); // 224*1024*8;
5464 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5465 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5467 opt_default("b:a", "448000");
5468 parse_option(o, "ar", "48000", options);
5470 } else if (!strncmp(arg, "dv", 2)) {
5472 parse_option(o, "f", "dv", options);
5474 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5475 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5476 norm == PAL ? "yuv420p" : "yuv411p", options);
5477 parse_option(o, "r", frame_rates[norm], options);
5479 parse_option(o, "ar", "48000", options);
5480 parse_option(o, "ac", "2", options);
5483 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5484 return AVERROR(EINVAL);
5489 static int opt_vstats_file(const char *opt, const char *arg)
5491 av_free (vstats_filename);
5492 vstats_filename = av_strdup (arg);
5496 static int opt_vstats(const char *opt, const char *arg)
5499 time_t today2 = time(NULL);
5500 struct tm *today = localtime(&today2);
5502 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5504 return opt_vstats_file(opt, filename);
5507 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5509 return parse_option(o, "frames:v", arg, options);
5512 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5514 return parse_option(o, "frames:a", arg, options);
5517 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5519 return parse_option(o, "frames:d", arg, options);
5522 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5525 char filename[1000], line[1000], tmp_line[1000];
5526 const char *codec_name = *opt == 'v' ? video_codec_name :
5527 *opt == 'a' ? audio_codec_name :
5528 subtitle_codec_name;
5530 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5531 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5532 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5534 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5538 while (fgets(line, sizeof(line), f)) {
5539 char *key = tmp_line, *value, *endptr;
5541 if (strcspn(line, "#\n\r") == 0)
5543 strcpy(tmp_line, line);
5544 if (!av_strtok(key, "=", &value) ||
5545 !av_strtok(value, "\r\n", &endptr)) {
5546 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5549 av_log(NULL, AV_LOG_DEBUG, "ffpreset[%s]: set '%s' = '%s'\n", filename, key, value);
5551 if (!strcmp(key, "acodec")) opt_audio_codec (o, key, value);
5552 else if (!strcmp(key, "vcodec")) opt_video_codec (o, key, value);
5553 else if (!strcmp(key, "scodec")) opt_subtitle_codec(o, key, value);
5554 else if (!strcmp(key, "dcodec")) opt_data_codec (o, key, value);
5555 else if (opt_default(key, value) < 0) {
5556 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n",
5557 filename, line, key, value);
5567 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5571 static int opt_passlogfile(const char *opt, const char *arg)
5573 pass_logfilename_prefix = arg;
5574 #if CONFIG_LIBX264_ENCODER
5575 return opt_default(opt, arg);
5581 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5583 char *s = av_asprintf("%s:%c", opt + 1, *opt);
5584 int ret = parse_option(o, s, arg, options);
5589 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5591 if(!strcmp(opt, "b")){
5592 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5593 return parse_option(o, "b:v", arg, options);
5595 return opt_default(opt, arg);
5598 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5602 if(!strcmp(opt, "qscale")){
5603 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5604 return parse_option(o, "q:v", arg, options);
5606 s = av_asprintf("q%s", opt + 6);
5607 ret = parse_option(o, s, arg, options);
5612 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5614 if(!strcmp(opt, "profile")){
5615 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5616 return parse_option(o, "profile:v", arg, options);
5618 return opt_default(opt, arg);
5621 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5623 return parse_option(o, "filter:v", arg, options);
5626 static int opt_vsync(const char *opt, const char *arg)
5628 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
5629 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
5630 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5631 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
5633 if (video_sync_method == VSYNC_AUTO)
5634 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5638 static int opt_deinterlace(const char *opt, const char *arg)
5640 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5645 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5647 int idx = locate_option(argc, argv, options, "cpuflags");
5648 if (idx && argv[idx + 1])
5649 opt_cpuflags("cpuflags", argv[idx + 1]);
5652 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5654 char layout_str[32];
5657 int ret, channels, ac_str_size;
5660 layout = av_get_channel_layout(arg);
5662 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5663 return AVERROR(EINVAL);
5665 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5666 ret = opt_default(opt, layout_str);
5670 /* set 'ac' option based on channel layout */
5671 channels = av_get_channel_layout_nb_channels(layout);
5672 snprintf(layout_str, sizeof(layout_str), "%d", channels);
5673 stream_str = strchr(opt, ':');
5674 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5675 ac_str = av_mallocz(ac_str_size);
5677 return AVERROR(ENOMEM);
5678 av_strlcpy(ac_str, "ac", 3);
5680 av_strlcat(ac_str, stream_str, ac_str_size);
5681 ret = parse_option(o, ac_str, layout_str, options);
5687 static int opt_filter_complex(const char *opt, const char *arg)
5689 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5690 &nb_filtergraphs, nb_filtergraphs + 1);
5691 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5692 return AVERROR(ENOMEM);
5693 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
5694 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5698 #define OFFSET(x) offsetof(OptionsContext, x)
5699 static const OptionDef options[] = {
5701 #include "cmdutils_common_opts.h"
5702 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5703 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5704 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5705 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5706 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5707 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5708 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5709 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5710 { "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]" },
5711 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5712 "outfile[,metadata]:infile[,metadata]" },
5713 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
5714 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5715 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5716 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5717 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5718 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5719 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5720 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5721 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5722 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5723 "add timings for benchmarking" },
5724 { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5725 "add timings for each task" },
5726 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5727 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5728 "dump each input packet" },
5729 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5730 "when dumping packets, also dump the payload" },
5731 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5732 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5733 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5734 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5735 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5736 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
5737 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
5738 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5739 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5740 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5741 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5742 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5743 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5744 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5745 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5746 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5747 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5748 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5749 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5750 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5751 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5752 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5753 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5756 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5757 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5758 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5759 { "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" },
5760 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5761 { "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" },
5762 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5763 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5764 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5765 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5766 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5767 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5768 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5769 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5770 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5771 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5772 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5773 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5774 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5775 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5776 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5777 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5778 "use same quantizer as source (implies VBR)" },
5779 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5780 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5781 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5782 "this option is deprecated, use the yadif filter instead" },
5783 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5784 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5785 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5786 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5787 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5788 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5789 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5790 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5791 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5792 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5793 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5794 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5795 { "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" },
5796 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5799 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5800 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5801 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5802 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5803 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5804 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5805 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5806 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5807 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5808 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
5809 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5811 /* subtitle options */
5812 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5813 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5814 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5817 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5818 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5819 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5822 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5823 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5825 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5826 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5827 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5829 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5830 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5831 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5832 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5833 /* data codec support */
5834 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5835 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5837 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5841 int main(int argc, char **argv)
5843 OptionsContext o = { 0 };
5846 reset_options(&o, 0);
5848 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5849 parse_loglevel(argc, argv, options);
5851 if(argc>1 && !strcmp(argv[1], "-d")){
5853 av_log_set_callback(log_callback_null);
5858 avcodec_register_all();
5860 avdevice_register_all();
5862 avfilter_register_all();
5864 avformat_network_init();
5866 show_banner(argc, argv, options);
5870 parse_cpuflags(argc, argv, options);
5873 parse_options(&o, argc, argv, options, opt_output_file);
5875 if (nb_output_files <= 0 && nb_input_files == 0) {
5877 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5881 /* file converter / grab */
5882 if (nb_output_files <= 0) {
5883 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5887 if (nb_input_files == 0) {
5888 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5892 current_time = ti = getutime();
5893 if (transcode() < 0)
5895 ti = getutime() - ti;
5897 int maxrss = getmaxrss() / 1024;
5898 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);