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"
62 # include "libavfilter/vsrc_buffer.h"
64 #if HAVE_SYS_RESOURCE_H
65 #include <sys/types.h>
67 #include <sys/resource.h>
68 #elif HAVE_GETPROCESSTIMES
71 #if HAVE_GETPROCESSMEMORYINFO
77 #include <sys/select.h>
82 #include <sys/ioctl.h>
92 #include "libavutil/avassert.h"
95 #define VSYNC_PASSTHROUGH 0
98 #define VSYNC_DROP 0xff
100 const char program_name[] = "ffmpeg";
101 const int program_birth_year = 2000;
103 /* select an input stream for an output stream */
104 typedef struct StreamMap {
105 int disabled; /** 1 is this mapping is disabled by a negative map */
109 int sync_stream_index;
110 char *linklabel; /** name of an output link, for mapping lavfi outputs */
114 int file_idx, stream_idx, channel_idx; // input
115 int ofile_idx, ostream_idx; // output
118 static const OptionDef options[];
120 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
122 static int frame_bits_per_raw_sample = 0;
123 static int video_discard = 0;
124 static int same_quant = 0;
125 static int do_deinterlace = 0;
126 static int intra_dc_precision = 8;
127 static int qp_hist = 0;
128 static int intra_only = 0;
129 static const char *video_codec_name = NULL;
130 static const char *audio_codec_name = NULL;
131 static const char *subtitle_codec_name = NULL;
133 static int file_overwrite = 0;
134 static int no_file_overwrite = 0;
135 static int do_benchmark = 0;
136 static int do_benchmark_all = 0;
137 static int do_hex_dump = 0;
138 static int do_pkt_dump = 0;
139 static int do_psnr = 0;
140 static int do_pass = 0;
141 static const char *pass_logfilename_prefix;
142 static int video_sync_method = VSYNC_AUTO;
143 static int audio_sync_method = 0;
144 static float audio_drift_threshold = 0.1;
145 static int copy_ts = 0;
146 static int copy_tb = -1;
147 static int opt_shortest = 0;
148 static char *vstats_filename;
149 static FILE *vstats_file;
151 static int audio_volume = 256;
153 static int exit_on_error = 0;
154 static int using_stdin = 0;
155 static int run_as_daemon = 0;
156 static volatile int received_nb_signals = 0;
157 static int64_t video_size = 0;
158 static int64_t audio_size = 0;
159 static int64_t extra_size = 0;
160 static int nb_frames_dup = 0;
161 static int nb_frames_drop = 0;
162 static int input_sync;
164 static float dts_delta_threshold = 10;
165 static float dts_error_threshold = 3600*30;
167 static int print_stats = 1;
168 static int debug_ts = 0;
169 static int current_time;
171 static uint8_t *audio_buf;
172 static unsigned int allocated_audio_buf_size;
173 static uint8_t *async_buf;
174 static unsigned int allocated_async_buf_size;
176 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
178 typedef struct InputFilter {
179 AVFilterContext *filter;
180 struct InputStream *ist;
181 struct FilterGraph *graph;
184 typedef struct OutputFilter {
185 AVFilterContext *filter;
186 struct OutputStream *ost;
187 struct FilterGraph *graph;
189 /* temporary storage until stream maps are processed */
190 AVFilterInOut *out_tmp;
193 typedef struct FilterGraph {
195 const char *graph_desc;
197 AVFilterGraph *graph;
199 InputFilter **inputs;
201 OutputFilter **outputs;
205 typedef struct FrameBuffer {
211 enum PixelFormat pix_fmt;
214 struct InputStream *ist;
215 struct FrameBuffer *next;
218 typedef struct InputStream {
221 int discard; /* true if stream data should be discarded */
222 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
224 AVFrame *decoded_frame;
226 int64_t start; /* time when read started */
227 /* predicted dts of the next packet read for this stream or (when there are
228 * several frames in a packet) of the next frame in current packet */
230 /* dts of the last packet read for this stream */
233 int64_t next_pts; ///< synthetic pts for the next decode frame
234 int64_t pts; ///< current pts of the decoded frame
236 int is_start; /* is 1 at the start and after a discontinuity */
238 int showed_multi_packet_warning;
243 int resample_pix_fmt;
245 /* a pool of free buffers for decoded data */
246 FrameBuffer *buffer_pool;
249 /* decoded data from this stream goes into all those filters
250 * currently video only */
251 InputFilter **filters;
255 typedef struct InputFile {
256 AVFormatContext *ctx;
257 int eof_reached; /* true if eof reached */
258 int ist_index; /* index of first stream in input_streams */
259 int buffer_size; /* current total buffer size */
261 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
262 from ctx.nb_streams if new streams appear during av_read_frame() */
266 typedef struct OutputStream {
267 int file_index; /* file index */
268 int index; /* stream index in the output file */
269 int source_index; /* InputStream index */
270 AVStream *st; /* stream in the output file */
271 int encoding_needed; /* true if encoding needed for this stream */
273 /* input pts and corresponding output pts
275 struct InputStream *sync_ist; /* input stream to sync against */
276 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
277 AVBitStreamFilterContext *bitstream_filters;
280 AVFrame *output_frame;
281 AVFrame *filtered_frame;
284 AVRational frame_rate;
288 float frame_aspect_ratio;
291 /* forced key frames */
292 int64_t *forced_kf_pts;
298 int audio_channels_map[SWR_CH_MAX]; ///< list of the channels id to pick from the source stream
299 int audio_channels_mapped; ///< number of channels in audio_channels_map
300 int resample_sample_fmt;
301 int resample_channels;
302 uint64_t resample_channel_layout;
303 int resample_sample_rate;
304 float rematrix_volume;
305 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
310 OutputFilter *filter;
314 int64_t swr_dither_method;
315 double swr_dither_scale;
317 int is_past_recording_time;
319 const char *attachment_filename;
320 int copy_initial_nonkeyframes;
322 enum PixelFormat pix_fmts[2];
328 /* init terminal so that we can grab keys */
329 static struct termios oldtty;
330 static int restore_tty;
333 typedef struct OutputFile {
334 AVFormatContext *ctx;
336 int ost_index; /* index of the first stream in output_streams */
337 int64_t recording_time; /* desired length of the resulting file in microseconds */
338 int64_t start_time; /* start time in microseconds */
339 uint64_t limit_filesize; /* filesize limit expressed in bytes */
342 static InputStream **input_streams = NULL;
343 static int nb_input_streams = 0;
344 static InputFile **input_files = NULL;
345 static int nb_input_files = 0;
347 static OutputStream **output_streams = NULL;
348 static int nb_output_streams = 0;
349 static OutputFile **output_files = NULL;
350 static int nb_output_files = 0;
352 static FilterGraph **filtergraphs;
355 typedef struct OptionsContext {
356 /* input/output options */
360 SpecifierOpt *codec_names;
362 SpecifierOpt *audio_channels;
363 int nb_audio_channels;
364 SpecifierOpt *audio_sample_rate;
365 int nb_audio_sample_rate;
366 SpecifierOpt *rematrix_volume;
367 int nb_rematrix_volume;
368 SpecifierOpt *frame_rates;
370 SpecifierOpt *frame_sizes;
372 SpecifierOpt *frame_pix_fmts;
373 int nb_frame_pix_fmts;
376 int64_t input_ts_offset;
379 SpecifierOpt *ts_scale;
381 SpecifierOpt *dump_attachment;
382 int nb_dump_attachment;
385 StreamMap *stream_maps;
387 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
388 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
389 int metadata_global_manual;
390 int metadata_streams_manual;
391 int metadata_chapters_manual;
392 const char **attachments;
395 int chapters_input_file;
397 int64_t recording_time;
398 uint64_t limit_filesize;
404 int subtitle_disable;
407 /* indexed by output file stream index */
411 SpecifierOpt *metadata;
413 SpecifierOpt *max_frames;
415 SpecifierOpt *bitstream_filters;
416 int nb_bitstream_filters;
417 SpecifierOpt *codec_tags;
419 SpecifierOpt *sample_fmts;
421 SpecifierOpt *qscale;
423 SpecifierOpt *forced_key_frames;
424 int nb_forced_key_frames;
425 SpecifierOpt *force_fps;
427 SpecifierOpt *frame_aspect_ratios;
428 int nb_frame_aspect_ratios;
429 SpecifierOpt *rc_overrides;
431 SpecifierOpt *intra_matrices;
432 int nb_intra_matrices;
433 SpecifierOpt *inter_matrices;
434 int nb_inter_matrices;
435 SpecifierOpt *top_field_first;
436 int nb_top_field_first;
437 SpecifierOpt *metadata_map;
439 SpecifierOpt *presets;
441 SpecifierOpt *copy_initial_nonkeyframes;
442 int nb_copy_initial_nonkeyframes;
443 SpecifierOpt *filters;
447 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
450 for (i = 0; i < o->nb_ ## name; i++) {\
451 char *spec = o->name[i].specifier;\
452 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
453 outvar = o->name[i].u.type;\
459 static int64_t getutime(void)
462 struct rusage rusage;
464 getrusage(RUSAGE_SELF, &rusage);
465 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
466 #elif HAVE_GETPROCESSTIMES
469 proc = GetCurrentProcess();
470 GetProcessTimes(proc, &c, &e, &k, &u);
471 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
477 static void update_benchmark(const char *fmt, ...)
479 if (do_benchmark_all) {
480 int64_t t = getutime();
486 vsnprintf(buf, sizeof(buf), fmt, va);
488 printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
494 static void reset_options(OptionsContext *o, int is_input)
496 const OptionDef *po = options;
497 OptionsContext bak= *o;
500 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
502 void *dst = (uint8_t*)o + po->u.off;
504 if (po->flags & OPT_SPEC) {
505 SpecifierOpt **so = dst;
506 int i, *count = (int*)(so + 1);
507 for (i = 0; i < *count; i++) {
508 av_freep(&(*so)[i].specifier);
509 if (po->flags & OPT_STRING)
510 av_freep(&(*so)[i].u.str);
514 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
519 for (i = 0; i < o->nb_stream_maps; i++)
520 av_freep(&o->stream_maps[i].linklabel);
521 av_freep(&o->stream_maps);
522 av_freep(&o->audio_channel_maps);
523 av_freep(&o->streamid_map);
525 memset(o, 0, sizeof(*o));
527 if(is_input) o->recording_time = bak.recording_time;
528 else o->recording_time = INT64_MAX;
529 o->mux_max_delay = 0.7;
530 o->limit_filesize = UINT64_MAX;
531 o->chapters_input_file = INT_MAX;
537 static int alloc_buffer(InputStream *ist, AVCodecContext *s, FrameBuffer **pbuf)
539 FrameBuffer *buf = av_mallocz(sizeof(*buf));
541 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
542 int h_chroma_shift, v_chroma_shift;
543 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
544 int w = s->width, h = s->height;
547 return AVERROR(ENOMEM);
549 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
554 avcodec_align_dimensions(s, &w, &h);
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])
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 /** filter graph containing all filters including input & output */
732 AVCodecContext *codec = ost->st->codec;
733 enum PixelFormat *pix_fmts = choose_pixel_fmts(ost);
734 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
735 AVRational sample_aspect_ratio;
739 avfilter_graph_free(&fg->graph);
740 fg->graph = avfilter_graph_alloc();
742 return AVERROR(ENOMEM);
744 if (ist->st->sample_aspect_ratio.num) {
745 sample_aspect_ratio = ist->st->sample_aspect_ratio;
747 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
749 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,
750 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
751 sample_aspect_ratio.num, sample_aspect_ratio.den, SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
753 ret = avfilter_graph_create_filter(&fg->inputs[0]->filter,
754 avfilter_get_by_name("buffer"),
755 "src", args, NULL, fg->graph);
759 #if FF_API_OLD_VSINK_API
760 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),
761 "out", NULL, pix_fmts, fg->graph);
763 buffersink_params->pixel_fmts = pix_fmts;
764 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),
765 "out", NULL, buffersink_params, fg->graph);
767 av_freep(&buffersink_params);
771 last_filter = fg->inputs[0]->filter;
773 if (codec->width || codec->height) {
774 snprintf(args, 255, "%d:%d:flags=0x%X",
777 (unsigned)ost->sws_flags);
778 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
779 NULL, args, NULL, fg->graph)) < 0)
781 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
783 last_filter = filter;
786 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
787 fg->graph->scale_sws_opts = av_strdup(args);
790 AVFilterInOut *outputs = avfilter_inout_alloc();
791 AVFilterInOut *inputs = avfilter_inout_alloc();
793 outputs->name = av_strdup("in");
794 outputs->filter_ctx = last_filter;
795 outputs->pad_idx = 0;
796 outputs->next = NULL;
798 inputs->name = av_strdup("out");
799 inputs->filter_ctx = fg->outputs[0]->filter;
803 if ((ret = avfilter_graph_parse(fg->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
805 av_freep(&ost->avfilter);
807 if ((ret = avfilter_link(last_filter, 0, fg->outputs[0]->filter, 0)) < 0)
811 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
814 ost->filter = fg->outputs[0];
819 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
821 FilterGraph *fg = av_mallocz(sizeof(*fg));
825 fg->index = nb_filtergraphs;
827 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
829 if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
831 fg->outputs[0]->ost = ost;
832 fg->outputs[0]->graph = fg;
834 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
836 if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
838 fg->inputs[0]->ist = ist;
839 fg->inputs[0]->graph = fg;
841 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
842 &ist->nb_filters, ist->nb_filters + 1);
843 ist->filters[ist->nb_filters - 1] = fg->inputs[0];
845 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
846 &nb_filtergraphs, nb_filtergraphs + 1);
847 filtergraphs[nb_filtergraphs - 1] = fg;
852 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
855 enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
858 // TODO: support other filter types
859 if (type != AVMEDIA_TYPE_VIDEO) {
860 av_log(NULL, AV_LOG_FATAL, "Only video filters supported currently.\n");
868 int file_idx = strtol(in->name, &p, 0);
870 if (file_idx < 0 || file_idx >= nb_input_files) {
871 av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtergraph description %s.\n",
872 file_idx, fg->graph_desc);
875 s = input_files[file_idx]->ctx;
877 for (i = 0; i < s->nb_streams; i++) {
878 if (s->streams[i]->codec->codec_type != type)
880 if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
886 av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
887 "matches no streams.\n", p, fg->graph_desc);
890 ist = input_streams[input_files[file_idx]->ist_index + st->index];
892 /* find the first unused stream of corresponding type */
893 for (i = 0; i < nb_input_streams; i++) {
894 ist = input_streams[i];
895 if (ist->st->codec->codec_type == type && ist->discard)
898 if (i == nb_input_streams) {
899 av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
900 "unlabeled input pad %d on filter %s", in->pad_idx,
901 in->filter_ctx->name);
906 ist->decoding_needed = 1;
907 ist->st->discard = AVDISCARD_NONE;
909 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
910 &fg->nb_inputs, fg->nb_inputs + 1);
911 if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
913 fg->inputs[fg->nb_inputs - 1]->ist = ist;
914 fg->inputs[fg->nb_inputs - 1]->graph = fg;
916 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
917 &ist->nb_filters, ist->nb_filters + 1);
918 ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
921 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
923 AVCodecContext *codec = ofilter->ost->st->codec;
924 AVFilterContext *last_filter = out->filter_ctx;
925 int pad_idx = out->pad_idx;
927 enum PixelFormat *pix_fmts = choose_pixel_fmts(ofilter->ost);
928 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
930 #if FF_API_OLD_VSINK_API
931 ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),
932 "out", NULL, pix_fmts, fg->graph);
934 buffersink_params->pixel_fmts = pix_fmts;
935 ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),
936 "out", NULL, buffersink_params, fg->graph);
938 av_freep(&buffersink_params);
943 if (codec->width || codec->height) {
945 snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
948 (unsigned)ofilter->ost->sws_flags);
949 if ((ret = avfilter_graph_create_filter(&last_filter, avfilter_get_by_name("scale"),
950 NULL, args, NULL, fg->graph)) < 0)
952 if ((ret = avfilter_link(out->filter_ctx, out->pad_idx, last_filter, 0)) < 0)
957 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
963 static int configure_complex_filter(FilterGraph *fg)
965 AVFilterInOut *inputs, *outputs, *cur;
966 int ret, i, init = !fg->graph;
968 avfilter_graph_free(&fg->graph);
969 if (!(fg->graph = avfilter_graph_alloc()))
970 return AVERROR(ENOMEM);
972 if ((ret = avfilter_graph_parse2(fg->graph, fg->graph_desc, &inputs, &outputs)) < 0)
975 for (cur = inputs; init && cur; cur = cur->next)
976 init_input_filter(fg, cur);
978 for (cur = inputs, i = 0; cur; cur = cur->next, i++) {
979 InputFilter *ifilter = fg->inputs[i];
980 InputStream *ist = ifilter->ist;
984 sar = ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
985 ist->st->codec->sample_aspect_ratio;
986 snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
987 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
990 if ((ret = avfilter_graph_create_filter(&ifilter->filter,
991 avfilter_get_by_name("buffer"), cur->name,
992 args, NULL, fg->graph)) < 0)
994 if ((ret = avfilter_link(ifilter->filter, 0,
995 cur->filter_ctx, cur->pad_idx)) < 0)
998 avfilter_inout_free(&inputs);
1001 /* we already know the mappings between lavfi outputs and output streams,
1002 * so we can finish the setup */
1003 for (cur = outputs, i = 0; cur; cur = cur->next, i++)
1004 configure_output_filter(fg, fg->outputs[i], cur);
1005 avfilter_inout_free(&outputs);
1007 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1010 /* wait until output mappings are processed */
1011 for (cur = outputs; cur;) {
1012 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1013 &fg->nb_outputs, fg->nb_outputs + 1);
1014 if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1016 fg->outputs[fg->nb_outputs - 1]->graph = fg;
1017 fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1019 fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1026 static int configure_complex_filters(void)
1030 for (i = 0; i < nb_filtergraphs; i++)
1031 if (!filtergraphs[i]->graph &&
1032 (ret = configure_complex_filter(filtergraphs[i])) < 0)
1037 static int configure_filtergraph(FilterGraph *fg)
1039 return fg->graph_desc ? configure_complex_filter(fg) : configure_video_filters(fg);
1042 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1045 for (i = 0; i < fg->nb_inputs; i++)
1046 if (fg->inputs[i]->ist == ist)
1051 static void term_exit(void)
1053 av_log(NULL, AV_LOG_QUIET, "%s", "");
1056 tcsetattr (0, TCSANOW, &oldtty);
1060 static volatile int received_sigterm = 0;
1062 static void sigterm_handler(int sig)
1064 received_sigterm = sig;
1065 received_nb_signals++;
1067 if(received_nb_signals > 3)
1071 static void term_init(void)
1077 if (tcgetattr (0, &tty) == 0) {
1082 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1083 |INLCR|IGNCR|ICRNL|IXON);
1084 tty.c_oflag |= OPOST;
1085 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1086 tty.c_cflag &= ~(CSIZE|PARENB);
1089 tty.c_cc[VTIME] = 0;
1091 tcsetattr (0, TCSANOW, &tty);
1093 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
1096 avformat_network_deinit();
1098 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
1099 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
1101 signal(SIGXCPU, sigterm_handler);
1105 /* read a key without blocking */
1106 static int read_key(void)
1118 n = select(1, &rfds, NULL, NULL, &tv);
1120 n = read(0, &ch, 1);
1127 # if HAVE_PEEKNAMEDPIPE
1129 static HANDLE input_handle;
1132 input_handle = GetStdHandle(STD_INPUT_HANDLE);
1133 is_pipe = !GetConsoleMode(input_handle, &dw);
1136 if (stdin->_cnt > 0) {
1141 /* When running under a GUI, you will end here. */
1142 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
1159 static int decode_interrupt_cb(void *ctx)
1161 return received_nb_signals > 1;
1164 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1166 void av_noreturn exit_program(int ret)
1170 for (i = 0; i < nb_filtergraphs; i++) {
1171 avfilter_graph_free(&filtergraphs[i]->graph);
1172 for (j = 0; j < filtergraphs[i]->nb_inputs; j++)
1173 av_freep(&filtergraphs[i]->inputs[j]);
1174 av_freep(&filtergraphs[i]->inputs);
1175 for (j = 0; j < filtergraphs[i]->nb_outputs; j++)
1176 av_freep(&filtergraphs[i]->outputs[j]);
1177 av_freep(&filtergraphs[i]->outputs);
1178 av_freep(&filtergraphs[i]);
1180 av_freep(&filtergraphs);
1183 for (i = 0; i < nb_output_files; i++) {
1184 AVFormatContext *s = output_files[i]->ctx;
1185 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1187 avformat_free_context(s);
1188 av_dict_free(&output_files[i]->opts);
1189 av_freep(&output_files[i]);
1191 for (i = 0; i < nb_output_streams; i++) {
1192 AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1194 AVBitStreamFilterContext *next = bsfc->next;
1195 av_bitstream_filter_close(bsfc);
1198 output_streams[i]->bitstream_filters = NULL;
1200 if (output_streams[i]->output_frame) {
1201 AVFrame *frame = output_streams[i]->output_frame;
1202 if (frame->extended_data != frame->data)
1203 av_freep(&frame->extended_data);
1206 av_freep(&output_streams[i]->filtered_frame);
1207 av_freep(&output_streams[i]);
1209 for (i = 0; i < nb_input_files; i++) {
1210 avformat_close_input(&input_files[i]->ctx);
1211 av_freep(&input_files[i]);
1213 for (i = 0; i < nb_input_streams; i++) {
1214 av_freep(&input_streams[i]->decoded_frame);
1215 av_dict_free(&input_streams[i]->opts);
1216 free_buffer_pool(input_streams[i]);
1217 av_freep(&input_streams[i]->filters);
1218 av_freep(&input_streams[i]);
1222 fclose(vstats_file);
1223 av_free(vstats_filename);
1225 av_freep(&input_streams);
1226 av_freep(&input_files);
1227 av_freep(&output_streams);
1228 av_freep(&output_files);
1231 av_freep(&audio_buf);
1232 allocated_audio_buf_size = 0;
1233 av_freep(&async_buf);
1234 allocated_async_buf_size = 0;
1237 avformat_network_deinit();
1239 if (received_sigterm) {
1240 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1241 (int) received_sigterm);
1245 exit(ret); /* not all OS-es handle main() return value */
1248 static void assert_avoptions(AVDictionary *m)
1250 AVDictionaryEntry *t;
1251 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1252 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1257 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1259 const char *codec_string = encoder ? "encoder" : "decoder";
1261 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1262 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1263 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1264 "results.\nAdd '-strict experimental' if you want to use it.\n",
1265 codec_string, c->codec->name);
1266 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1267 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1268 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1269 codec_string, codec->name);
1274 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
1276 if (codec && codec->sample_fmts) {
1277 const enum AVSampleFormat *p = codec->sample_fmts;
1278 for (; *p != -1; p++) {
1279 if (*p == st->codec->sample_fmt)
1283 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
1284 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
1285 if(av_get_sample_fmt_name(st->codec->sample_fmt))
1286 av_log(NULL, AV_LOG_WARNING,
1287 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
1288 av_get_sample_fmt_name(st->codec->sample_fmt),
1290 av_get_sample_fmt_name(codec->sample_fmts[0]));
1291 st->codec->sample_fmt = codec->sample_fmts[0];
1296 static void choose_sample_rate(AVStream *st, AVCodec *codec)
1298 if (codec && codec->supported_samplerates) {
1299 const int *p = codec->supported_samplerates;
1301 int best_dist = INT_MAX;
1303 int dist = abs(st->codec->sample_rate - *p);
1304 if (dist < best_dist) {
1311 const int *sample_rates = codec->supported_samplerates;
1312 av_log(st->codec, AV_LOG_WARNING,
1313 "Requested sampling rate (%dHz) unsupported, using %dHz instead\n"
1314 "Available sampling rates for %s:",
1315 st->codec->sample_rate, best, codec->name);
1316 for (i = 0; sample_rates[i]; i++) {
1317 if (!sample_rates[i + 1]) av_log(st->codec, AV_LOG_WARNING, " and");
1318 else if (i) av_log(st->codec, AV_LOG_WARNING, ",");
1319 av_log(st->codec, AV_LOG_WARNING, " %d", sample_rates[i]);
1321 av_log(st->codec, AV_LOG_WARNING, ".\n");
1323 st->codec->sample_rate = best;
1328 get_sync_ipts(const OutputStream *ost, int64_t pts)
1330 OutputFile *of = output_files[ost->file_index];
1331 return (double)(pts - of->start_time) / AV_TIME_BASE;
1334 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1336 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1337 AVCodecContext *avctx = ost->st->codec;
1340 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1341 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1342 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1345 * Audio encoders may split the packets -- #frames in != #packets out.
1346 * But there is no reordering, so we can limit the number of output packets
1347 * by simply dropping them here.
1348 * Counting encoded video frames needs to be done separately because of
1349 * reordering, see do_video_out()
1351 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1352 if (ost->frame_number >= ost->max_frames) {
1353 av_free_packet(pkt);
1356 ost->frame_number++;
1360 AVPacket new_pkt = *pkt;
1361 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1362 &new_pkt.data, &new_pkt.size,
1363 pkt->data, pkt->size,
1364 pkt->flags & AV_PKT_FLAG_KEY);
1366 av_free_packet(pkt);
1367 new_pkt.destruct = av_destruct_packet;
1369 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1370 bsfc->filter->name, pkt->stream_index,
1371 avctx->codec ? avctx->codec->name : "copy");
1381 pkt->stream_index = ost->index;
1382 ret = av_interleaved_write_frame(s, pkt);
1384 print_error("av_interleaved_write_frame()", ret);
1389 static void get_default_channel_layouts(OutputStream *ost, InputStream *ist)
1391 char layout_name[256];
1392 AVCodecContext *enc = ost->st->codec;
1393 AVCodecContext *dec = ist->st->codec;
1395 if (dec->channel_layout &&
1396 av_get_channel_layout_nb_channels(dec->channel_layout) != dec->channels) {
1397 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1398 dec->channels, dec->channel_layout);
1399 av_log(NULL, AV_LOG_ERROR, "New channel layout (%s) is invalid\n",
1401 dec->channel_layout = 0;
1403 if (!dec->channel_layout) {
1404 if (enc->channel_layout && dec->channels == enc->channels) {
1405 dec->channel_layout = enc->channel_layout;
1407 dec->channel_layout = av_get_default_channel_layout(dec->channels);
1409 if (!dec->channel_layout) {
1410 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1411 "layout for Input Stream #%d.%d\n", ist->file_index,
1416 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1417 dec->channels, dec->channel_layout);
1418 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
1419 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1421 if (!enc->channel_layout) {
1422 if (dec->channels == enc->channels) {
1423 enc->channel_layout = dec->channel_layout;
1426 enc->channel_layout = av_get_default_channel_layout(enc->channels);
1428 if (!enc->channel_layout) {
1429 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel layout "
1430 "for Output Stream #%d.%d\n", ost->file_index,
1434 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1435 enc->channels, enc->channel_layout);
1436 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Output Stream "
1437 "#%d.%d : %s\n", ost->file_index, ost->st->index, layout_name);
1441 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1443 int fill_char = 0x00;
1444 if (sample_fmt == AV_SAMPLE_FMT_U8)
1446 memset(buf, fill_char, size);
1449 static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,
1450 const uint8_t *buf, int buf_size)
1452 AVCodecContext *enc = ost->st->codec;
1453 AVFrame *frame = NULL;
1455 int ret, got_packet;
1457 av_init_packet(&pkt);
1461 if (buf && buf_size) {
1462 if (!ost->output_frame) {
1463 ost->output_frame = avcodec_alloc_frame();
1464 if (!ost->output_frame) {
1465 av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");
1469 frame = ost->output_frame;
1470 if (frame->extended_data != frame->data)
1471 av_freep(&frame->extended_data);
1472 avcodec_get_frame_defaults(frame);
1474 frame->nb_samples = buf_size /
1475 (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
1476 if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,
1477 buf, buf_size, 1)) < 0) {
1478 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_fill_audio_frame)\n");
1482 frame->pts = ost->sync_opts;
1483 ost->sync_opts += frame->nb_samples;
1487 update_benchmark(NULL);
1488 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1489 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1492 update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
1497 if (pkt.pts != AV_NOPTS_VALUE)
1498 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1499 if (pkt.dts != AV_NOPTS_VALUE) {
1500 int64_t max = ost->st->cur_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
1501 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1502 if (ost->st->cur_dts && ost->st->cur_dts != AV_NOPTS_VALUE && max > pkt.dts) {
1503 av_log(s, max - pkt.dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG, "Audio timestamp %"PRId64" < %"PRId64" invalid, cliping\n", pkt.dts, max);
1504 pkt.pts = pkt.dts = max;
1507 if (pkt.duration > 0)
1508 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1510 write_frame(s, &pkt, ost);
1512 audio_size += pkt.size;
1514 av_free_packet(&pkt);
1518 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1519 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1520 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1521 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1527 static int alloc_audio_output_buf(AVCodecContext *dec, AVCodecContext *enc,
1528 int nb_samples, int *buf_linesize)
1530 int64_t audio_buf_samples;
1533 /* calculate required number of samples to allocate */
1534 audio_buf_samples = ((int64_t)nb_samples * enc->sample_rate + dec->sample_rate) /
1536 audio_buf_samples = 4 * audio_buf_samples + 10000; // safety factors for resampling
1537 audio_buf_samples = FFMAX(audio_buf_samples, enc->frame_size);
1538 if (audio_buf_samples > INT_MAX)
1539 return AVERROR(EINVAL);
1541 audio_buf_size = av_samples_get_buffer_size(buf_linesize, enc->channels,
1543 enc->sample_fmt, 0);
1544 if (audio_buf_size < 0)
1545 return audio_buf_size;
1547 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
1549 return AVERROR(ENOMEM);
1554 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1555 InputStream *ist, AVFrame *decoded_frame)
1560 int frame_bytes, resample_changed, ret;
1561 AVCodecContext *enc = ost->st->codec;
1562 AVCodecContext *dec = ist->st->codec;
1563 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1564 int isize = av_get_bytes_per_sample(dec->sample_fmt);
1565 uint8_t *buf[AV_NUM_DATA_POINTERS];
1566 int size = decoded_frame->nb_samples * dec->channels * isize;
1567 int planes = av_sample_fmt_is_planar(dec->sample_fmt) ? dec->channels : 1;
1569 int out_linesize = 0;
1570 int buf_linesize = decoded_frame->linesize[0];
1572 av_assert0(planes <= AV_NUM_DATA_POINTERS);
1574 for(i=0; i<planes; i++)
1575 buf[i]= decoded_frame->data[i];
1578 get_default_channel_layouts(ost, ist);
1580 if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples, &out_linesize) < 0) {
1581 av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1585 if (audio_sync_method > 1 ||
1586 enc->channels != dec->channels ||
1587 enc->channel_layout != dec->channel_layout ||
1588 enc->sample_rate != dec->sample_rate ||
1589 dec->sample_fmt != enc->sample_fmt)
1590 ost->audio_resample = 1;
1592 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1593 ost->resample_channels != dec->channels ||
1594 ost->resample_channel_layout != dec->channel_layout ||
1595 ost->resample_sample_rate != dec->sample_rate;
1597 if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
1599 if (resample_changed) {
1600 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",
1601 ist->file_index, ist->st->index,
1602 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt),
1603 ost->resample_channels, ost->resample_channel_layout,
1604 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt),
1605 dec->channels, dec->channel_layout);
1606 ost->resample_sample_fmt = dec->sample_fmt;
1607 ost->resample_channels = dec->channels;
1608 ost->resample_channel_layout = dec->channel_layout;
1609 ost->resample_sample_rate = dec->sample_rate;
1610 swr_free(&ost->swr);
1612 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1613 if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
1614 ost->resample_sample_fmt == enc->sample_fmt &&
1615 ost->resample_channels == enc->channels &&
1616 ost->resample_channel_layout == enc->channel_layout &&
1617 ost->resample_sample_rate == enc->sample_rate) {
1619 ost->audio_resample = 0;
1621 ost->swr = swr_alloc_set_opts(ost->swr,
1622 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
1623 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
1625 av_opt_set_int(ost->swr, "dither_method", ost->swr_dither_method,0);
1626 av_opt_set_int(ost->swr, "dither_scale", ost->swr_dither_scale,0);
1627 if (ost->audio_channels_mapped)
1628 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
1629 av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
1630 if (ost->audio_channels_mapped) {
1631 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
1632 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
1634 if (av_opt_set_int(ost->swr, "ich", dec->channels, 0) < 0) {
1635 av_log(NULL, AV_LOG_FATAL, "Unsupported number of input channels\n");
1638 if (av_opt_set_int(ost->swr, "och", enc->channels, 0) < 0) {
1639 av_log(NULL, AV_LOG_FATAL, "Unsupported number of output channels\n");
1642 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
1643 if(ost->swr && swr_init(ost->swr) < 0){
1644 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
1645 swr_free(&ost->swr);
1649 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1650 dec->channels, dec->sample_rate,
1651 enc->channels, enc->sample_rate);
1657 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1659 if (audio_sync_method > 0) {
1660 double delta = get_sync_ipts(ost, ist->pts) * enc->sample_rate - ost->sync_opts -
1661 av_fifo_size(ost->fifo) / (enc->channels * osize);
1662 int idelta = delta * dec->sample_rate / enc->sample_rate;
1663 int byte_delta = idelta * isize * dec->channels;
1665 // FIXME resample delay
1666 if (fabs(delta) > 50) {
1667 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1668 if (byte_delta < 0) {
1669 byte_delta = FFMAX(byte_delta, -size);
1671 for (i=0; i<planes; i++)
1672 buf[i] -= byte_delta/planes;
1673 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1674 -byte_delta / (isize * dec->channels));
1679 av_fast_malloc(&async_buf, &allocated_async_buf_size,
1682 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1686 if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples + idelta, &out_linesize) < 0) {
1687 av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1692 for (i=0; i<planes; i++) {
1693 uint8_t *t = async_buf + i*((byte_delta + size)/planes);
1694 generate_silence(t, dec->sample_fmt, byte_delta/planes);
1695 memcpy(t + byte_delta/planes, buf[i], size/planes);
1699 buf_linesize = allocated_async_buf_size;
1700 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1702 } else if (audio_sync_method > 1) {
1703 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1704 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1705 delta, comp, enc->sample_rate);
1706 // 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));
1707 swr_set_compensation(ost->swr, comp, enc->sample_rate);
1710 } else if (audio_sync_method == 0)
1711 ost->sync_opts = lrintf(get_sync_ipts(ost, ist->pts) * enc->sample_rate) -
1712 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1714 if (ost->audio_resample || ost->audio_channels_mapped) {
1716 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp},
1717 allocated_audio_buf_size / (enc->channels * osize),
1719 size / (dec->channels * isize));
1721 av_log(NULL, AV_LOG_FATAL, "swr_convert failed\n");
1724 size_out = size_out * enc->channels * osize;
1730 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1732 /* now encode as many frames as possible */
1733 if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1734 /* output resampled raw samples */
1735 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1736 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1739 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1741 frame_bytes = enc->frame_size * osize * enc->channels;
1743 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1744 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1745 encode_audio_frame(s, ost, audio_buf, frame_bytes);
1748 encode_audio_frame(s, ost, buftmp, size_out);
1752 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1754 AVCodecContext *dec;
1755 AVPicture *picture2;
1756 AVPicture picture_tmp;
1759 dec = ist->st->codec;
1761 /* deinterlace : must be done before any resize */
1762 if (do_deinterlace) {
1765 /* create temporary picture */
1766 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1767 buf = av_malloc(size);
1771 picture2 = &picture_tmp;
1772 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1774 if (avpicture_deinterlace(picture2, picture,
1775 dec->pix_fmt, dec->width, dec->height) < 0) {
1776 /* if error, do not deinterlace */
1777 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1786 if (picture != picture2)
1787 *picture = *picture2;
1791 static void do_subtitle_out(AVFormatContext *s,
1797 static uint8_t *subtitle_out = NULL;
1798 int subtitle_out_max_size = 1024 * 1024;
1799 int subtitle_out_size, nb, i;
1800 AVCodecContext *enc;
1803 if (pts == AV_NOPTS_VALUE) {
1804 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1810 enc = ost->st->codec;
1812 if (!subtitle_out) {
1813 subtitle_out = av_malloc(subtitle_out_max_size);
1816 /* Note: DVB subtitle need one packet to draw them and one other
1817 packet to clear them */
1818 /* XXX: signal it in the codec context ? */
1819 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1824 for (i = 0; i < nb; i++) {
1825 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1827 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1828 // start_display_time is required to be 0
1829 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1830 sub->end_display_time -= sub->start_display_time;
1831 sub->start_display_time = 0;
1832 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1833 subtitle_out_max_size, sub);
1834 if (subtitle_out_size < 0) {
1835 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1839 av_init_packet(&pkt);
1840 pkt.data = subtitle_out;
1841 pkt.size = subtitle_out_size;
1842 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1843 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1844 /* XXX: the pts correction is handled here. Maybe handling
1845 it in the codec would be better */
1847 pkt.pts += 90 * sub->start_display_time;
1849 pkt.pts += 90 * sub->end_display_time;
1851 write_frame(s, &pkt, ost);
1855 static double psnr(double d)
1857 return -10.0 * log(d) / log(10.0);
1860 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1863 AVCodecContext *enc;
1865 double ti1, bitrate, avg_bitrate;
1867 /* this is executed just the first time do_video_stats is called */
1869 vstats_file = fopen(vstats_filename, "w");
1876 enc = ost->st->codec;
1877 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1878 frame_number = ost->frame_number;
1879 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1880 if (enc->flags&CODEC_FLAG_PSNR)
1881 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1883 fprintf(vstats_file,"f_size= %6d ", frame_size);
1884 /* compute pts value */
1885 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1889 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1890 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1891 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1892 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1893 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1898 static void do_video_out(AVFormatContext *s, OutputStream *ost,
1899 AVFrame *in_picture, float quality)
1901 int nb_frames, i, ret, format_video_sync;
1902 AVCodecContext *enc;
1903 double sync_ipts, delta;
1904 double duration = 0;
1906 InputStream *ist = NULL;
1908 if (ost->source_index >= 0)
1909 ist = input_streams[ost->source_index];
1911 enc = ost->st->codec;
1913 if (ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1914 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1915 if(ist->st->r_frame_rate.num)
1916 duration= FFMAX(duration, 1/av_q2d(ist->st->r_frame_rate));
1917 if(ist->st->avg_frame_rate.num && 0)
1918 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1920 duration /= av_q2d(enc->time_base);
1923 sync_ipts = get_sync_ipts(ost, in_picture->pts) / av_q2d(enc->time_base);
1924 delta = sync_ipts - ost->sync_opts + duration;
1926 /* by default, we output a single frame */
1929 format_video_sync = video_sync_method;
1930 if (format_video_sync == VSYNC_AUTO)
1931 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1933 switch (format_video_sync) {
1935 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1938 else if (delta > 1.1)
1939 nb_frames = lrintf(delta);
1944 else if (delta > 0.6)
1945 ost->sync_opts = lrintf(sync_ipts);
1948 case VSYNC_PASSTHROUGH:
1949 ost->sync_opts = lrintf(sync_ipts);
1955 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1956 if (nb_frames == 0) {
1958 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1960 } else if (nb_frames > 1) {
1961 nb_frames_dup += nb_frames - 1;
1962 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1965 /* duplicates frame if needed */
1966 for (i = 0; i < nb_frames; i++) {
1968 av_init_packet(&pkt);
1972 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1973 enc->codec->id == CODEC_ID_RAWVIDEO) {
1974 /* raw pictures are written as AVPicture structure to
1975 avoid any copies. We support temporarily the older
1977 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1978 enc->coded_frame->top_field_first = in_picture->top_field_first;
1979 pkt.data = (uint8_t *)in_picture;
1980 pkt.size = sizeof(AVPicture);
1981 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1982 pkt.flags |= AV_PKT_FLAG_KEY;
1984 write_frame(s, &pkt, ost);
1987 AVFrame big_picture;
1989 big_picture = *in_picture;
1990 /* better than nothing: use input picture interlaced
1992 big_picture.interlaced_frame = in_picture->interlaced_frame;
1993 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1994 if (ost->top_field_first == -1)
1995 big_picture.top_field_first = in_picture->top_field_first;
1997 big_picture.top_field_first = !!ost->top_field_first;
2000 /* handles same_quant here. This is not correct because it may
2001 not be a global option */
2002 big_picture.quality = quality;
2003 if (!enc->me_threshold)
2004 big_picture.pict_type = 0;
2005 big_picture.pts = ost->sync_opts;
2006 if (ost->forced_kf_index < ost->forced_kf_count &&
2007 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
2008 big_picture.pict_type = AV_PICTURE_TYPE_I;
2009 ost->forced_kf_index++;
2011 update_benchmark(NULL);
2012 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
2013 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
2015 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
2020 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
2021 pkt.pts = ost->sync_opts;
2023 if (pkt.pts != AV_NOPTS_VALUE)
2024 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2025 if (pkt.dts != AV_NOPTS_VALUE)
2026 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2029 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
2030 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
2031 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
2032 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
2035 write_frame(s, &pkt, ost);
2036 frame_size = pkt.size;
2037 video_size += pkt.size;
2038 av_free_packet(&pkt);
2040 /* if two pass, output log */
2041 if (ost->logfile && enc->stats_out) {
2042 fprintf(ost->logfile, "%s", enc->stats_out);
2048 * For video, number of frames in == number of packets out.
2049 * But there may be reordering, so we can't throw away frames on encoder
2050 * flush, we need to limit them here, before they go into encoder.
2052 ost->frame_number++;
2054 if (vstats_filename && frame_size)
2055 do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
2058 /* check for new output on any of the filtergraphs */
2059 static int poll_filters(void)
2061 AVFilterBufferRef *picref;
2062 AVFrame *filtered_frame = NULL;
2063 int i, ret, ret_all;
2064 unsigned nb_success, nb_eof;
2067 /* Reap all buffers present in the buffer sinks */
2069 for (i = 0; i < nb_output_streams; i++) {
2070 OutputStream *ost = output_streams[i];
2071 OutputFile *of = output_files[ost->file_index];
2073 if (!ost->filter || ost->is_past_recording_time)
2076 if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
2077 return AVERROR(ENOMEM);
2079 avcodec_get_frame_defaults(ost->filtered_frame);
2080 filtered_frame = ost->filtered_frame;
2083 AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base;
2084 ret = av_buffersink_get_buffer_ref(ost->filter->filter, &picref,
2085 AV_BUFFERSINK_FLAG_NO_REQUEST);
2087 if (ret != AVERROR(EAGAIN)) {
2089 av_strerror(ret, buf, sizeof(buf));
2090 av_log(NULL, AV_LOG_WARNING,
2091 "Error in av_buffersink_get_buffer_ref(): %s\n", buf);
2095 filtered_frame->pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2096 // if (ost->source_index >= 0)
2097 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
2099 if (of->start_time && filtered_frame->pts < of->start_time)
2102 switch (ost->filter->filter->inputs[0]->type) {
2103 case AVMEDIA_TYPE_VIDEO:
2104 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);
2105 if (!ost->frame_aspect_ratio)
2106 ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
2108 do_video_out(of->ctx, ost, filtered_frame,
2109 same_quant ? ost->last_quality :
2110 ost->st->codec->global_quality);
2113 // TODO support audio/subtitle filters
2117 avfilter_unref_buffer(picref);
2120 /* Request frames through all the graphs */
2121 ret_all = nb_success = nb_eof = 0;
2122 for (i = 0; i < nb_filtergraphs; i++) {
2123 ret = avfilter_graph_request_oldest(filtergraphs[i]->graph);
2126 } else if (ret == AVERROR_EOF) {
2128 } else if (ret != AVERROR(EAGAIN)) {
2130 av_strerror(ret, buf, sizeof(buf));
2131 av_log(NULL, AV_LOG_WARNING,
2132 "Error in request_frame(): %s\n", buf);
2138 /* Try again if anything succeeded */
2140 return nb_eof == nb_filtergraphs ? AVERROR_EOF : ret_all;
2143 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
2147 AVFormatContext *oc;
2149 AVCodecContext *enc;
2150 int frame_number, vid, i;
2152 int64_t pts = INT64_MAX;
2153 static int64_t last_time = -1;
2154 static int qp_histogram[52];
2155 int hours, mins, secs, us;
2157 if (!print_stats && !is_last_report)
2160 if (!is_last_report) {
2161 if (last_time == -1) {
2162 last_time = cur_time;
2165 if ((cur_time - last_time) < 500000)
2167 last_time = cur_time;
2171 oc = output_files[0]->ctx;
2173 total_size = avio_size(oc->pb);
2174 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
2175 total_size = avio_tell(oc->pb);
2182 for (i = 0; i < nb_output_streams; i++) {
2184 ost = output_streams[i];
2185 enc = ost->st->codec;
2186 if (!ost->stream_copy && enc->coded_frame)
2187 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
2188 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2189 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
2191 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2192 float fps, t = (cur_time-timer_start) / 1000000.0;
2194 frame_number = ost->frame_number;
2195 fps = t > 1 ? frame_number / t : 0;
2196 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
2197 frame_number, fps < 9.95, fps, q);
2199 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
2203 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
2205 for (j = 0; j < 32; j++)
2206 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
2208 if (enc->flags&CODEC_FLAG_PSNR) {
2210 double error, error_sum = 0;
2211 double scale, scale_sum = 0;
2212 char type[3] = { 'Y','U','V' };
2213 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
2214 for (j = 0; j < 3; j++) {
2215 if (is_last_report) {
2216 error = enc->error[j];
2217 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
2219 error = enc->coded_frame->error[j];
2220 scale = enc->width * enc->height * 255.0 * 255.0;
2226 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
2228 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
2232 /* compute min output value */
2233 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
2234 ost->st->time_base, AV_TIME_BASE_Q));
2237 secs = pts / AV_TIME_BASE;
2238 us = pts % AV_TIME_BASE;
2244 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
2246 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2247 "size=%8.0fkB time=", total_size / 1024.0);
2248 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2249 "%02d:%02d:%02d.%02d ", hours, mins, secs,
2250 (100 * us) / AV_TIME_BASE);
2251 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2252 "bitrate=%6.1fkbits/s", bitrate);
2254 if (nb_frames_dup || nb_frames_drop)
2255 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
2256 nb_frames_dup, nb_frames_drop);
2258 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
2262 if (is_last_report) {
2263 int64_t raw= audio_size + video_size + extra_size;
2264 av_log(NULL, AV_LOG_INFO, "\n");
2265 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
2266 video_size / 1024.0,
2267 audio_size / 1024.0,
2268 extra_size / 1024.0,
2269 100.0 * (total_size - raw) / raw
2271 if(video_size + audio_size + extra_size == 0){
2272 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
2277 static void flush_encoders(void)
2281 for (i = 0; i < nb_output_streams; i++) {
2282 OutputStream *ost = output_streams[i];
2283 AVCodecContext *enc = ost->st->codec;
2284 AVFormatContext *os = output_files[ost->file_index]->ctx;
2285 int stop_encoding = 0;
2287 if (!ost->encoding_needed)
2290 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
2292 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
2297 int fifo_bytes, got_packet;
2298 av_init_packet(&pkt);
2302 switch (ost->st->codec->codec_type) {
2303 case AVMEDIA_TYPE_AUDIO:
2304 fifo_bytes = av_fifo_size(ost->fifo);
2305 if (fifo_bytes > 0) {
2306 /* encode any samples remaining in fifo */
2307 int frame_bytes = fifo_bytes;
2309 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
2311 /* pad last frame with silence if needed */
2312 if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
2313 frame_bytes = enc->frame_size * enc->channels *
2314 av_get_bytes_per_sample(enc->sample_fmt);
2315 if (allocated_audio_buf_size < frame_bytes)
2317 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
2319 encode_audio_frame(os, ost, audio_buf, frame_bytes);
2321 /* flush encoder with NULL frames until it is done
2322 returning packets */
2323 if (encode_audio_frame(os, ost, NULL, 0) == 0) {
2329 case AVMEDIA_TYPE_VIDEO:
2330 update_benchmark(NULL);
2331 ret = avcodec_encode_video2(enc, &pkt, NULL, &got_packet);
2332 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
2334 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
2337 video_size += pkt.size;
2338 if (ost->logfile && enc->stats_out) {
2339 fprintf(ost->logfile, "%s", enc->stats_out);
2345 if (pkt.pts != AV_NOPTS_VALUE)
2346 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2347 if (pkt.dts != AV_NOPTS_VALUE)
2348 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2349 write_frame(os, &pkt, ost);
2361 * Check whether a packet from ist should be written into ost at this time
2363 static int check_output_constraints(InputStream *ist, OutputStream *ost)
2365 OutputFile *of = output_files[ost->file_index];
2366 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
2368 if (ost->source_index != ist_index)
2371 if (of->start_time && ist->pts < of->start_time)
2374 if (of->recording_time != INT64_MAX &&
2375 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
2376 (AVRational){ 1, 1000000 }) >= 0) {
2377 ost->is_past_recording_time = 1;
2384 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2386 OutputFile *of = output_files[ost->file_index];
2387 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
2391 av_init_packet(&opkt);
2393 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2394 !ost->copy_initial_nonkeyframes)
2397 /* force the input stream PTS */
2398 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2399 audio_size += pkt->size;
2400 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2401 video_size += pkt->size;
2405 if (pkt->pts != AV_NOPTS_VALUE)
2406 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
2408 opkt.pts = AV_NOPTS_VALUE;
2410 if (pkt->dts == AV_NOPTS_VALUE)
2411 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
2413 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
2414 opkt.dts -= ost_tb_start_time;
2416 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
2417 opkt.flags = pkt->flags;
2419 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2420 if ( ost->st->codec->codec_id != CODEC_ID_H264
2421 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
2422 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
2423 && ost->st->codec->codec_id != CODEC_ID_VC1
2425 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
2426 opkt.destruct = av_destruct_packet;
2428 opkt.data = pkt->data;
2429 opkt.size = pkt->size;
2431 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2432 /* store AVPicture in AVPacket, as expected by the output format */
2433 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2434 opkt.data = (uint8_t *)&pict;
2435 opkt.size = sizeof(AVPicture);
2436 opkt.flags |= AV_PKT_FLAG_KEY;
2439 write_frame(of->ctx, &opkt, ost);
2440 ost->st->codec->frame_number++;
2441 av_free_packet(&opkt);
2444 static void rate_emu_sleep(InputStream *ist)
2446 if (input_files[ist->file_index]->rate_emu) {
2447 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2448 int64_t now = av_gettime() - ist->start;
2454 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2456 AVFrame *decoded_frame;
2457 AVCodecContext *avctx = ist->st->codec;
2458 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
2461 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2462 return AVERROR(ENOMEM);
2464 avcodec_get_frame_defaults(ist->decoded_frame);
2465 decoded_frame = ist->decoded_frame;
2467 update_benchmark(NULL);
2468 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2469 update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2473 if (avctx->sample_rate <= 0) {
2474 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2475 return AVERROR_INVALIDDATA;
2479 /* no audio frame */
2483 /* if the decoder provides a pts, use it instead of the last packet pts.
2484 the decoder could be delaying output by a packet or more. */
2485 if (decoded_frame->pts != AV_NOPTS_VALUE)
2486 ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2488 /* increment next_dts to use for the case where the input stream does not
2489 have timestamps or there are multiple frames in the packet */
2490 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2492 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2496 // preprocess audio (volume)
2497 if (audio_volume != 256) {
2498 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
2499 void *samples = decoded_frame->data[0];
2500 switch (avctx->sample_fmt) {
2501 case AV_SAMPLE_FMT_U8:
2503 uint8_t *volp = samples;
2504 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2505 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
2506 *volp++ = av_clip_uint8(v);
2510 case AV_SAMPLE_FMT_S16:
2512 int16_t *volp = samples;
2513 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2514 int v = ((*volp) * audio_volume + 128) >> 8;
2515 *volp++ = av_clip_int16(v);
2519 case AV_SAMPLE_FMT_S32:
2521 int32_t *volp = samples;
2522 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2523 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
2524 *volp++ = av_clipl_int32(v);
2528 case AV_SAMPLE_FMT_FLT:
2530 float *volp = samples;
2531 float scale = audio_volume / 256.f;
2532 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2537 case AV_SAMPLE_FMT_DBL:
2539 double *volp = samples;
2540 double scale = audio_volume / 256.;
2541 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2547 av_log(NULL, AV_LOG_FATAL,
2548 "Audio volume adjustment on sample format %s is not supported.\n",
2549 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
2554 rate_emu_sleep(ist);
2556 for (i = 0; i < nb_output_streams; i++) {
2557 OutputStream *ost = output_streams[i];
2559 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2561 do_audio_out(output_files[ost->file_index]->ctx, ost, ist, decoded_frame);
2567 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
2569 AVFrame *decoded_frame;
2570 void *buffer_to_free = NULL;
2571 int i, ret = 0, resample_changed;
2572 int64_t *best_effort_timestamp;
2573 AVRational *frame_sample_aspect;
2576 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2577 return AVERROR(ENOMEM);
2579 avcodec_get_frame_defaults(ist->decoded_frame);
2580 decoded_frame = ist->decoded_frame;
2581 pkt->pts = *pkt_pts;
2582 pkt->dts = ist->dts;
2583 *pkt_pts = AV_NOPTS_VALUE;
2585 update_benchmark(NULL);
2586 ret = avcodec_decode_video2(ist->st->codec,
2587 decoded_frame, got_output, pkt);
2588 update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2592 quality = same_quant ? decoded_frame->quality : 0;
2594 /* no picture yet */
2596 for (i = 0; i < ist->nb_filters; i++)
2597 av_buffersrc_buffer(ist->filters[i]->filter, NULL);
2601 best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
2602 if(*best_effort_timestamp != AV_NOPTS_VALUE)
2603 ist->next_pts = ist->pts = decoded_frame->pts = *best_effort_timestamp;
2607 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2609 rate_emu_sleep(ist);
2611 if (ist->st->sample_aspect_ratio.num)
2612 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2614 resample_changed = ist->resample_width != decoded_frame->width ||
2615 ist->resample_height != decoded_frame->height ||
2616 ist->resample_pix_fmt != decoded_frame->format;
2617 if (resample_changed) {
2618 av_log(NULL, AV_LOG_INFO,
2619 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2620 ist->file_index, ist->st->index,
2621 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2622 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2624 ist->resample_width = decoded_frame->width;
2625 ist->resample_height = decoded_frame->height;
2626 ist->resample_pix_fmt = decoded_frame->format;
2628 for (i = 0; i < nb_filtergraphs; i++)
2629 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2630 configure_filtergraph(filtergraphs[i]) < 0) {
2631 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2636 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2637 for (i = 0; i < ist->nb_filters; i++) {
2638 int changed = ist->st->codec->width != ist->filters[i]->filter->outputs[0]->w
2639 || ist->st->codec->height != ist->filters[i]->filter->outputs[0]->h
2640 || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2641 // XXX what an ugly hack
2642 if (ist->filters[i]->graph->nb_outputs == 1)
2643 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2645 if (!frame_sample_aspect->num)
2646 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2647 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2648 FrameBuffer *buf = decoded_frame->opaque;
2649 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2650 decoded_frame->data, decoded_frame->linesize,
2651 AV_PERM_READ | AV_PERM_PRESERVE,
2652 ist->st->codec->width, ist->st->codec->height,
2653 ist->st->codec->pix_fmt);
2655 avfilter_copy_frame_props(fb, decoded_frame);
2656 fb->buf->priv = buf;
2657 fb->buf->free = filter_release_buffer;
2659 av_assert0(buf->refcount>0);
2661 av_buffersrc_buffer(ist->filters[i]->filter, fb);
2663 if(av_vsrc_buffer_add_frame(ist->filters[i]->filter, decoded_frame,AV_VSRC_BUF_FLAG_OVERWRITE)<0) {
2664 av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2670 av_free(buffer_to_free);
2674 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2676 AVSubtitle subtitle;
2677 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2678 &subtitle, got_output, pkt);
2684 rate_emu_sleep(ist);
2686 for (i = 0; i < nb_output_streams; i++) {
2687 OutputStream *ost = output_streams[i];
2689 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2692 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2695 avsubtitle_free(&subtitle);
2699 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2700 static int output_packet(InputStream *ist, const AVPacket *pkt)
2704 int64_t pkt_pts = AV_NOPTS_VALUE;
2707 if (!ist->saw_first_ts) {
2708 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;
2710 if (pkt != NULL && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2711 ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2712 ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2714 ist->saw_first_ts = 1;
2717 if (ist->next_dts == AV_NOPTS_VALUE)
2718 ist->next_dts = ist->dts;
2719 if (ist->next_pts == AV_NOPTS_VALUE)
2720 ist->next_pts = ist->pts;
2724 av_init_packet(&avpkt);
2732 if (pkt->dts != AV_NOPTS_VALUE) {
2733 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2734 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2735 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2737 if(pkt->pts != AV_NOPTS_VALUE)
2738 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2740 // while we have more to decode or while the decoder did output something on EOF
2741 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2745 ist->pts = ist->next_pts;
2746 ist->dts = ist->next_dts;
2748 if (avpkt.size && avpkt.size != pkt->size) {
2749 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2750 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2751 ist->showed_multi_packet_warning = 1;
2754 switch (ist->st->codec->codec_type) {
2755 case AVMEDIA_TYPE_AUDIO:
2756 ret = transcode_audio (ist, &avpkt, &got_output);
2758 case AVMEDIA_TYPE_VIDEO:
2759 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
2760 if (avpkt.duration) {
2761 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2762 } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2763 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2764 duration = ((int64_t)AV_TIME_BASE *
2765 ist->st->codec->time_base.num * ticks) /
2766 ist->st->codec->time_base.den;
2770 if(ist->dts != AV_NOPTS_VALUE && duration) {
2771 ist->next_dts += duration;
2773 ist->next_dts = AV_NOPTS_VALUE;
2776 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2778 case AVMEDIA_TYPE_SUBTITLE:
2779 ret = transcode_subtitles(ist, &avpkt, &got_output);
2789 avpkt.pts= AV_NOPTS_VALUE;
2791 // touch data and size only if not EOF
2793 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2803 /* handle stream copy */
2804 if (!ist->decoding_needed) {
2805 rate_emu_sleep(ist);
2806 ist->dts = ist->next_dts;
2807 switch (ist->st->codec->codec_type) {
2808 case AVMEDIA_TYPE_AUDIO:
2809 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2810 ist->st->codec->sample_rate;
2812 case AVMEDIA_TYPE_VIDEO:
2813 if (pkt->duration) {
2814 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2815 } else if(ist->st->codec->time_base.num != 0) {
2816 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2817 ist->next_dts += ((int64_t)AV_TIME_BASE *
2818 ist->st->codec->time_base.num * ticks) /
2819 ist->st->codec->time_base.den;
2823 ist->pts = ist->dts;
2824 ist->next_pts = ist->next_dts;
2826 for (i = 0; pkt && i < nb_output_streams; i++) {
2827 OutputStream *ost = output_streams[i];
2829 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2832 do_streamcopy(ist, ost, pkt);
2838 static void print_sdp(void)
2842 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2846 for (i = 0; i < nb_output_files; i++)
2847 avc[i] = output_files[i]->ctx;
2849 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2850 printf("SDP:\n%s\n", sdp);
2855 static int init_input_stream(int ist_index, char *error, int error_len)
2858 InputStream *ist = input_streams[ist_index];
2860 if (ist->decoding_needed) {
2861 AVCodec *codec = ist->dec;
2863 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2864 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2865 return AVERROR(EINVAL);
2868 ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
2869 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2870 ist->st->codec->get_buffer = codec_get_buffer;
2871 ist->st->codec->release_buffer = codec_release_buffer;
2872 ist->st->codec->opaque = ist;
2875 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2876 av_dict_set(&ist->opts, "threads", "auto", 0);
2877 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2878 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2879 ist->file_index, ist->st->index);
2880 return AVERROR(EINVAL);
2882 assert_codec_experimental(ist->st->codec, 0);
2883 assert_avoptions(ist->opts);
2885 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2886 for (i = 0; i < nb_output_streams; i++) {
2887 OutputStream *ost = output_streams[i];
2888 if (ost->source_index == ist_index) {
2889 if (!ist->st->codec->channel_layout || !ost->st->codec->channel_layout)
2890 get_default_channel_layouts(ost, ist);
2897 ist->next_pts = AV_NOPTS_VALUE;
2898 ist->next_dts = AV_NOPTS_VALUE;
2904 static InputStream *get_input_stream(OutputStream *ost)
2906 if (ost->source_index >= 0)
2907 return input_streams[ost->source_index];
2910 FilterGraph *fg = ost->filter->graph;
2913 for (i = 0; i < fg->nb_inputs; i++)
2914 if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2915 return fg->inputs[i]->ist;
2921 static int transcode_init(void)
2923 int ret = 0, i, j, k;
2924 AVFormatContext *oc;
2925 AVCodecContext *codec, *icodec;
2931 /* init framerate emulation */
2932 for (i = 0; i < nb_input_files; i++) {
2933 InputFile *ifile = input_files[i];
2934 if (ifile->rate_emu)
2935 for (j = 0; j < ifile->nb_streams; j++)
2936 input_streams[j + ifile->ist_index]->start = av_gettime();
2939 /* output stream init */
2940 for (i = 0; i < nb_output_files; i++) {
2941 oc = output_files[i]->ctx;
2942 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2943 av_dump_format(oc, i, oc->filename, 1);
2944 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2945 return AVERROR(EINVAL);
2949 /* init complex filtergraphs */
2950 for (i = 0; i < nb_filtergraphs; i++)
2951 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2954 /* for each output stream, we compute the right encoding parameters */
2955 for (i = 0; i < nb_output_streams; i++) {
2956 ost = output_streams[i];
2957 oc = output_files[ost->file_index]->ctx;
2958 ist = get_input_stream(ost);
2960 if (ost->attachment_filename)
2963 codec = ost->st->codec;
2966 icodec = ist->st->codec;
2968 ost->st->disposition = ist->st->disposition;
2969 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2970 codec->chroma_sample_location = icodec->chroma_sample_location;
2973 if (ost->stream_copy) {
2974 uint64_t extra_size;
2976 av_assert0(ist && !ost->filter);
2978 extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2980 if (extra_size > INT_MAX) {
2981 return AVERROR(EINVAL);
2984 /* if stream_copy is selected, no need to decode or encode */
2985 codec->codec_id = icodec->codec_id;
2986 codec->codec_type = icodec->codec_type;
2988 if (!codec->codec_tag) {
2989 if (!oc->oformat->codec_tag ||
2990 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2991 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2992 codec->codec_tag = icodec->codec_tag;
2995 codec->bit_rate = icodec->bit_rate;
2996 codec->rc_max_rate = icodec->rc_max_rate;
2997 codec->rc_buffer_size = icodec->rc_buffer_size;
2998 codec->field_order = icodec->field_order;
2999 codec->extradata = av_mallocz(extra_size);
3000 if (!codec->extradata) {
3001 return AVERROR(ENOMEM);
3003 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
3004 codec->extradata_size= icodec->extradata_size;
3006 codec->time_base = ist->st->time_base;
3008 * Avi is a special case here because it supports variable fps but
3009 * having the fps and timebase differe significantly adds quite some
3012 if(!strcmp(oc->oformat->name, "avi")) {
3013 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
3014 && av_q2d(ist->st->time_base) < 1.0/500
3016 codec->time_base = icodec->time_base;
3017 codec->time_base.num *= icodec->ticks_per_frame;
3018 codec->time_base.den *= 2;
3019 codec->ticks_per_frame = 2;
3021 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
3022 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
3023 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
3025 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
3026 && av_q2d(ist->st->time_base) < 1.0/500
3028 codec->time_base = icodec->time_base;
3029 codec->time_base.num *= icodec->ticks_per_frame;
3032 av_reduce(&codec->time_base.num, &codec->time_base.den,
3033 codec->time_base.num, codec->time_base.den, INT_MAX);
3035 switch (codec->codec_type) {
3036 case AVMEDIA_TYPE_AUDIO:
3037 if (audio_volume != 256) {
3038 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3041 codec->channel_layout = icodec->channel_layout;
3042 codec->sample_rate = icodec->sample_rate;
3043 codec->channels = icodec->channels;
3044 codec->frame_size = icodec->frame_size;
3045 codec->audio_service_type = icodec->audio_service_type;
3046 codec->block_align = icodec->block_align;
3048 case AVMEDIA_TYPE_VIDEO:
3049 codec->pix_fmt = icodec->pix_fmt;
3050 codec->width = icodec->width;
3051 codec->height = icodec->height;
3052 codec->has_b_frames = icodec->has_b_frames;
3053 if (!codec->sample_aspect_ratio.num) {
3054 codec->sample_aspect_ratio =
3055 ost->st->sample_aspect_ratio =
3056 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
3057 ist->st->codec->sample_aspect_ratio.num ?
3058 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
3060 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3062 case AVMEDIA_TYPE_SUBTITLE:
3063 codec->width = icodec->width;
3064 codec->height = icodec->height;
3066 case AVMEDIA_TYPE_DATA:
3067 case AVMEDIA_TYPE_ATTACHMENT:
3074 ost->enc = avcodec_find_encoder(codec->codec_id);
3076 /* should only happen when a default codec is not present. */
3077 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3078 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3079 ret = AVERROR(EINVAL);
3084 ist->decoding_needed = 1;
3085 ost->encoding_needed = 1;
3087 switch (codec->codec_type) {
3088 case AVMEDIA_TYPE_AUDIO:
3089 ost->fifo = av_fifo_alloc(1024);
3091 return AVERROR(ENOMEM);
3094 if (!codec->sample_rate)
3095 codec->sample_rate = icodec->sample_rate;
3096 choose_sample_rate(ost->st, ost->enc);
3097 codec->time_base = (AVRational){ 1, codec->sample_rate };
3099 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
3100 codec->sample_fmt = icodec->sample_fmt;
3101 choose_sample_fmt(ost->st, ost->enc);
3103 if (ost->audio_channels_mapped) {
3104 /* the requested output channel is set to the number of
3105 * -map_channel only if no -ac are specified */
3106 if (!codec->channels) {
3107 codec->channels = ost->audio_channels_mapped;
3108 codec->channel_layout = av_get_default_channel_layout(codec->channels);
3109 if (!codec->channel_layout) {
3110 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
3114 /* fill unused channel mapping with -1 (which means a muted
3115 * channel in case the number of output channels is bigger
3116 * than the number of mapped channel) */
3117 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
3118 ost->audio_channels_map[j] = -1;
3119 } else if (!codec->channels) {
3120 codec->channels = icodec->channels;
3121 codec->channel_layout = icodec->channel_layout;
3123 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
3124 codec->channel_layout = 0;
3127 // ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
3128 // ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
3129 // || codec->channel_layout != icodec->channel_layout;
3130 icodec->request_channels = codec-> channels;
3131 ost->resample_sample_fmt = icodec->sample_fmt;
3132 ost->resample_sample_rate = icodec->sample_rate;
3133 ost->resample_channels = icodec->channels;
3134 ost->resample_channel_layout = icodec->channel_layout;
3136 case AVMEDIA_TYPE_VIDEO:
3139 fg = init_simple_filtergraph(ist, ost);
3140 if (configure_video_filters(fg)) {
3141 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3146 if (ist && !ost->frame_rate.num)
3147 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
3148 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3149 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3150 ost->frame_rate = ost->enc->supported_framerates[idx];
3152 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3153 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3154 && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3155 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3156 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3158 for (j = 0; j < ost->forced_kf_count; j++)
3159 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3163 codec->width = ost->filter->filter->inputs[0]->w;
3164 codec->height = ost->filter->filter->inputs[0]->h;
3165 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3166 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3167 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3168 ost->filter->filter->inputs[0]->sample_aspect_ratio;
3169 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3171 if (codec->width != icodec->width ||
3172 codec->height != icodec->height ||
3173 codec->pix_fmt != icodec->pix_fmt) {
3174 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3178 case AVMEDIA_TYPE_SUBTITLE:
3179 codec->time_base = (AVRational){1, 1000};
3186 if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3187 char logfilename[1024];
3190 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3191 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3193 if (!strcmp(ost->enc->name, "libx264")) {
3194 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3196 if (codec->flags & CODEC_FLAG_PASS2) {
3198 size_t logbuffer_size;
3199 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3200 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3204 codec->stats_in = logbuffer;
3206 if (codec->flags & CODEC_FLAG_PASS1) {
3207 f = fopen(logfilename, "wb");
3209 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3210 logfilename, strerror(errno));
3220 /* open each encoder */
3221 for (i = 0; i < nb_output_streams; i++) {
3222 ost = output_streams[i];
3223 if (ost->encoding_needed) {
3224 AVCodec *codec = ost->enc;
3225 AVCodecContext *dec = NULL;
3227 if ((ist = get_input_stream(ost)))
3228 dec = ist->st->codec;
3229 if (dec && dec->subtitle_header) {
3230 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3231 if (!ost->st->codec->subtitle_header) {
3232 ret = AVERROR(ENOMEM);
3235 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3236 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3238 if (!av_dict_get(ost->opts, "threads", NULL, 0))
3239 av_dict_set(&ost->opts, "threads", "auto", 0);
3240 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3241 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3242 ost->file_index, ost->index);
3243 ret = AVERROR(EINVAL);
3246 assert_codec_experimental(ost->st->codec, 1);
3247 assert_avoptions(ost->opts);
3248 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3249 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3250 " It takes bits/s as argument, not kbits/s\n");
3251 extra_size += ost->st->codec->extradata_size;
3253 if (ost->st->codec->me_threshold)
3254 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3258 /* init input streams */
3259 for (i = 0; i < nb_input_streams; i++)
3260 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3263 /* discard unused programs */
3264 for (i = 0; i < nb_input_files; i++) {
3265 InputFile *ifile = input_files[i];
3266 for (j = 0; j < ifile->ctx->nb_programs; j++) {
3267 AVProgram *p = ifile->ctx->programs[j];
3268 int discard = AVDISCARD_ALL;
3270 for (k = 0; k < p->nb_stream_indexes; k++)
3271 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3272 discard = AVDISCARD_DEFAULT;
3275 p->discard = discard;
3279 /* open files and write file headers */
3280 for (i = 0; i < nb_output_files; i++) {
3281 oc = output_files[i]->ctx;
3282 oc->interrupt_callback = int_cb;
3283 if (avformat_write_header(oc, &output_files[i]->opts) < 0) {
3284 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
3285 ret = AVERROR(EINVAL);
3288 // assert_avoptions(output_files[i]->opts);
3289 if (strcmp(oc->oformat->name, "rtp")) {
3295 /* dump the file output parameters - cannot be done before in case
3297 for (i = 0; i < nb_output_files; i++) {
3298 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3301 /* dump the stream mapping */
3302 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3303 for (i = 0; i < nb_input_streams; i++) {
3304 ist = input_streams[i];
3306 for (j = 0; j < ist->nb_filters; j++) {
3307 AVFilterLink *link = ist->filters[j]->filter->outputs[0];
3308 if (ist->filters[j]->graph->graph_desc) {
3309 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
3310 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3311 link->dst->filter->name);
3312 if (link->dst->input_count > 1)
3313 av_log(NULL, AV_LOG_INFO, ":%s", link->dstpad->name);
3314 if (nb_filtergraphs > 1)
3315 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3316 av_log(NULL, AV_LOG_INFO, "\n");
3321 for (i = 0; i < nb_output_streams; i++) {
3322 ost = output_streams[i];
3324 if (ost->attachment_filename) {
3325 /* an attached file */
3326 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
3327 ost->attachment_filename, ost->file_index, ost->index);
3331 if (ost->filter && ost->filter->graph->graph_desc) {
3332 /* output from a complex graph */
3333 AVFilterLink *link = ost->filter->filter->inputs[0];
3334 av_log(NULL, AV_LOG_INFO, " %s", link->src->filter->name);
3335 if (link->src->output_count > 1)
3336 av_log(NULL, AV_LOG_INFO, ":%s", link->srcpad->name);
3337 if (nb_filtergraphs > 1)
3338 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3340 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3341 ost->index, ost->enc ? ost->enc->name : "?");
3345 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
3346 input_streams[ost->source_index]->file_index,
3347 input_streams[ost->source_index]->st->index,
3350 if (ost->audio_channels_mapped) {
3351 av_log(NULL, AV_LOG_INFO, " [ch:");
3352 for (j = 0; j < ost->audio_channels_mapped; j++)
3353 if (ost->audio_channels_map[j] == -1)
3354 av_log(NULL, AV_LOG_INFO, " M");
3356 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
3357 av_log(NULL, AV_LOG_INFO, "]");
3359 if (ost->sync_ist != input_streams[ost->source_index])
3360 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3361 ost->sync_ist->file_index,
3362 ost->sync_ist->st->index);
3363 if (ost->stream_copy)
3364 av_log(NULL, AV_LOG_INFO, " (copy)");
3366 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3367 input_streams[ost->source_index]->dec->name : "?",
3368 ost->enc ? ost->enc->name : "?");
3369 av_log(NULL, AV_LOG_INFO, "\n");
3373 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3385 * The following code is the main loop of the file converter
3387 static int transcode(void)
3390 AVFormatContext *is, *os;
3394 int no_packet_count = 0;
3395 int64_t timer_start;
3398 if (!(no_packet = av_mallocz(nb_input_files)))
3401 ret = transcode_init();
3406 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3409 timer_start = av_gettime();
3411 for (; received_sigterm == 0;) {
3412 int file_index, ist_index, past_recording_time = 1;
3415 int64_t cur_time= av_gettime();
3417 ipts_min = INT64_MAX;
3418 /* if 'q' pressed, exits */
3420 static int64_t last_time;
3421 if (received_nb_signals)
3423 /* read_key() returns 0 on EOF */
3424 if(cur_time - last_time >= 100000 && !run_as_daemon){
3426 last_time = cur_time;
3431 if (key == '+') av_log_set_level(av_log_get_level()+10);
3432 if (key == '-') av_log_set_level(av_log_get_level()-10);
3433 if (key == 's') qp_hist ^= 1;
3436 do_hex_dump = do_pkt_dump = 0;
3437 } else if(do_pkt_dump){
3441 av_log_set_level(AV_LOG_DEBUG);
3443 if (key == 'c' || key == 'C'){
3444 char buf[4096], target[64], command[256], arg[256] = {0};
3447 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3449 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3454 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3455 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3456 target, time, command, arg);
3457 for (i = 0; i < nb_filtergraphs; i++) {
3458 FilterGraph *fg = filtergraphs[i];
3461 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3462 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3463 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3465 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3470 av_log(NULL, AV_LOG_ERROR,
3471 "Parse error, at least 3 arguments were expected, "
3472 "only %d given in string '%s'\n", n, buf);
3475 if (key == 'd' || key == 'D'){
3478 debug = input_streams[0]->st->codec->debug<<1;
3479 if(!debug) debug = 1;
3480 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3483 if(scanf("%d", &debug)!=1)
3484 fprintf(stderr,"error parsing debug value\n");
3485 for(i=0;i<nb_input_streams;i++) {
3486 input_streams[i]->st->codec->debug = debug;
3488 for(i=0;i<nb_output_streams;i++) {
3489 ost = output_streams[i];
3490 ost->st->codec->debug = debug;
3492 if(debug) av_log_set_level(AV_LOG_DEBUG);
3493 fprintf(stderr,"debug=%d\n", debug);
3496 fprintf(stderr, "key function\n"
3497 "? show this help\n"
3498 "+ increase verbosity\n"
3499 "- decrease verbosity\n"
3500 "c Send command to filtergraph\n"
3501 "D cycle through available debug modes\n"
3502 "h dump packets/hex press to cycle through the 3 states\n"
3504 "s Show QP histogram\n"
3509 /* check if there's any stream where output is still needed */
3510 for (i = 0; i < nb_output_streams; i++) {
3512 ost = output_streams[i];
3513 of = output_files[ost->file_index];
3514 os = output_files[ost->file_index]->ctx;
3515 if (ost->is_past_recording_time ||
3516 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3518 if (ost->frame_number >= ost->max_frames) {
3520 for (j = 0; j < of->ctx->nb_streams; j++)
3521 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3524 past_recording_time = 0;
3526 if (past_recording_time)
3529 /* select the stream that we must read now by looking at the
3530 smallest output pts */
3532 for (i = 0; i < nb_input_streams; i++) {
3534 ist = input_streams[i];
3536 if (ist->discard || no_packet[ist->file_index])
3538 if (!input_files[ist->file_index]->eof_reached) {
3539 if (ipts < ipts_min) {
3541 file_index = ist->file_index;
3545 /* if none, if is finished */
3546 if (file_index < 0) {
3547 if (no_packet_count) {
3548 no_packet_count = 0;
3549 memset(no_packet, 0, nb_input_files);
3556 /* read a frame from it and output it in the fifo */
3557 is = input_files[file_index]->ctx;
3558 ret = av_read_frame(is, &pkt);
3559 if (ret == AVERROR(EAGAIN)) {
3560 no_packet[file_index] = 1;
3565 input_files[file_index]->eof_reached = 1;
3567 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3568 ist = input_streams[input_files[file_index]->ist_index + i];
3569 if (ist->decoding_needed)
3570 output_packet(ist, NULL);
3579 no_packet_count = 0;
3580 memset(no_packet, 0, nb_input_files);
3583 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3584 is->streams[pkt.stream_index]);
3586 /* the following test is needed in case new streams appear
3587 dynamically in stream : we ignore them */
3588 if (pkt.stream_index >= input_files[file_index]->nb_streams)
3589 goto discard_packet;
3590 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3591 ist = input_streams[ist_index];
3593 goto discard_packet;
3595 if (pkt.dts != AV_NOPTS_VALUE)
3596 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3597 if (pkt.pts != AV_NOPTS_VALUE)
3598 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3600 if (pkt.pts != AV_NOPTS_VALUE)
3601 pkt.pts *= ist->ts_scale;
3602 if (pkt.dts != AV_NOPTS_VALUE)
3603 pkt.dts *= ist->ts_scale;
3606 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3607 "next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%"PRId64"\n",
3608 ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3609 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3610 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3611 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3612 input_files[ist->file_index]->ts_offset);
3615 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3616 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3617 int64_t delta = pkt_dts - ist->next_dts;
3618 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3619 if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3620 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3621 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3622 pkt_dts+1<ist->pts){
3623 input_files[ist->file_index]->ts_offset -= delta;
3624 av_log(NULL, AV_LOG_DEBUG,
3625 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3626 delta, input_files[ist->file_index]->ts_offset);
3627 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3628 if (pkt.pts != AV_NOPTS_VALUE)
3629 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3632 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3633 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3634 pkt_dts+1<ist->pts){
3635 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3636 pkt.dts = AV_NOPTS_VALUE;
3638 if (pkt.pts != AV_NOPTS_VALUE){
3639 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3640 delta = pkt_pts - ist->next_dts;
3641 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3642 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3643 pkt_pts+1<ist->pts) {
3644 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3645 pkt.pts = AV_NOPTS_VALUE;
3651 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3652 if (output_packet(ist, &pkt) < 0 ||
3653 ((ret = poll_filters()) < 0 && ret != AVERROR_EOF)) {
3654 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3655 ist->file_index, ist->st->index);
3658 av_free_packet(&pkt);
3663 av_free_packet(&pkt);
3665 /* dump report by using the output first video and audio streams */
3666 print_report(0, timer_start, cur_time);
3669 /* at the end of stream, we must flush the decoder buffers */
3670 for (i = 0; i < nb_input_streams; i++) {
3671 ist = input_streams[i];
3672 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3673 output_packet(ist, NULL);
3681 /* write the trailer if needed and close file */
3682 for (i = 0; i < nb_output_files; i++) {
3683 os = output_files[i]->ctx;
3684 av_write_trailer(os);
3687 /* dump report by using the first video and audio streams */
3688 print_report(1, timer_start, av_gettime());
3690 /* close each encoder */
3691 for (i = 0; i < nb_output_streams; i++) {
3692 ost = output_streams[i];
3693 if (ost->encoding_needed) {
3694 av_freep(&ost->st->codec->stats_in);
3695 avcodec_close(ost->st->codec);
3699 /* close each decoder */
3700 for (i = 0; i < nb_input_streams; i++) {
3701 ist = input_streams[i];
3702 if (ist->decoding_needed) {
3703 avcodec_close(ist->st->codec);
3711 av_freep(&no_packet);
3713 if (output_streams) {
3714 for (i = 0; i < nb_output_streams; i++) {
3715 ost = output_streams[i];
3717 if (ost->stream_copy)
3718 av_freep(&ost->st->codec->extradata);
3720 fclose(ost->logfile);
3721 ost->logfile = NULL;
3723 av_fifo_free(ost->fifo); /* works even if fifo is not
3724 initialized but set to zero */
3725 av_freep(&ost->st->codec->subtitle_header);
3726 av_free(ost->forced_kf_pts);
3727 swr_free(&ost->swr);
3728 av_dict_free(&ost->opts);
3735 static int opt_frame_crop(const char *opt, const char *arg)
3737 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3738 return AVERROR(EINVAL);
3741 static int opt_pad(const char *opt, const char *arg)
3743 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3747 static int opt_video_channel(const char *opt, const char *arg)
3749 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3750 return opt_default("channel", arg);
3753 static int opt_video_standard(const char *opt, const char *arg)
3755 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3756 return opt_default("standard", arg);
3759 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3761 audio_codec_name = arg;
3762 return parse_option(o, "codec:a", arg, options);
3765 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3767 video_codec_name = arg;
3768 return parse_option(o, "codec:v", arg, options);
3771 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3773 subtitle_codec_name = arg;
3774 return parse_option(o, "codec:s", arg, options);
3777 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3779 return parse_option(o, "codec:d", arg, options);
3782 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3784 StreamMap *m = NULL;
3785 int i, negative = 0, file_idx;
3786 int sync_file_idx = -1, sync_stream_idx = 0;
3794 map = av_strdup(arg);
3796 /* parse sync stream first, just pick first matching stream */
3797 if (sync = strchr(map, ',')) {
3799 sync_file_idx = strtol(sync + 1, &sync, 0);
3800 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3801 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3806 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3807 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3808 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3809 sync_stream_idx = i;
3812 if (i == input_files[sync_file_idx]->nb_streams) {
3813 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3814 "match any streams.\n", arg);
3820 if (map[0] == '[') {
3821 /* this mapping refers to lavfi output */
3822 const char *c = map + 1;
3823 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3824 &o->nb_stream_maps, o->nb_stream_maps + 1);
3825 m = &o->stream_maps[o->nb_stream_maps - 1];
3826 m->linklabel = av_get_token(&c, "]");
3827 if (!m->linklabel) {
3828 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3832 file_idx = strtol(map, &p, 0);
3833 if (file_idx >= nb_input_files || file_idx < 0) {
3834 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3838 /* disable some already defined maps */
3839 for (i = 0; i < o->nb_stream_maps; i++) {
3840 m = &o->stream_maps[i];
3841 if (file_idx == m->file_index &&
3842 check_stream_specifier(input_files[m->file_index]->ctx,
3843 input_files[m->file_index]->ctx->streams[m->stream_index],
3844 *p == ':' ? p + 1 : p) > 0)
3848 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3849 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3850 *p == ':' ? p + 1 : p) <= 0)
3852 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3853 &o->nb_stream_maps, o->nb_stream_maps + 1);
3854 m = &o->stream_maps[o->nb_stream_maps - 1];
3856 m->file_index = file_idx;
3857 m->stream_index = i;
3859 if (sync_file_idx >= 0) {
3860 m->sync_file_index = sync_file_idx;
3861 m->sync_stream_index = sync_stream_idx;
3863 m->sync_file_index = file_idx;
3864 m->sync_stream_index = i;
3870 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3878 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3880 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3881 &o->nb_attachments, o->nb_attachments + 1);
3882 o->attachments[o->nb_attachments - 1] = arg;
3886 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3892 o->audio_channel_maps =
3893 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3894 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3895 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3897 /* muted channel syntax */
3898 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3899 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3900 m->file_idx = m->stream_idx = -1;
3902 m->ofile_idx = m->ostream_idx = -1;
3907 n = sscanf(arg, "%d.%d.%d:%d.%d",
3908 &m->file_idx, &m->stream_idx, &m->channel_idx,
3909 &m->ofile_idx, &m->ostream_idx);
3911 if (n != 3 && n != 5) {
3912 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3913 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3917 if (n != 5) // only file.stream.channel specified
3918 m->ofile_idx = m->ostream_idx = -1;
3921 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3922 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3926 if (m->stream_idx < 0 ||
3927 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
3928 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3929 m->file_idx, m->stream_idx);
3932 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
3933 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3934 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3935 m->file_idx, m->stream_idx);
3938 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3939 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3940 m->file_idx, m->stream_idx, m->channel_idx);
3947 * Parse a metadata specifier in arg.
3948 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3949 * @param index for type c/p, chapter/program index is written here
3950 * @param stream_spec for type s, the stream specifier is written here
3952 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3960 if (*(++arg) && *arg != ':') {
3961 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3964 *stream_spec = *arg == ':' ? arg + 1 : "";
3968 if (*(++arg) == ':')
3969 *index = strtol(++arg, NULL, 0);
3972 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3979 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3981 AVDictionary **meta_in = NULL;
3982 AVDictionary **meta_out = NULL;
3984 char type_in, type_out;
3985 const char *istream_spec = NULL, *ostream_spec = NULL;
3986 int idx_in = 0, idx_out = 0;
3988 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3989 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3992 if (type_out == 'g' || !*outspec)
3993 o->metadata_global_manual = 1;
3994 if (type_out == 's' || !*outspec)
3995 o->metadata_streams_manual = 1;
3996 if (type_out == 'c' || !*outspec)
3997 o->metadata_chapters_manual = 1;
4001 if (type_in == 'g' || type_out == 'g')
4002 o->metadata_global_manual = 1;
4003 if (type_in == 's' || type_out == 's')
4004 o->metadata_streams_manual = 1;
4005 if (type_in == 'c' || type_out == 'c')
4006 o->metadata_chapters_manual = 1;
4008 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
4009 if ((index) < 0 || (index) >= (nb_elems)) {\
4010 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
4015 #define SET_DICT(type, meta, context, index)\
4018 meta = &context->metadata;\
4021 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
4022 meta = &context->chapters[index]->metadata;\
4025 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
4026 meta = &context->programs[index]->metadata;\
4030 SET_DICT(type_in, meta_in, ic, idx_in);
4031 SET_DICT(type_out, meta_out, oc, idx_out);
4033 /* for input streams choose first matching stream */
4034 if (type_in == 's') {
4035 for (i = 0; i < ic->nb_streams; i++) {
4036 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
4037 meta_in = &ic->streams[i]->metadata;
4043 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
4048 if (type_out == 's') {
4049 for (i = 0; i < oc->nb_streams; i++) {
4050 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
4051 meta_out = &oc->streams[i]->metadata;
4052 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4057 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
4062 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
4065 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
4066 struct tm time = *gmtime((time_t*)&recording_timestamp);
4067 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
4068 parse_option(o, "metadata", buf, options);
4070 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
4071 "tag instead.\n", opt);
4075 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
4077 const char *codec_string = encoder ? "encoder" : "decoder";
4081 avcodec_find_encoder_by_name(name) :
4082 avcodec_find_decoder_by_name(name);
4084 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4087 if (codec->type != type) {
4088 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4094 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4096 char *codec_name = NULL;
4098 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4100 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4101 st->codec->codec_id = codec->id;
4104 return avcodec_find_decoder(st->codec->codec_id);
4108 * Add all the streams from the given input file to the global
4109 * list of input streams.
4111 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4114 char *next, *codec_tag = NULL;
4116 for (i = 0; i < ic->nb_streams; i++) {
4117 AVStream *st = ic->streams[i];
4118 AVCodecContext *dec = st->codec;
4119 InputStream *ist = av_mallocz(sizeof(*ist));
4124 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4125 input_streams[nb_input_streams - 1] = ist;
4128 ist->file_index = nb_input_files;
4130 st->discard = AVDISCARD_ALL;
4131 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
4133 ist->ts_scale = 1.0;
4134 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4136 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4138 uint32_t tag = strtol(codec_tag, &next, 0);
4140 tag = AV_RL32(codec_tag);
4141 st->codec->codec_tag = tag;
4144 ist->dec = choose_decoder(o, ic, st);
4146 switch (dec->codec_type) {
4147 case AVMEDIA_TYPE_VIDEO:
4149 ist->dec = avcodec_find_decoder(dec->codec_id);
4151 dec->flags |= CODEC_FLAG_EMU_EDGE;
4154 ist->resample_height = dec->height;
4155 ist->resample_width = dec->width;
4156 ist->resample_pix_fmt = dec->pix_fmt;
4159 case AVMEDIA_TYPE_AUDIO:
4160 case AVMEDIA_TYPE_DATA:
4161 case AVMEDIA_TYPE_SUBTITLE:
4163 ist->dec = avcodec_find_decoder(dec->codec_id);
4165 case AVMEDIA_TYPE_ATTACHMENT:
4166 case AVMEDIA_TYPE_UNKNOWN:
4174 static void assert_file_overwrite(const char *filename)
4176 if ((!file_overwrite || no_file_overwrite) &&
4177 (strchr(filename, ':') == NULL || filename[1] == ':' ||
4178 av_strstart(filename, "file:", NULL))) {
4179 if (avio_check(filename, 0) == 0) {
4180 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
4181 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4184 signal(SIGINT, SIG_DFL);
4185 if (!read_yesno()) {
4186 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4192 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4199 static void dump_attachment(AVStream *st, const char *filename)
4202 AVIOContext *out = NULL;
4203 AVDictionaryEntry *e;
4205 if (!st->codec->extradata_size) {
4206 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4207 nb_input_files - 1, st->index);
4210 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4211 filename = e->value;
4213 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4214 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4218 assert_file_overwrite(filename);
4220 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4221 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4226 avio_write(out, st->codec->extradata, st->codec->extradata_size);
4231 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4233 AVFormatContext *ic;
4234 AVInputFormat *file_iformat = NULL;
4238 AVDictionary **opts;
4239 int orig_nb_streams; // number of streams before avformat_find_stream_info
4242 if (!(file_iformat = av_find_input_format(o->format))) {
4243 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4248 if (!strcmp(filename, "-"))
4251 using_stdin |= !strncmp(filename, "pipe:", 5) ||
4252 !strcmp(filename, "/dev/stdin");
4254 /* get default parameters from command line */
4255 ic = avformat_alloc_context();
4257 print_error(filename, AVERROR(ENOMEM));
4260 if (o->nb_audio_sample_rate) {
4261 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4262 av_dict_set(&format_opts, "sample_rate", buf, 0);
4264 if (o->nb_audio_channels) {
4265 /* because we set audio_channels based on both the "ac" and
4266 * "channel_layout" options, we need to check that the specified
4267 * demuxer actually has the "channels" option before setting it */
4268 if (file_iformat && file_iformat->priv_class &&
4269 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4270 AV_OPT_SEARCH_FAKE_OBJ)) {
4271 snprintf(buf, sizeof(buf), "%d",
4272 o->audio_channels[o->nb_audio_channels - 1].u.i);
4273 av_dict_set(&format_opts, "channels", buf, 0);
4276 if (o->nb_frame_rates) {
4277 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4279 if (o->nb_frame_sizes) {
4280 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4282 if (o->nb_frame_pix_fmts)
4283 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4285 ic->video_codec_id = video_codec_name ?
4286 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
4287 ic->audio_codec_id = audio_codec_name ?
4288 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
4289 ic->subtitle_codec_id= subtitle_codec_name ?
4290 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4291 ic->flags |= AVFMT_FLAG_NONBLOCK;
4292 ic->interrupt_callback = int_cb;
4294 /* open the input file with generic avformat function */
4295 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4297 print_error(filename, err);
4300 assert_avoptions(format_opts);
4302 /* apply forced codec ids */
4303 for (i = 0; i < ic->nb_streams; i++)
4304 choose_decoder(o, ic, ic->streams[i]);
4306 /* Set AVCodecContext options for avformat_find_stream_info */
4307 opts = setup_find_stream_info_opts(ic, codec_opts);
4308 orig_nb_streams = ic->nb_streams;
4310 /* If not enough info to get the stream parameters, we decode the
4311 first frames to get it. (used in mpeg case for example) */
4312 ret = avformat_find_stream_info(ic, opts);
4314 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4315 avformat_close_input(&ic);
4319 timestamp = o->start_time;
4320 /* add the stream start time */
4321 if (ic->start_time != AV_NOPTS_VALUE)
4322 timestamp += ic->start_time;
4324 /* if seeking requested, we execute it */
4325 if (o->start_time != 0) {
4326 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4328 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4329 filename, (double)timestamp / AV_TIME_BASE);
4333 /* update the current parameters so that they match the one of the input stream */
4334 add_input_streams(o, ic);
4336 /* dump the file content */
4337 av_dump_format(ic, nb_input_files, filename, 0);
4339 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4340 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4343 input_files[nb_input_files - 1]->ctx = ic;
4344 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
4345 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4346 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4347 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
4349 for (i = 0; i < o->nb_dump_attachment; i++) {
4352 for (j = 0; j < ic->nb_streams; j++) {
4353 AVStream *st = ic->streams[j];
4355 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4356 dump_attachment(st, o->dump_attachment[i].u.str);
4360 for (i = 0; i < orig_nb_streams; i++)
4361 av_dict_free(&opts[i]);
4364 reset_options(o, 1);
4368 static void parse_forced_key_frames(char *kf, OutputStream *ost)
4373 for (p = kf; *p; p++)
4376 ost->forced_kf_count = n;
4377 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
4378 if (!ost->forced_kf_pts) {
4379 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
4382 for (i = 0; i < n; i++) {
4383 p = i ? strchr(p, ',') + 1 : kf;
4384 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
4388 static uint8_t *get_line(AVIOContext *s)
4394 if (avio_open_dyn_buf(&line) < 0) {
4395 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4399 while ((c = avio_r8(s)) && c != '\n')
4402 avio_close_dyn_buf(line, &buf);
4407 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4410 char filename[1000];
4411 const char *base[3] = { getenv("AVCONV_DATADIR"),
4416 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4420 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4421 i != 1 ? "" : "/.avconv", codec_name, preset_name);
4422 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4425 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4426 i != 1 ? "" : "/.avconv", preset_name);
4427 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4433 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4435 char *codec_name = NULL;
4437 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4439 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4440 NULL, ost->st->codec->codec_type);
4441 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4442 } else if (!strcmp(codec_name, "copy"))
4443 ost->stream_copy = 1;
4445 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4446 ost->st->codec->codec_id = ost->enc->id;
4450 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4453 AVStream *st = avformat_new_stream(oc, NULL);
4454 int idx = oc->nb_streams - 1, ret = 0;
4455 char *bsf = NULL, *next, *codec_tag = NULL;
4456 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4458 char *buf = NULL, *arg = NULL, *preset = NULL;
4459 AVIOContext *s = NULL;
4462 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4466 if (oc->nb_streams - 1 < o->nb_streamid_map)
4467 st->id = o->streamid_map[oc->nb_streams - 1];
4469 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4470 nb_output_streams + 1);
4471 if (!(ost = av_mallocz(sizeof(*ost))))
4473 output_streams[nb_output_streams - 1] = ost;
4475 ost->file_index = nb_output_files;
4478 st->codec->codec_type = type;
4479 choose_encoder(o, oc, ost);
4481 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
4484 avcodec_get_context_defaults3(st->codec, ost->enc);
4485 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4487 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4488 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4491 if (!buf[0] || buf[0] == '#') {
4495 if (!(arg = strchr(buf, '='))) {
4496 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4500 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4502 } while (!s->eof_reached);
4506 av_log(NULL, AV_LOG_FATAL,
4507 "Preset %s specified for stream %d:%d, but could not be opened.\n",
4508 preset, ost->file_index, ost->index);
4512 ost->max_frames = INT64_MAX;
4513 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4515 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4517 if (next = strchr(bsf, ','))
4519 if (!(bsfc = av_bitstream_filter_init(bsf))) {
4520 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4524 bsfc_prev->next = bsfc;
4526 ost->bitstream_filters = bsfc;
4532 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4534 uint32_t tag = strtol(codec_tag, &next, 0);
4536 tag = AV_RL32(codec_tag);
4537 st->codec->codec_tag = tag;
4540 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4541 if (qscale >= 0 || same_quant) {
4542 st->codec->flags |= CODEC_FLAG_QSCALE;
4543 st->codec->global_quality = FF_QP2LAMBDA * qscale;
4546 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4547 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4549 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4550 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4551 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4553 ost->source_index = source_index;
4554 if (source_index >= 0) {
4555 ost->sync_ist = input_streams[source_index];
4556 input_streams[source_index]->discard = 0;
4557 input_streams[source_index]->st->discard = AVDISCARD_NONE;
4560 ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
4565 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4568 const char *p = str;
4575 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4582 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4586 AVCodecContext *video_enc;
4588 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4590 video_enc = st->codec;
4592 if (!ost->stream_copy) {
4593 const char *p = NULL;
4594 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
4595 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4596 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
4599 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4600 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4601 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4605 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4606 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4607 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4611 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4612 if (frame_aspect_ratio) {
4614 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4615 q.num <= 0 || q.den <= 0) {
4616 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4619 ost->frame_aspect_ratio = av_q2d(q);
4622 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4623 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4624 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4625 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4628 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4631 video_enc->gop_size = 0;
4632 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4634 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4635 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4638 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4640 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4642 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4643 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4646 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4649 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4650 for (i = 0; p; i++) {
4652 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4654 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4657 /* FIXME realloc failure */
4658 video_enc->rc_override =
4659 av_realloc(video_enc->rc_override,
4660 sizeof(RcOverride) * (i + 1));
4661 video_enc->rc_override[i].start_frame = start;
4662 video_enc->rc_override[i].end_frame = end;
4664 video_enc->rc_override[i].qscale = q;
4665 video_enc->rc_override[i].quality_factor = 1.0;
4668 video_enc->rc_override[i].qscale = 0;
4669 video_enc->rc_override[i].quality_factor = -q/100.0;
4674 video_enc->rc_override_count = i;
4675 if (!video_enc->rc_initial_buffer_occupancy)
4676 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4677 video_enc->intra_dc_precision = intra_dc_precision - 8;
4680 video_enc->flags|= CODEC_FLAG_PSNR;
4685 video_enc->flags |= CODEC_FLAG_PASS1;
4688 video_enc->flags |= CODEC_FLAG_PASS2;
4692 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4693 if (forced_key_frames)
4694 parse_forced_key_frames(forced_key_frames, ost);
4696 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4698 ost->top_field_first = -1;
4699 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4701 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4703 ost->avfilter = av_strdup(filters);
4705 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4711 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4716 AVCodecContext *audio_enc;
4718 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4721 audio_enc = st->codec;
4722 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4724 if (!ost->stream_copy) {
4725 char *sample_fmt = NULL;
4727 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4729 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4731 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4732 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4736 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4738 ost->rematrix_volume=1.0;
4739 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4742 /* check for channel mapping for this audio stream */
4743 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4744 AudioChannelMap *map = &o->audio_channel_maps[n];
4745 InputStream *ist = input_streams[ost->source_index];
4746 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4747 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4748 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4749 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4750 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4752 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4753 ost->file_index, ost->st->index);
4760 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4764 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4765 if (!ost->stream_copy) {
4766 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4773 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4775 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4776 ost->stream_copy = 1;
4780 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4784 AVCodecContext *subtitle_enc;
4786 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4788 subtitle_enc = st->codec;
4790 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4792 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4797 /* arg format is "output-stream-index:streamid-value". */
4798 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4804 av_strlcpy(idx_str, arg, sizeof(idx_str));
4805 p = strchr(idx_str, ':');
4807 av_log(NULL, AV_LOG_FATAL,
4808 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4813 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4814 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4815 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4819 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4821 AVFormatContext *is = ifile->ctx;
4822 AVFormatContext *os = ofile->ctx;
4825 for (i = 0; i < is->nb_chapters; i++) {
4826 AVChapter *in_ch = is->chapters[i], *out_ch;
4827 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4828 AV_TIME_BASE_Q, in_ch->time_base);
4829 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4830 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4833 if (in_ch->end < ts_off)
4835 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4838 out_ch = av_mallocz(sizeof(AVChapter));
4840 return AVERROR(ENOMEM);
4842 out_ch->id = in_ch->id;
4843 out_ch->time_base = in_ch->time_base;
4844 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4845 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4848 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4851 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4853 return AVERROR(ENOMEM);
4854 os->chapters[os->nb_chapters - 1] = out_ch;
4859 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4862 AVFormatContext *ic = avformat_alloc_context();
4864 ic->interrupt_callback = int_cb;
4865 err = avformat_open_input(&ic, filename, NULL, NULL);
4868 /* copy stream format */
4869 for(i=0;i<ic->nb_streams;i++) {
4873 AVCodecContext *avctx;
4875 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4876 ost = new_output_stream(o, s, codec->type, -1);
4881 // FIXME: a more elegant solution is needed
4882 memcpy(st, ic->streams[i], sizeof(AVStream));
4884 st->info = av_malloc(sizeof(*st->info));
4885 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4887 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4889 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4890 choose_sample_fmt(st, codec);
4891 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4892 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4895 avformat_close_input(&ic);
4899 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4900 AVFormatContext *oc)
4904 if (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type != AVMEDIA_TYPE_VIDEO) {
4905 av_log(NULL, AV_LOG_FATAL, "Only video filters are supported currently.\n");
4909 ost = new_video_stream(o, oc, -1);
4910 ost->source_index = -1;
4911 ost->filter = ofilter;
4915 if (ost->stream_copy) {
4916 av_log(NULL, AV_LOG_ERROR, "Streamcopy requested for output stream %d:%d, "
4917 "which is fed from a complex filtergraph. Filtering and streamcopy "
4918 "cannot be used together.\n", ost->file_index, ost->index);
4922 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4923 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4926 avfilter_inout_free(&ofilter->out_tmp);
4929 static void opt_output_file(void *optctx, const char *filename)
4931 OptionsContext *o = optctx;
4932 AVFormatContext *oc;
4934 AVOutputFormat *file_oformat;
4938 if (configure_complex_filters() < 0) {
4939 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4943 if (!strcmp(filename, "-"))
4946 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4948 print_error(filename, err);
4951 file_oformat= oc->oformat;
4952 oc->interrupt_callback = int_cb;
4954 /* create streams for all unlabeled output pads */
4955 for (i = 0; i < nb_filtergraphs; i++) {
4956 FilterGraph *fg = filtergraphs[i];
4957 for (j = 0; j < fg->nb_outputs; j++) {
4958 OutputFilter *ofilter = fg->outputs[j];
4960 if (!ofilter->out_tmp || ofilter->out_tmp->name)
4963 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4964 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
4965 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
4966 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
4968 init_output_filter(ofilter, o, oc);
4972 if (!strcmp(file_oformat->name, "ffm") &&
4973 av_strstart(filename, "http:", NULL)) {
4975 /* special case for files sent to ffserver: we get the stream
4976 parameters from ffserver */
4977 int err = read_ffserver_streams(o, oc, filename);
4979 print_error(filename, err);
4982 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4983 ost = output_streams[j];
4984 for (i = 0; i < nb_input_streams; i++) {
4985 ist = input_streams[i];
4986 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4988 ost->source_index= i;
4990 ist->st->discard = AVDISCARD_NONE;
4995 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));
4999 } else if (!o->nb_stream_maps) {
5000 /* pick the "best" stream of each type */
5002 /* video: highest resolution */
5003 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
5004 int area = 0, idx = -1;
5005 for (i = 0; i < nb_input_streams; i++) {
5006 ist = input_streams[i];
5007 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
5008 ist->st->codec->width * ist->st->codec->height > area) {
5009 area = ist->st->codec->width * ist->st->codec->height;
5014 new_video_stream(o, oc, idx);
5017 /* audio: most channels */
5018 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
5019 int channels = 0, idx = -1;
5020 for (i = 0; i < nb_input_streams; i++) {
5021 ist = input_streams[i];
5022 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
5023 ist->st->codec->channels > channels) {
5024 channels = ist->st->codec->channels;
5029 new_audio_stream(o, oc, idx);
5032 /* subtitles: pick first */
5033 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
5034 for (i = 0; i < nb_input_streams; i++)
5035 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
5036 new_subtitle_stream(o, oc, i);
5040 /* do something with data? */
5042 for (i = 0; i < o->nb_stream_maps; i++) {
5043 StreamMap *map = &o->stream_maps[i];
5044 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
5049 if (map->linklabel) {
5051 OutputFilter *ofilter = NULL;
5054 for (j = 0; j < nb_filtergraphs; j++) {
5055 fg = filtergraphs[j];
5056 for (k = 0; k < fg->nb_outputs; k++) {
5057 AVFilterInOut *out = fg->outputs[k]->out_tmp;
5058 if (out && !strcmp(out->name, map->linklabel)) {
5059 ofilter = fg->outputs[k];
5066 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
5067 "in any defined filter graph.\n", map->linklabel);
5070 init_output_filter(ofilter, o, oc);
5072 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5073 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5075 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5077 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5079 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5082 switch (ist->st->codec->codec_type) {
5083 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
5084 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
5085 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
5086 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
5087 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5089 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5090 map->file_index, map->stream_index);
5098 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5099 AVDictionaryEntry *e;
5100 ost = output_streams[i];
5102 if ( ost->stream_copy
5103 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5104 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5105 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5109 /* handle attached files */
5110 for (i = 0; i < o->nb_attachments; i++) {
5112 uint8_t *attachment;
5116 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5117 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5121 if ((len = avio_size(pb)) <= 0) {
5122 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5126 if (!(attachment = av_malloc(len))) {
5127 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5131 avio_read(pb, attachment, len);
5133 ost = new_attachment_stream(o, oc, -1);
5134 ost->stream_copy = 0;
5135 ost->attachment_filename = o->attachments[i];
5136 ost->st->codec->extradata = attachment;
5137 ost->st->codec->extradata_size = len;
5139 p = strrchr(o->attachments[i], '/');
5140 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5144 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5145 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5148 output_files[nb_output_files - 1]->ctx = oc;
5149 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
5150 output_files[nb_output_files - 1]->recording_time = o->recording_time;
5151 if (o->recording_time != INT64_MAX)
5152 oc->duration = o->recording_time;
5153 output_files[nb_output_files - 1]->start_time = o->start_time;
5154 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5155 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5157 /* check filename in case of an image number is expected */
5158 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5159 if (!av_filename_number_test(oc->filename)) {
5160 print_error(oc->filename, AVERROR(EINVAL));
5165 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5166 /* test if it already exists to avoid losing precious files */
5167 assert_file_overwrite(filename);
5170 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5171 &oc->interrupt_callback,
5172 &output_files[nb_output_files - 1]->opts)) < 0) {
5173 print_error(filename, err);
5178 if (o->mux_preload) {
5180 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5181 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5183 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5186 for (i = 0; i < o->nb_metadata_map; i++) {
5188 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5190 if (in_file_index >= nb_input_files) {
5191 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5194 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5198 if (o->chapters_input_file >= nb_input_files) {
5199 if (o->chapters_input_file == INT_MAX) {
5200 /* copy chapters from the first input file that has them*/
5201 o->chapters_input_file = -1;
5202 for (i = 0; i < nb_input_files; i++)
5203 if (input_files[i]->ctx->nb_chapters) {
5204 o->chapters_input_file = i;
5208 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5209 o->chapters_input_file);
5213 if (o->chapters_input_file >= 0)
5214 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5215 !o->metadata_chapters_manual);
5217 /* copy global metadata by default */
5218 if (!o->metadata_global_manual && nb_input_files){
5219 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5220 AV_DICT_DONT_OVERWRITE);
5221 if(o->recording_time != INT64_MAX)
5222 av_dict_set(&oc->metadata, "duration", NULL, 0);
5224 if (!o->metadata_streams_manual)
5225 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5227 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
5229 ist = input_streams[output_streams[i]->source_index];
5230 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5233 /* process manually set metadata */
5234 for (i = 0; i < o->nb_metadata; i++) {
5237 const char *stream_spec;
5238 int index = 0, j, ret = 0;
5240 val = strchr(o->metadata[i].u.str, '=');
5242 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5243 o->metadata[i].u.str);
5248 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5250 for (j = 0; j < oc->nb_streams; j++) {
5251 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5252 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5256 printf("ret %d, stream_spec %s\n", ret, stream_spec);
5264 if (index < 0 || index >= oc->nb_chapters) {
5265 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5268 m = &oc->chapters[index]->metadata;
5271 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5274 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5278 reset_options(o, 0);
5281 /* same option as mencoder */
5282 static int opt_pass(const char *opt, const char *arg)
5284 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5288 static int64_t getmaxrss(void)
5290 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5291 struct rusage rusage;
5292 getrusage(RUSAGE_SELF, &rusage);
5293 return (int64_t)rusage.ru_maxrss * 1024;
5294 #elif HAVE_GETPROCESSMEMORYINFO
5296 PROCESS_MEMORY_COUNTERS memcounters;
5297 proc = GetCurrentProcess();
5298 memcounters.cb = sizeof(memcounters);
5299 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5300 return memcounters.PeakPagefileUsage;
5306 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5308 return parse_option(o, "q:a", arg, options);
5311 static void show_usage(void)
5313 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5314 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5315 av_log(NULL, AV_LOG_INFO, "\n");
5318 static int opt_help(const char *opt, const char *arg)
5320 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5321 av_log_set_callback(log_callback_help);
5323 show_help_options(options, "Main options:\n",
5324 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5325 show_help_options(options, "\nAdvanced options:\n",
5326 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5328 show_help_options(options, "\nVideo options:\n",
5329 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5331 show_help_options(options, "\nAdvanced Video options:\n",
5332 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5333 OPT_VIDEO | OPT_EXPERT);
5334 show_help_options(options, "\nAudio options:\n",
5335 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5337 show_help_options(options, "\nAdvanced Audio options:\n",
5338 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5339 OPT_AUDIO | OPT_EXPERT);
5340 show_help_options(options, "\nSubtitle options:\n",
5341 OPT_SUBTITLE | OPT_GRAB,
5343 show_help_options(options, "\nAudio/Video grab options:\n",
5347 show_help_children(avcodec_get_class(), flags);
5348 show_help_children(avformat_get_class(), flags);
5349 show_help_children(sws_get_class(), flags);
5354 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5356 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5357 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5359 if (!strncmp(arg, "pal-", 4)) {
5362 } else if (!strncmp(arg, "ntsc-", 5)) {
5365 } else if (!strncmp(arg, "film-", 5)) {
5369 /* Try to determine PAL/NTSC by peeking in the input files */
5370 if (nb_input_files) {
5372 for (j = 0; j < nb_input_files; j++) {
5373 for (i = 0; i < input_files[j]->nb_streams; i++) {
5374 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5375 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5377 fr = c->time_base.den * 1000 / c->time_base.num;
5381 } else if ((fr == 29970) || (fr == 23976)) {
5386 if (norm != UNKNOWN)
5390 if (norm != UNKNOWN)
5391 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5394 if (norm == UNKNOWN) {
5395 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5396 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5397 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5401 if (!strcmp(arg, "vcd")) {
5402 opt_video_codec(o, "c:v", "mpeg1video");
5403 opt_audio_codec(o, "c:a", "mp2");
5404 parse_option(o, "f", "vcd", options);
5406 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5407 parse_option(o, "r", frame_rates[norm], options);
5408 opt_default("g", norm == PAL ? "15" : "18");
5410 opt_default("b:v", "1150000");
5411 opt_default("maxrate", "1150000");
5412 opt_default("minrate", "1150000");
5413 opt_default("bufsize", "327680"); // 40*1024*8;
5415 opt_default("b:a", "224000");
5416 parse_option(o, "ar", "44100", options);
5417 parse_option(o, "ac", "2", options);
5419 opt_default("packetsize", "2324");
5420 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5422 /* We have to offset the PTS, so that it is consistent with the SCR.
5423 SCR starts at 36000, but the first two packs contain only padding
5424 and the first pack from the other stream, respectively, may also have
5425 been written before.
5426 So the real data starts at SCR 36000+3*1200. */
5427 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5428 } else if (!strcmp(arg, "svcd")) {
5430 opt_video_codec(o, "c:v", "mpeg2video");
5431 opt_audio_codec(o, "c:a", "mp2");
5432 parse_option(o, "f", "svcd", options);
5434 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5435 parse_option(o, "r", frame_rates[norm], options);
5436 parse_option(o, "pix_fmt", "yuv420p", options);
5437 opt_default("g", norm == PAL ? "15" : "18");
5439 opt_default("b:v", "2040000");
5440 opt_default("maxrate", "2516000");
5441 opt_default("minrate", "0"); // 1145000;
5442 opt_default("bufsize", "1835008"); // 224*1024*8;
5443 opt_default("scan_offset", "1");
5446 opt_default("b:a", "224000");
5447 parse_option(o, "ar", "44100", options);
5449 opt_default("packetsize", "2324");
5451 } else if (!strcmp(arg, "dvd")) {
5453 opt_video_codec(o, "c:v", "mpeg2video");
5454 opt_audio_codec(o, "c:a", "ac3");
5455 parse_option(o, "f", "dvd", options);
5457 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5458 parse_option(o, "r", frame_rates[norm], options);
5459 parse_option(o, "pix_fmt", "yuv420p", options);
5460 opt_default("g", norm == PAL ? "15" : "18");
5462 opt_default("b:v", "6000000");
5463 opt_default("maxrate", "9000000");
5464 opt_default("minrate", "0"); // 1500000;
5465 opt_default("bufsize", "1835008"); // 224*1024*8;
5467 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5468 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5470 opt_default("b:a", "448000");
5471 parse_option(o, "ar", "48000", options);
5473 } else if (!strncmp(arg, "dv", 2)) {
5475 parse_option(o, "f", "dv", options);
5477 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5478 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5479 norm == PAL ? "yuv420p" : "yuv411p", options);
5480 parse_option(o, "r", frame_rates[norm], options);
5482 parse_option(o, "ar", "48000", options);
5483 parse_option(o, "ac", "2", options);
5486 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5487 return AVERROR(EINVAL);
5492 static int opt_vstats_file(const char *opt, const char *arg)
5494 av_free (vstats_filename);
5495 vstats_filename = av_strdup (arg);
5499 static int opt_vstats(const char *opt, const char *arg)
5502 time_t today2 = time(NULL);
5503 struct tm *today = localtime(&today2);
5505 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5507 return opt_vstats_file(opt, filename);
5510 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5512 return parse_option(o, "frames:v", arg, options);
5515 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5517 return parse_option(o, "frames:a", arg, options);
5520 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5522 return parse_option(o, "frames:d", arg, options);
5525 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5528 char filename[1000], tmp[1000], tmp2[1000], line[1000];
5529 const char *codec_name = *opt == 'v' ? video_codec_name :
5530 *opt == 'a' ? audio_codec_name :
5531 subtitle_codec_name;
5533 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5534 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5535 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5537 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5542 int e= fscanf(f, "%999[^\n]\n", line) - 1;
5543 if(line[0] == '#' && !e)
5545 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
5547 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5550 if(!strcmp(tmp, "acodec")){
5551 opt_audio_codec(o, tmp, tmp2);
5552 }else if(!strcmp(tmp, "vcodec")){
5553 opt_video_codec(o, tmp, tmp2);
5554 }else if(!strcmp(tmp, "scodec")){
5555 opt_subtitle_codec(o, tmp, tmp2);
5556 }else if(!strcmp(tmp, "dcodec")){
5557 opt_data_codec(o, tmp, tmp2);
5558 }else if(opt_default(tmp, tmp2) < 0){
5559 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
5569 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5573 static int opt_passlogfile(const char *opt, const char *arg)
5575 pass_logfilename_prefix = arg;
5576 #if CONFIG_LIBX264_ENCODER
5577 return opt_default(opt, arg);
5583 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5585 char *s = av_asprintf("%s:%c", opt + 1, *opt);
5586 int ret = parse_option(o, s, arg, options);
5591 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5593 if(!strcmp(opt, "b")){
5594 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5595 return parse_option(o, "b:v", arg, options);
5597 return opt_default(opt, arg);
5600 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5604 if(!strcmp(opt, "qscale")){
5605 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5606 return parse_option(o, "q:v", arg, options);
5608 s = av_asprintf("q%s", opt + 6);
5609 ret = parse_option(o, s, arg, options);
5614 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5616 if(!strcmp(opt, "profile")){
5617 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5618 return parse_option(o, "profile:v", arg, options);
5620 return opt_default(opt, arg);
5623 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5625 return parse_option(o, "filter:v", arg, options);
5628 static int opt_vsync(const char *opt, const char *arg)
5630 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
5631 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
5632 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5633 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
5635 if (video_sync_method == VSYNC_AUTO)
5636 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5640 static int opt_deinterlace(const char *opt, const char *arg)
5642 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5647 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5649 int idx = locate_option(argc, argv, options, "cpuflags");
5650 if (idx && argv[idx + 1])
5651 opt_cpuflags("cpuflags", argv[idx + 1]);
5654 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5656 char layout_str[32];
5659 int ret, channels, ac_str_size;
5662 layout = av_get_channel_layout(arg);
5664 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5665 return AVERROR(EINVAL);
5667 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5668 ret = opt_default(opt, layout_str);
5672 /* set 'ac' option based on channel layout */
5673 channels = av_get_channel_layout_nb_channels(layout);
5674 snprintf(layout_str, sizeof(layout_str), "%d", channels);
5675 stream_str = strchr(opt, ':');
5676 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5677 ac_str = av_mallocz(ac_str_size);
5679 return AVERROR(ENOMEM);
5680 av_strlcpy(ac_str, "ac", 3);
5682 av_strlcat(ac_str, stream_str, ac_str_size);
5683 ret = parse_option(o, ac_str, layout_str, options);
5689 static int opt_filter_complex(const char *opt, const char *arg)
5691 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5692 &nb_filtergraphs, nb_filtergraphs + 1);
5693 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5694 return AVERROR(ENOMEM);
5695 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
5696 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5700 #define OFFSET(x) offsetof(OptionsContext, x)
5701 static const OptionDef options[] = {
5703 #include "cmdutils_common_opts.h"
5704 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5705 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5706 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5707 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5708 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5709 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5710 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5711 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5712 { "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]" },
5713 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5714 "outfile[,metadata]:infile[,metadata]" },
5715 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
5716 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5717 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5718 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5719 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5720 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5721 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5722 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5723 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5724 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5725 "add timings for benchmarking" },
5726 { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5727 "add timings for each task" },
5728 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5729 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5730 "dump each input packet" },
5731 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5732 "when dumping packets, also dump the payload" },
5733 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5734 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5735 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5736 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5737 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5738 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
5739 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
5740 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5741 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5742 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5743 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5744 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5745 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5746 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5747 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5748 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5749 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5750 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5751 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5752 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5753 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5754 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5755 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5758 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5759 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5760 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5761 { "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" },
5762 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5763 { "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" },
5764 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5765 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5766 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5767 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5768 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5769 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5770 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5771 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5772 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5773 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5774 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5775 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5776 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5777 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5778 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5779 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5780 "use same quantizer as source (implies VBR)" },
5781 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5782 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5783 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5784 "this option is deprecated, use the yadif filter instead" },
5785 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5786 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5787 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5788 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5789 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5790 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5791 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5792 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5793 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5794 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5795 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5796 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5797 { "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" },
5798 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5801 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5802 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5803 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5804 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5805 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5806 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5807 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5808 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5809 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5810 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
5811 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5813 /* subtitle options */
5814 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5815 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5816 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5819 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5820 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5821 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5824 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5825 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5827 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5828 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5829 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5831 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5832 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5833 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5834 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5835 /* data codec support */
5836 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5837 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5839 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5843 int main(int argc, char **argv)
5845 OptionsContext o = { 0 };
5848 reset_options(&o, 0);
5850 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5851 parse_loglevel(argc, argv, options);
5853 if(argc>1 && !strcmp(argv[1], "-d")){
5855 av_log_set_callback(log_callback_null);
5860 avcodec_register_all();
5862 avdevice_register_all();
5864 avfilter_register_all();
5866 avformat_network_init();
5868 show_banner(argc, argv, options);
5872 parse_cpuflags(argc, argv, options);
5875 parse_options(&o, argc, argv, options, opt_output_file);
5877 if (nb_output_files <= 0 && nb_input_files == 0) {
5879 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5883 /* file converter / grab */
5884 if (nb_output_files <= 0) {
5885 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5889 if (nb_input_files == 0) {
5890 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5894 current_time = ti = getutime();
5895 if (transcode() < 0)
5897 ti = getutime() - ti;
5899 int maxrss = getmaxrss() / 1024;
5900 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);