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 "libavcodec/audioconvert.h"
40 #include "libavutil/audioconvert.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/samplefmt.h"
43 #include "libavutil/colorspace.h"
44 #include "libavutil/fifo.h"
45 #include "libavutil/intreadwrite.h"
46 #include "libavutil/dict.h"
47 #include "libavutil/mathematics.h"
48 #include "libavutil/pixdesc.h"
49 #include "libavutil/avstring.h"
50 #include "libavutil/libm.h"
51 #include "libavutil/imgutils.h"
52 #include "libavutil/timestamp.h"
53 #include "libavformat/os_support.h"
54 #include "libswresample/swresample.h"
56 #include "libavformat/ffm.h" // not public API
58 # include "libavfilter/avcodec.h"
59 # include "libavfilter/avfilter.h"
60 # include "libavfilter/avfiltergraph.h"
61 # include "libavfilter/buffersink.h"
62 # include "libavfilter/buffersrc.h"
63 # include "libavfilter/vsrc_buffer.h"
65 #if HAVE_SYS_RESOURCE_H
66 #include <sys/types.h>
68 #include <sys/resource.h>
69 #elif HAVE_GETPROCESSTIMES
72 #if HAVE_GETPROCESSMEMORYINFO
78 #include <sys/select.h>
83 #include <sys/ioctl.h>
93 #include "libavutil/avassert.h"
96 #define VSYNC_PASSTHROUGH 0
99 #define VSYNC_DROP 0xff
101 const char program_name[] = "ffmpeg";
102 const int program_birth_year = 2000;
104 /* select an input stream for an output stream */
105 typedef struct StreamMap {
106 int disabled; /** 1 is this mapping is disabled by a negative map */
110 int sync_stream_index;
111 char *linklabel; /** name of an output link, for mapping lavfi outputs */
115 int file_idx, stream_idx, channel_idx; // input
116 int ofile_idx, ostream_idx; // output
119 static const OptionDef options[];
121 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
123 static int frame_bits_per_raw_sample = 0;
124 static int video_discard = 0;
125 static int same_quant = 0;
126 static int do_deinterlace = 0;
127 static int intra_dc_precision = 8;
128 static int qp_hist = 0;
129 static int intra_only = 0;
130 static const char *video_codec_name = NULL;
131 static const char *audio_codec_name = NULL;
132 static const char *subtitle_codec_name = NULL;
134 static int file_overwrite = 0;
135 static int no_file_overwrite = 0;
136 static int do_benchmark = 0;
137 static int do_benchmark_all = 0;
138 static int do_hex_dump = 0;
139 static int do_pkt_dump = 0;
140 static int do_psnr = 0;
141 static int do_pass = 0;
142 static const char *pass_logfilename_prefix;
143 static int video_sync_method = VSYNC_AUTO;
144 static int audio_sync_method = 0;
145 static float audio_drift_threshold = 0.1;
146 static int copy_ts = 0;
147 static int copy_tb = -1;
148 static int opt_shortest = 0;
149 static char *vstats_filename;
150 static FILE *vstats_file;
152 static int audio_volume = 256;
154 static int exit_on_error = 0;
155 static int using_stdin = 0;
156 static int run_as_daemon = 0;
157 static volatile int received_nb_signals = 0;
158 static int64_t video_size = 0;
159 static int64_t audio_size = 0;
160 static int64_t extra_size = 0;
161 static int nb_frames_dup = 0;
162 static int nb_frames_drop = 0;
163 static int input_sync;
165 static float dts_delta_threshold = 10;
166 static float dts_error_threshold = 3600*30;
168 static int print_stats = 1;
169 static int debug_ts = 0;
170 static int current_time;
172 static uint8_t *audio_buf;
173 static unsigned int allocated_audio_buf_size;
174 static uint8_t *async_buf;
175 static unsigned int allocated_async_buf_size;
177 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
179 typedef struct InputFilter {
180 AVFilterContext *filter;
181 struct InputStream *ist;
182 struct FilterGraph *graph;
185 typedef struct OutputFilter {
186 AVFilterContext *filter;
187 struct OutputStream *ost;
188 struct FilterGraph *graph;
190 /* temporary storage until stream maps are processed */
191 AVFilterInOut *out_tmp;
194 typedef struct FilterGraph {
196 const char *graph_desc;
198 AVFilterGraph *graph;
200 InputFilter **inputs;
202 OutputFilter **outputs;
206 typedef struct FrameBuffer {
212 enum PixelFormat pix_fmt;
215 struct InputStream *ist;
216 struct FrameBuffer *next;
219 typedef struct InputStream {
222 int discard; /* true if stream data should be discarded */
223 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
225 AVFrame *decoded_frame;
227 int64_t start; /* time when read started */
228 /* predicted dts of the next packet read for this stream or (when there are
229 * several frames in a packet) of the next frame in current packet */
231 /* dts of the last packet read for this stream */
234 int64_t next_pts; ///< synthetic pts for the next decode frame
235 int64_t pts; ///< current pts of the decoded frame
237 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 int resample_sample_rate;
303 float rematrix_volume;
304 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
309 OutputFilter *filter;
313 int64_t swr_dither_method;
314 double swr_dither_scale;
316 int is_past_recording_time;
318 const char *attachment_filename;
319 int copy_initial_nonkeyframes;
321 enum PixelFormat pix_fmts[2];
327 /* init terminal so that we can grab keys */
328 static struct termios oldtty;
329 static int restore_tty;
332 typedef struct OutputFile {
333 AVFormatContext *ctx;
335 int ost_index; /* index of the first stream in output_streams */
336 int64_t recording_time; /* desired length of the resulting file in microseconds */
337 int64_t start_time; /* start time in microseconds */
338 uint64_t limit_filesize; /* filesize limit expressed in bytes */
341 static InputStream **input_streams = NULL;
342 static int nb_input_streams = 0;
343 static InputFile **input_files = NULL;
344 static int nb_input_files = 0;
346 static OutputStream **output_streams = NULL;
347 static int nb_output_streams = 0;
348 static OutputFile **output_files = NULL;
349 static int nb_output_files = 0;
351 static FilterGraph **filtergraphs;
354 typedef struct OptionsContext {
355 /* input/output options */
359 SpecifierOpt *codec_names;
361 SpecifierOpt *audio_channels;
362 int nb_audio_channels;
363 SpecifierOpt *audio_sample_rate;
364 int nb_audio_sample_rate;
365 SpecifierOpt *rematrix_volume;
366 int nb_rematrix_volume;
367 SpecifierOpt *frame_rates;
369 SpecifierOpt *frame_sizes;
371 SpecifierOpt *frame_pix_fmts;
372 int nb_frame_pix_fmts;
375 int64_t input_ts_offset;
378 SpecifierOpt *ts_scale;
380 SpecifierOpt *dump_attachment;
381 int nb_dump_attachment;
384 StreamMap *stream_maps;
386 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
387 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
388 int metadata_global_manual;
389 int metadata_streams_manual;
390 int metadata_chapters_manual;
391 const char **attachments;
394 int chapters_input_file;
396 int64_t recording_time;
397 uint64_t limit_filesize;
403 int subtitle_disable;
406 /* indexed by output file stream index */
410 SpecifierOpt *metadata;
412 SpecifierOpt *max_frames;
414 SpecifierOpt *bitstream_filters;
415 int nb_bitstream_filters;
416 SpecifierOpt *codec_tags;
418 SpecifierOpt *sample_fmts;
420 SpecifierOpt *qscale;
422 SpecifierOpt *forced_key_frames;
423 int nb_forced_key_frames;
424 SpecifierOpt *force_fps;
426 SpecifierOpt *frame_aspect_ratios;
427 int nb_frame_aspect_ratios;
428 SpecifierOpt *rc_overrides;
430 SpecifierOpt *intra_matrices;
431 int nb_intra_matrices;
432 SpecifierOpt *inter_matrices;
433 int nb_inter_matrices;
434 SpecifierOpt *top_field_first;
435 int nb_top_field_first;
436 SpecifierOpt *metadata_map;
438 SpecifierOpt *presets;
440 SpecifierOpt *copy_initial_nonkeyframes;
441 int nb_copy_initial_nonkeyframes;
442 SpecifierOpt *filters;
446 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
449 for (i = 0; i < o->nb_ ## name; i++) {\
450 char *spec = o->name[i].specifier;\
451 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
452 outvar = o->name[i].u.type;\
458 static int64_t getutime(void)
461 struct rusage rusage;
463 getrusage(RUSAGE_SELF, &rusage);
464 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
465 #elif HAVE_GETPROCESSTIMES
468 proc = GetCurrentProcess();
469 GetProcessTimes(proc, &c, &e, &k, &u);
470 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
476 static void update_benchmark(const char *fmt, ...)
478 if (do_benchmark_all) {
479 int64_t t = getutime();
485 vsnprintf(buf, sizeof(buf), fmt, va);
487 printf("bench: %8"PRIu64" %s \n", t - current_time, buf);
493 static void reset_options(OptionsContext *o, int is_input)
495 const OptionDef *po = options;
496 OptionsContext bak= *o;
499 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
501 void *dst = (uint8_t*)o + po->u.off;
503 if (po->flags & OPT_SPEC) {
504 SpecifierOpt **so = dst;
505 int i, *count = (int*)(so + 1);
506 for (i = 0; i < *count; i++) {
507 av_freep(&(*so)[i].specifier);
508 if (po->flags & OPT_STRING)
509 av_freep(&(*so)[i].u.str);
513 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
518 for (i = 0; i < o->nb_stream_maps; i++)
519 av_freep(&o->stream_maps[i].linklabel);
520 av_freep(&o->stream_maps);
521 av_freep(&o->audio_channel_maps);
522 av_freep(&o->streamid_map);
524 memset(o, 0, sizeof(*o));
526 if(is_input) o->recording_time = bak.recording_time;
527 else o->recording_time = INT64_MAX;
528 o->mux_max_delay = 0.7;
529 o->limit_filesize = UINT64_MAX;
530 o->chapters_input_file = INT_MAX;
536 static int alloc_buffer(InputStream *ist, AVCodecContext *s, FrameBuffer **pbuf)
538 FrameBuffer *buf = av_mallocz(sizeof(*buf));
540 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
541 int h_chroma_shift, v_chroma_shift;
542 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
543 int w = s->width, h = s->height;
546 return AVERROR(ENOMEM);
548 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
553 avcodec_align_dimensions(s, &w, &h);
554 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
555 s->pix_fmt, 32)) < 0) {
559 /* XXX this shouldn't be needed, but some tests break without this line
560 * those decoders are buggy and need to be fixed.
561 * the following tests fail:
562 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
564 memset(buf->base[0], 128, ret);
566 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
567 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
568 const int h_shift = i==0 ? 0 : h_chroma_shift;
569 const int v_shift = i==0 ? 0 : v_chroma_shift;
570 if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1])
571 buf->data[i] = buf->base[i];
573 buf->data[i] = buf->base[i] +
574 FFALIGN((buf->linesize[i]*edge >> v_shift) +
575 (pixel_size*edge >> h_shift), 32);
579 buf->pix_fmt = s->pix_fmt;
586 static void free_buffer_pool(InputStream *ist)
588 FrameBuffer *buf = ist->buffer_pool;
590 ist->buffer_pool = buf->next;
591 av_freep(&buf->base[0]);
593 buf = ist->buffer_pool;
597 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
599 av_assert0(buf->refcount);
601 if (!buf->refcount) {
602 buf->next = ist->buffer_pool;
603 ist->buffer_pool = buf;
607 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
609 InputStream *ist = s->opaque;
613 if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0)
616 if (!ist->buffer_pool && (ret = alloc_buffer(ist, s, &ist->buffer_pool)) < 0)
619 buf = ist->buffer_pool;
620 ist->buffer_pool = buf->next;
622 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
623 av_freep(&buf->base[0]);
625 if ((ret = alloc_buffer(ist, s, &buf)) < 0)
631 frame->type = FF_BUFFER_TYPE_USER;
632 frame->extended_data = frame->data;
633 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
634 frame->width = buf->w;
635 frame->height = buf->h;
636 frame->format = buf->pix_fmt;
637 frame->sample_aspect_ratio = s->sample_aspect_ratio;
639 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
640 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
641 frame->data[i] = buf->data[i];
642 frame->linesize[i] = buf->linesize[i];
648 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
650 InputStream *ist = s->opaque;
651 FrameBuffer *buf = frame->opaque;
654 if(frame->type!=FF_BUFFER_TYPE_USER)
655 return avcodec_default_release_buffer(s, frame);
657 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
658 frame->data[i] = NULL;
660 unref_buffer(ist, buf);
663 static void filter_release_buffer(AVFilterBuffer *fb)
665 FrameBuffer *buf = fb->priv;
667 unref_buffer(buf->ist, buf);
670 static enum PixelFormat choose_pixel_fmt(AVStream *st, AVCodec *codec, enum PixelFormat target)
672 if (codec && codec->pix_fmts) {
673 const enum PixelFormat *p = codec->pix_fmts;
674 int has_alpha= av_pix_fmt_descriptors[target].nb_components % 2 == 0;
675 enum PixelFormat best= PIX_FMT_NONE;
676 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
677 if (st->codec->codec_id == CODEC_ID_MJPEG) {
678 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
679 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
680 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
681 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
684 for (; *p != PIX_FMT_NONE; p++) {
685 best= avcodec_find_best_pix_fmt2(best, *p, target, has_alpha, NULL);
689 if (*p == PIX_FMT_NONE) {
690 if (target != PIX_FMT_NONE)
691 av_log(NULL, AV_LOG_WARNING,
692 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
693 av_pix_fmt_descriptors[target].name,
695 av_pix_fmt_descriptors[best].name);
702 static const enum PixelFormat *choose_pixel_fmts(OutputStream *ost)
704 if (ost->st->codec->pix_fmt != PIX_FMT_NONE) {
705 ost->pix_fmts[0] = choose_pixel_fmt(ost->st, ost->enc, ost->st->codec->pix_fmt);
706 return ost->pix_fmts;
707 } else if (ost->enc->pix_fmts) {
708 if (ost->st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
709 if (ost->st->codec->codec_id == CODEC_ID_MJPEG) {
710 return (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
711 } else if (ost->st->codec->codec_id == CODEC_ID_LJPEG) {
712 return (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
713 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
716 return ost->enc->pix_fmts;
721 static int configure_video_filters(FilterGraph *fg)
723 InputStream *ist = fg->inputs[0]->ist;
724 OutputStream *ost = fg->outputs[0]->ost;
725 AVFilterContext *last_filter, *filter;
726 /** filter graph containing all filters including input & output */
727 AVCodecContext *codec = ost->st->codec;
728 enum PixelFormat *pix_fmts = choose_pixel_fmts(ost);
729 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
730 AVRational sample_aspect_ratio;
734 avfilter_graph_free(&fg->graph);
735 fg->graph = avfilter_graph_alloc();
737 return AVERROR(ENOMEM);
739 if (ist->st->sample_aspect_ratio.num) {
740 sample_aspect_ratio = ist->st->sample_aspect_ratio;
742 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
744 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,
745 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
746 sample_aspect_ratio.num, sample_aspect_ratio.den, SWS_BILINEAR + ((ist->st->codec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
748 ret = avfilter_graph_create_filter(&fg->inputs[0]->filter,
749 avfilter_get_by_name("buffer"),
750 "src", args, NULL, fg->graph);
754 #if FF_API_OLD_VSINK_API
755 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),
756 "out", NULL, pix_fmts, fg->graph);
758 buffersink_params->pixel_fmts = pix_fmts;
759 ret = avfilter_graph_create_filter(&fg->outputs[0]->filter, avfilter_get_by_name("buffersink"),
760 "out", NULL, buffersink_params, fg->graph);
762 av_freep(&buffersink_params);
766 last_filter = fg->inputs[0]->filter;
768 if (codec->width || codec->height) {
769 snprintf(args, 255, "%d:%d:flags=0x%X",
772 (unsigned)ost->sws_flags);
773 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
774 NULL, args, NULL, fg->graph)) < 0)
776 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
778 last_filter = filter;
781 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
782 fg->graph->scale_sws_opts = av_strdup(args);
785 AVFilterInOut *outputs = avfilter_inout_alloc();
786 AVFilterInOut *inputs = avfilter_inout_alloc();
788 outputs->name = av_strdup("in");
789 outputs->filter_ctx = last_filter;
790 outputs->pad_idx = 0;
791 outputs->next = NULL;
793 inputs->name = av_strdup("out");
794 inputs->filter_ctx = fg->outputs[0]->filter;
798 if ((ret = avfilter_graph_parse(fg->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
800 av_freep(&ost->avfilter);
802 if ((ret = avfilter_link(last_filter, 0, fg->outputs[0]->filter, 0)) < 0)
806 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
809 ost->filter = fg->outputs[0];
814 static FilterGraph *init_simple_filtergraph(InputStream *ist, OutputStream *ost)
816 FilterGraph *fg = av_mallocz(sizeof(*fg));
820 fg->index = nb_filtergraphs;
822 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs), &fg->nb_outputs,
824 if (!(fg->outputs[0] = av_mallocz(sizeof(*fg->outputs[0]))))
826 fg->outputs[0]->ost = ost;
827 fg->outputs[0]->graph = fg;
829 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs), &fg->nb_inputs,
831 if (!(fg->inputs[0] = av_mallocz(sizeof(*fg->inputs[0]))))
833 fg->inputs[0]->ist = ist;
834 fg->inputs[0]->graph = fg;
836 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
837 &ist->nb_filters, ist->nb_filters + 1);
838 ist->filters[ist->nb_filters - 1] = fg->inputs[0];
840 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
841 &nb_filtergraphs, nb_filtergraphs + 1);
842 filtergraphs[nb_filtergraphs - 1] = fg;
847 static void init_input_filter(FilterGraph *fg, AVFilterInOut *in)
850 enum AVMediaType type = in->filter_ctx->input_pads[in->pad_idx].type;
853 // TODO: support other filter types
854 if (type != AVMEDIA_TYPE_VIDEO) {
855 av_log(NULL, AV_LOG_FATAL, "Only video filters supported currently.\n");
863 int file_idx = strtol(in->name, &p, 0);
865 if (file_idx < 0 || file_idx > nb_input_files) {
866 av_log(NULL, AV_LOG_FATAL, "Invalid file index %d in filtegraph description %s.\n",
867 file_idx, fg->graph_desc);
870 s = input_files[file_idx]->ctx;
872 for (i = 0; i < s->nb_streams; i++) {
873 if (s->streams[i]->codec->codec_type != type)
875 if (check_stream_specifier(s, s->streams[i], *p == ':' ? p + 1 : p) == 1) {
881 av_log(NULL, AV_LOG_FATAL, "Stream specifier '%s' in filtergraph description %s "
882 "matches no streams.\n", p, fg->graph_desc);
885 ist = input_streams[input_files[file_idx]->ist_index + st->index];
887 /* find the first unused stream of corresponding type */
888 for (i = 0; i < nb_input_streams; i++) {
889 ist = input_streams[i];
890 if (ist->st->codec->codec_type == type && ist->discard)
893 if (i == nb_input_streams) {
894 av_log(NULL, AV_LOG_FATAL, "Cannot find a matching stream for "
895 "unlabeled input pad %d on filter %s", in->pad_idx,
896 in->filter_ctx->name);
901 ist->decoding_needed = 1;
902 ist->st->discard = AVDISCARD_NONE;
904 fg->inputs = grow_array(fg->inputs, sizeof(*fg->inputs),
905 &fg->nb_inputs, fg->nb_inputs + 1);
906 if (!(fg->inputs[fg->nb_inputs - 1] = av_mallocz(sizeof(*fg->inputs[0]))))
908 fg->inputs[fg->nb_inputs - 1]->ist = ist;
909 fg->inputs[fg->nb_inputs - 1]->graph = fg;
911 ist->filters = grow_array(ist->filters, sizeof(*ist->filters),
912 &ist->nb_filters, ist->nb_filters + 1);
913 ist->filters[ist->nb_filters - 1] = fg->inputs[fg->nb_inputs - 1];
916 static int configure_output_filter(FilterGraph *fg, OutputFilter *ofilter, AVFilterInOut *out)
918 AVCodecContext *codec = ofilter->ost->st->codec;
919 AVFilterContext *last_filter = out->filter_ctx;
920 int pad_idx = out->pad_idx;
922 enum PixelFormat *pix_fmts = choose_pixel_fmts(ofilter->ost);
923 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
925 #if FF_API_OLD_VSINK_API
926 ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),
927 "out", NULL, pix_fmts, fg->graph);
929 buffersink_params->pixel_fmts = pix_fmts;
930 ret = avfilter_graph_create_filter(&ofilter->filter, avfilter_get_by_name("buffersink"),
931 "out", NULL, buffersink_params, fg->graph);
933 av_freep(&buffersink_params);
938 if (codec->width || codec->height) {
940 snprintf(args, sizeof(args), "%d:%d:flags=0x%X",
943 (unsigned)ofilter->ost->sws_flags);
944 if ((ret = avfilter_graph_create_filter(&last_filter, avfilter_get_by_name("scale"),
945 NULL, args, NULL, fg->graph)) < 0)
947 if ((ret = avfilter_link(out->filter_ctx, out->pad_idx, last_filter, 0)) < 0)
952 if ((ret = avfilter_link(last_filter, pad_idx, ofilter->filter, 0)) < 0)
958 static int configure_complex_filter(FilterGraph *fg)
960 AVFilterInOut *inputs, *outputs, *cur;
961 int ret, i, init = !fg->graph;
963 avfilter_graph_free(&fg->graph);
964 if (!(fg->graph = avfilter_graph_alloc()))
965 return AVERROR(ENOMEM);
967 if ((ret = avfilter_graph_parse2(fg->graph, fg->graph_desc, &inputs, &outputs)) < 0)
970 for (cur = inputs; init && cur; cur = cur->next)
971 init_input_filter(fg, cur);
973 for (cur = inputs, i = 0; cur; cur = cur->next, i++) {
974 InputFilter *ifilter = fg->inputs[i];
975 InputStream *ist = ifilter->ist;
979 sar = ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
980 ist->st->codec->sample_aspect_ratio;
981 snprintf(args, sizeof(args), "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
982 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
985 if ((ret = avfilter_graph_create_filter(&ifilter->filter,
986 avfilter_get_by_name("buffer"), cur->name,
987 args, NULL, fg->graph)) < 0)
989 if ((ret = avfilter_link(ifilter->filter, 0,
990 cur->filter_ctx, cur->pad_idx)) < 0)
993 avfilter_inout_free(&inputs);
996 /* we already know the mappings between lavfi outputs and output streams,
997 * so we can finish the setup */
998 for (cur = outputs, i = 0; cur; cur = cur->next, i++)
999 configure_output_filter(fg, fg->outputs[i], cur);
1000 avfilter_inout_free(&outputs);
1002 if ((ret = avfilter_graph_config(fg->graph, NULL)) < 0)
1005 /* wait until output mappings are processed */
1006 for (cur = outputs; cur;) {
1007 fg->outputs = grow_array(fg->outputs, sizeof(*fg->outputs),
1008 &fg->nb_outputs, fg->nb_outputs + 1);
1009 if (!(fg->outputs[fg->nb_outputs - 1] = av_mallocz(sizeof(*fg->outputs[0]))))
1011 fg->outputs[fg->nb_outputs - 1]->graph = fg;
1012 fg->outputs[fg->nb_outputs - 1]->out_tmp = cur;
1014 fg->outputs[fg->nb_outputs - 1]->out_tmp->next = NULL;
1021 static int configure_complex_filters(void)
1025 for (i = 0; i < nb_filtergraphs; i++)
1026 if (!filtergraphs[i]->graph &&
1027 (ret = configure_complex_filter(filtergraphs[i])) < 0)
1032 static int configure_filtergraph(FilterGraph *fg)
1034 return fg->graph_desc ? configure_complex_filter(fg) : configure_video_filters(fg);
1037 static int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
1040 for (i = 0; i < fg->nb_inputs; i++)
1041 if (fg->inputs[i]->ist == ist)
1046 static void term_exit(void)
1048 av_log(NULL, AV_LOG_QUIET, "%s", "");
1051 tcsetattr (0, TCSANOW, &oldtty);
1055 static volatile int received_sigterm = 0;
1057 static void sigterm_handler(int sig)
1059 received_sigterm = sig;
1060 received_nb_signals++;
1062 if(received_nb_signals > 3)
1066 static void term_init(void)
1072 if (tcgetattr (0, &tty) == 0) {
1077 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
1078 |INLCR|IGNCR|ICRNL|IXON);
1079 tty.c_oflag |= OPOST;
1080 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
1081 tty.c_cflag &= ~(CSIZE|PARENB);
1084 tty.c_cc[VTIME] = 0;
1086 tcsetattr (0, TCSANOW, &tty);
1088 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
1091 avformat_network_deinit();
1093 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
1094 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
1096 signal(SIGXCPU, sigterm_handler);
1100 /* read a key without blocking */
1101 static int read_key(void)
1113 n = select(1, &rfds, NULL, NULL, &tv);
1115 n = read(0, &ch, 1);
1122 # if HAVE_PEEKNAMEDPIPE
1124 static HANDLE input_handle;
1127 input_handle = GetStdHandle(STD_INPUT_HANDLE);
1128 is_pipe = !GetConsoleMode(input_handle, &dw);
1131 if (stdin->_cnt > 0) {
1136 /* When running under a GUI, you will end here. */
1137 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
1154 static int decode_interrupt_cb(void *ctx)
1156 return received_nb_signals > 1;
1159 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
1161 void av_noreturn exit_program(int ret)
1165 for (i = 0; i < nb_filtergraphs; i++) {
1166 avfilter_graph_free(&filtergraphs[i]->graph);
1167 for (j = 0; j < filtergraphs[i]->nb_inputs; j++)
1168 av_freep(&filtergraphs[i]->inputs[j]);
1169 av_freep(&filtergraphs[i]->inputs);
1170 for (j = 0; j < filtergraphs[i]->nb_outputs; j++)
1171 av_freep(&filtergraphs[i]->outputs[j]);
1172 av_freep(&filtergraphs[i]->outputs);
1173 av_freep(&filtergraphs[i]);
1175 av_freep(&filtergraphs);
1178 for (i = 0; i < nb_output_files; i++) {
1179 AVFormatContext *s = output_files[i]->ctx;
1180 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
1182 avformat_free_context(s);
1183 av_dict_free(&output_files[i]->opts);
1184 av_freep(&output_files[i]);
1186 for (i = 0; i < nb_output_streams; i++) {
1187 AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
1189 AVBitStreamFilterContext *next = bsfc->next;
1190 av_bitstream_filter_close(bsfc);
1193 output_streams[i]->bitstream_filters = NULL;
1195 if (output_streams[i]->output_frame) {
1196 AVFrame *frame = output_streams[i]->output_frame;
1197 if (frame->extended_data != frame->data)
1198 av_freep(&frame->extended_data);
1201 av_freep(&output_streams[i]->filtered_frame);
1202 av_freep(&output_streams[i]);
1204 for (i = 0; i < nb_input_files; i++) {
1205 avformat_close_input(&input_files[i]->ctx);
1206 av_freep(&input_files[i]);
1208 for (i = 0; i < nb_input_streams; i++) {
1209 av_freep(&input_streams[i]->decoded_frame);
1210 av_dict_free(&input_streams[i]->opts);
1211 free_buffer_pool(input_streams[i]);
1212 av_freep(&input_streams[i]->filters);
1213 av_freep(&input_streams[i]);
1217 fclose(vstats_file);
1218 av_free(vstats_filename);
1220 av_freep(&input_streams);
1221 av_freep(&input_files);
1222 av_freep(&output_streams);
1223 av_freep(&output_files);
1226 av_freep(&audio_buf);
1227 allocated_audio_buf_size = 0;
1228 av_freep(&async_buf);
1229 allocated_async_buf_size = 0;
1232 avformat_network_deinit();
1234 if (received_sigterm) {
1235 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
1236 (int) received_sigterm);
1240 exit(ret); /* not all OS-es handle main() return value */
1243 static void assert_avoptions(AVDictionary *m)
1245 AVDictionaryEntry *t;
1246 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
1247 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
1252 static void assert_codec_experimental(AVCodecContext *c, int encoder)
1254 const char *codec_string = encoder ? "encoder" : "decoder";
1256 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
1257 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1258 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
1259 "results.\nAdd '-strict experimental' if you want to use it.\n",
1260 codec_string, c->codec->name);
1261 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
1262 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
1263 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
1264 codec_string, codec->name);
1269 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
1271 if (codec && codec->sample_fmts) {
1272 const enum AVSampleFormat *p = codec->sample_fmts;
1273 for (; *p != -1; p++) {
1274 if (*p == st->codec->sample_fmt)
1278 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
1279 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
1280 if(av_get_sample_fmt_name(st->codec->sample_fmt))
1281 av_log(NULL, AV_LOG_WARNING,
1282 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
1283 av_get_sample_fmt_name(st->codec->sample_fmt),
1285 av_get_sample_fmt_name(codec->sample_fmts[0]));
1286 st->codec->sample_fmt = codec->sample_fmts[0];
1291 static void choose_sample_rate(AVStream *st, AVCodec *codec)
1293 if (codec && codec->supported_samplerates) {
1294 const int *p = codec->supported_samplerates;
1296 int best_dist = INT_MAX;
1298 int dist = abs(st->codec->sample_rate - *p);
1299 if (dist < best_dist) {
1306 const int *sample_rates = codec->supported_samplerates;
1307 av_log(st->codec, AV_LOG_WARNING,
1308 "Requested sampling rate (%dHz) unsupported, using %dHz instead\n"
1309 "Available sampling rates for %s:",
1310 st->codec->sample_rate, best, codec->name);
1311 for (i = 0; sample_rates[i]; i++) {
1312 if (!sample_rates[i + 1]) av_log(st->codec, AV_LOG_WARNING, " and");
1313 else if (i) av_log(st->codec, AV_LOG_WARNING, ",");
1314 av_log(st->codec, AV_LOG_WARNING, " %d", sample_rates[i]);
1316 av_log(st->codec, AV_LOG_WARNING, ".\n");
1318 st->codec->sample_rate = best;
1323 get_sync_ipts(const OutputStream *ost, int64_t pts)
1325 OutputFile *of = output_files[ost->file_index];
1326 return (double)(pts - of->start_time) / AV_TIME_BASE;
1329 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1331 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1332 AVCodecContext *avctx = ost->st->codec;
1335 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1336 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1337 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1340 * Audio encoders may split the packets -- #frames in != #packets out.
1341 * But there is no reordering, so we can limit the number of output packets
1342 * by simply dropping them here.
1343 * Counting encoded video frames needs to be done separately because of
1344 * reordering, see do_video_out()
1346 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1347 if (ost->frame_number >= ost->max_frames) {
1348 av_free_packet(pkt);
1351 ost->frame_number++;
1355 AVPacket new_pkt = *pkt;
1356 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1357 &new_pkt.data, &new_pkt.size,
1358 pkt->data, pkt->size,
1359 pkt->flags & AV_PKT_FLAG_KEY);
1361 av_free_packet(pkt);
1362 new_pkt.destruct = av_destruct_packet;
1364 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1365 bsfc->filter->name, pkt->stream_index,
1366 avctx->codec ? avctx->codec->name : "copy");
1376 pkt->stream_index = ost->index;
1377 ret = av_interleaved_write_frame(s, pkt);
1379 print_error("av_interleaved_write_frame()", ret);
1384 static void get_default_channel_layouts(OutputStream *ost, InputStream *ist)
1386 char layout_name[256];
1387 AVCodecContext *enc = ost->st->codec;
1388 AVCodecContext *dec = ist->st->codec;
1390 if (dec->channel_layout &&
1391 av_get_channel_layout_nb_channels(dec->channel_layout) != dec->channels) {
1392 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1393 dec->channels, dec->channel_layout);
1394 av_log(NULL, AV_LOG_ERROR, "New channel layout (%s) is invalid\n",
1396 dec->channel_layout = 0;
1398 if (!dec->channel_layout) {
1399 if (enc->channel_layout && dec->channels == enc->channels) {
1400 dec->channel_layout = enc->channel_layout;
1402 dec->channel_layout = av_get_default_channel_layout(dec->channels);
1404 if (!dec->channel_layout) {
1405 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1406 "layout for Input Stream #%d.%d\n", ist->file_index,
1411 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1412 dec->channels, dec->channel_layout);
1413 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
1414 "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1416 if (!enc->channel_layout) {
1417 if (dec->channels == enc->channels) {
1418 enc->channel_layout = dec->channel_layout;
1421 enc->channel_layout = av_get_default_channel_layout(enc->channels);
1423 if (!enc->channel_layout) {
1424 av_log(NULL, AV_LOG_FATAL, "Unable to find default channel layout "
1425 "for Output Stream #%d.%d\n", ost->file_index,
1429 av_get_channel_layout_string(layout_name, sizeof(layout_name),
1430 enc->channels, enc->channel_layout);
1431 av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Output Stream "
1432 "#%d.%d : %s\n", ost->file_index, ost->st->index, layout_name);
1436 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1438 int fill_char = 0x00;
1439 if (sample_fmt == AV_SAMPLE_FMT_U8)
1441 memset(buf, fill_char, size);
1444 static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,
1445 const uint8_t *buf, int buf_size)
1447 AVCodecContext *enc = ost->st->codec;
1448 AVFrame *frame = NULL;
1450 int ret, got_packet;
1452 av_init_packet(&pkt);
1456 if (buf && buf_size) {
1457 if (!ost->output_frame) {
1458 ost->output_frame = avcodec_alloc_frame();
1459 if (!ost->output_frame) {
1460 av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");
1464 frame = ost->output_frame;
1465 if (frame->extended_data != frame->data)
1466 av_freep(&frame->extended_data);
1467 avcodec_get_frame_defaults(frame);
1469 frame->nb_samples = buf_size /
1470 (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
1471 if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,
1472 buf, buf_size, 1)) < 0) {
1473 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_fill_audio_frame)\n");
1477 frame->pts = ost->sync_opts;
1478 ost->sync_opts += frame->nb_samples;
1482 update_benchmark(NULL);
1483 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1484 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1487 update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
1492 if (pkt.pts != AV_NOPTS_VALUE)
1493 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1494 if (pkt.dts != AV_NOPTS_VALUE) {
1495 int64_t max = ost->st->cur_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
1496 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1497 if (ost->st->cur_dts && ost->st->cur_dts != AV_NOPTS_VALUE && max > pkt.dts) {
1498 av_log(s, max - pkt.dts > 2 ? AV_LOG_WARNING : AV_LOG_DEBUG, "Audio timestamp %"PRId64" < %"PRId64" invalid, cliping\n", pkt.dts, max);
1499 pkt.pts = pkt.dts = max;
1502 if (pkt.duration > 0)
1503 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1505 write_frame(s, &pkt, ost);
1507 audio_size += pkt.size;
1509 av_free_packet(&pkt);
1513 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1514 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1515 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1516 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1522 static int alloc_audio_output_buf(AVCodecContext *dec, AVCodecContext *enc,
1525 int64_t audio_buf_samples;
1528 /* calculate required number of samples to allocate */
1529 audio_buf_samples = ((int64_t)nb_samples * enc->sample_rate + dec->sample_rate) /
1531 audio_buf_samples = 4 * audio_buf_samples + 10000; // safety factors for resampling
1532 audio_buf_samples = FFMAX(audio_buf_samples, enc->frame_size);
1533 if (audio_buf_samples > INT_MAX)
1534 return AVERROR(EINVAL);
1536 audio_buf_size = av_samples_get_buffer_size(NULL, enc->channels,
1538 enc->sample_fmt, 0);
1539 if (audio_buf_size < 0)
1540 return audio_buf_size;
1542 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
1544 return AVERROR(ENOMEM);
1549 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1550 InputStream *ist, AVFrame *decoded_frame)
1555 int frame_bytes, resample_changed;
1556 AVCodecContext *enc = ost->st->codec;
1557 AVCodecContext *dec = ist->st->codec;
1558 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1559 int isize = av_get_bytes_per_sample(dec->sample_fmt);
1560 uint8_t *buf[AV_NUM_DATA_POINTERS];
1561 int size = decoded_frame->nb_samples * dec->channels * isize;
1562 int planes = av_sample_fmt_is_planar(dec->sample_fmt) ? dec->channels : 1;
1565 av_assert0(planes <= AV_NUM_DATA_POINTERS);
1567 for(i=0; i<planes; i++)
1568 buf[i]= decoded_frame->data[i];
1570 get_default_channel_layouts(ost, ist);
1572 if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples) < 0) {
1573 av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1577 if (enc->channels != dec->channels
1578 || enc->sample_fmt != dec->sample_fmt
1579 || enc->sample_rate!= dec->sample_rate
1581 ost->audio_resample = 1;
1583 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1584 ost->resample_channels != dec->channels ||
1585 ost->resample_sample_rate != dec->sample_rate;
1587 if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
1588 if (resample_changed) {
1589 av_log(NULL, AV_LOG_INFO, "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d to rate:%d fmt:%s ch:%d\n",
1590 ist->file_index, ist->st->index,
1591 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
1592 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
1593 ost->resample_sample_fmt = dec->sample_fmt;
1594 ost->resample_channels = dec->channels;
1595 ost->resample_sample_rate = dec->sample_rate;
1596 swr_free(&ost->swr);
1598 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1599 if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
1600 ost->resample_sample_fmt == enc->sample_fmt &&
1601 ost->resample_channels == enc->channels &&
1602 ost->resample_sample_rate == enc->sample_rate) {
1604 ost->audio_resample = 0;
1606 ost->swr = swr_alloc_set_opts(ost->swr,
1607 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
1608 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
1610 av_opt_set_int(ost->swr, "dither_method", ost->swr_dither_method,0);
1611 av_opt_set_int(ost->swr, "dither_scale", ost->swr_dither_scale,0);
1612 if (ost->audio_channels_mapped)
1613 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
1614 av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
1615 if (ost->audio_channels_mapped) {
1616 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
1617 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
1619 if (av_opt_set_int(ost->swr, "ich", dec->channels, 0) < 0) {
1620 av_log(NULL, AV_LOG_FATAL, "Unsupported number of input channels\n");
1623 if (av_opt_set_int(ost->swr, "och", enc->channels, 0) < 0) {
1624 av_log(NULL, AV_LOG_FATAL, "Unsupported number of output channels\n");
1627 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
1628 if(ost->swr && swr_init(ost->swr) < 0){
1629 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
1630 swr_free(&ost->swr);
1634 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1635 dec->channels, dec->sample_rate,
1636 enc->channels, enc->sample_rate);
1642 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1644 if (audio_sync_method > 0) {
1645 double delta = get_sync_ipts(ost, ist->pts) * enc->sample_rate - ost->sync_opts -
1646 av_fifo_size(ost->fifo) / (enc->channels * osize);
1647 int idelta = delta * dec->sample_rate / enc->sample_rate;
1648 int byte_delta = idelta * isize * dec->channels;
1650 // FIXME resample delay
1651 if (fabs(delta) > 50) {
1652 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1653 if (byte_delta < 0) {
1654 byte_delta = FFMAX(byte_delta, -size);
1656 for (i=0; i<planes; i++)
1657 buf[i] -= byte_delta/planes;
1658 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1659 -byte_delta / (isize * dec->channels));
1664 av_fast_malloc(&async_buf, &allocated_async_buf_size,
1667 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1671 if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples + idelta) < 0) {
1672 av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1677 for (i=0; i<planes; i++) {
1678 uint8_t *t = async_buf + i*((byte_delta + size)/planes);
1679 generate_silence(t, dec->sample_fmt, byte_delta/planes);
1680 memcpy(t + byte_delta/planes, buf[i], size/planes);
1684 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1686 } else if (audio_sync_method > 1) {
1687 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1688 av_assert0(ost->audio_resample);
1689 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1690 delta, comp, enc->sample_rate);
1691 // 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));
1692 swr_set_compensation(ost->swr, comp, enc->sample_rate);
1695 } else if (audio_sync_method == 0)
1696 ost->sync_opts = lrintf(get_sync_ipts(ost, ist->pts) * enc->sample_rate) -
1697 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1699 if (ost->audio_resample || ost->audio_channels_mapped) {
1701 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, allocated_audio_buf_size / (enc->channels * osize),
1702 buf, size / (dec->channels * isize));
1704 av_log(NULL, AV_LOG_FATAL, "swr_convert failed\n");
1707 size_out = size_out * enc->channels * osize;
1713 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1715 /* now encode as many frames as possible */
1716 if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1717 /* output resampled raw samples */
1718 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1719 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1722 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1724 frame_bytes = enc->frame_size * osize * enc->channels;
1726 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1727 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1728 encode_audio_frame(s, ost, audio_buf, frame_bytes);
1731 encode_audio_frame(s, ost, buftmp, size_out);
1735 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1737 AVCodecContext *dec;
1738 AVPicture *picture2;
1739 AVPicture picture_tmp;
1742 dec = ist->st->codec;
1744 /* deinterlace : must be done before any resize */
1745 if (do_deinterlace) {
1748 /* create temporary picture */
1749 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1750 buf = av_malloc(size);
1754 picture2 = &picture_tmp;
1755 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1757 if (avpicture_deinterlace(picture2, picture,
1758 dec->pix_fmt, dec->width, dec->height) < 0) {
1759 /* if error, do not deinterlace */
1760 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1769 if (picture != picture2)
1770 *picture = *picture2;
1774 static void do_subtitle_out(AVFormatContext *s,
1780 static uint8_t *subtitle_out = NULL;
1781 int subtitle_out_max_size = 1024 * 1024;
1782 int subtitle_out_size, nb, i;
1783 AVCodecContext *enc;
1786 if (pts == AV_NOPTS_VALUE) {
1787 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1793 enc = ost->st->codec;
1795 if (!subtitle_out) {
1796 subtitle_out = av_malloc(subtitle_out_max_size);
1799 /* Note: DVB subtitle need one packet to draw them and one other
1800 packet to clear them */
1801 /* XXX: signal it in the codec context ? */
1802 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1807 for (i = 0; i < nb; i++) {
1808 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1810 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1811 // start_display_time is required to be 0
1812 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1813 sub->end_display_time -= sub->start_display_time;
1814 sub->start_display_time = 0;
1815 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1816 subtitle_out_max_size, sub);
1817 if (subtitle_out_size < 0) {
1818 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1822 av_init_packet(&pkt);
1823 pkt.data = subtitle_out;
1824 pkt.size = subtitle_out_size;
1825 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1826 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1827 /* XXX: the pts correction is handled here. Maybe handling
1828 it in the codec would be better */
1830 pkt.pts += 90 * sub->start_display_time;
1832 pkt.pts += 90 * sub->end_display_time;
1834 write_frame(s, &pkt, ost);
1838 static double psnr(double d)
1840 return -10.0 * log(d) / log(10.0);
1843 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1846 AVCodecContext *enc;
1848 double ti1, bitrate, avg_bitrate;
1850 /* this is executed just the first time do_video_stats is called */
1852 vstats_file = fopen(vstats_filename, "w");
1859 enc = ost->st->codec;
1860 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1861 frame_number = ost->frame_number;
1862 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1863 if (enc->flags&CODEC_FLAG_PSNR)
1864 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1866 fprintf(vstats_file,"f_size= %6d ", frame_size);
1867 /* compute pts value */
1868 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1872 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1873 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1874 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1875 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1876 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1881 static void do_video_out(AVFormatContext *s, OutputStream *ost,
1882 AVFrame *in_picture, float quality)
1884 int nb_frames, i, ret, format_video_sync;
1885 AVCodecContext *enc;
1886 double sync_ipts, delta;
1887 double duration = 0;
1889 InputStream *ist = NULL;
1891 if (ost->source_index >= 0)
1892 ist = input_streams[ost->source_index];
1894 enc = ost->st->codec;
1896 if (ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1897 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1898 if(ist->st->r_frame_rate.num)
1899 duration= FFMAX(duration, 1/av_q2d(ist->st->r_frame_rate));
1900 if(ist->st->avg_frame_rate.num && 0)
1901 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1903 duration /= av_q2d(enc->time_base);
1906 sync_ipts = get_sync_ipts(ost, in_picture->pts) / av_q2d(enc->time_base);
1907 delta = sync_ipts - ost->sync_opts + duration;
1909 /* by default, we output a single frame */
1912 format_video_sync = video_sync_method;
1913 if (format_video_sync == VSYNC_AUTO)
1914 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1916 switch (format_video_sync) {
1918 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1921 else if (delta > 1.1)
1922 nb_frames = lrintf(delta);
1927 else if (delta > 0.6)
1928 ost->sync_opts = lrintf(sync_ipts);
1931 case VSYNC_PASSTHROUGH:
1932 ost->sync_opts = lrintf(sync_ipts);
1938 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1939 if (nb_frames == 0) {
1941 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1943 } else if (nb_frames > 1) {
1944 nb_frames_dup += nb_frames - 1;
1945 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1948 /* duplicates frame if needed */
1949 for (i = 0; i < nb_frames; i++) {
1951 av_init_packet(&pkt);
1955 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1956 enc->codec->id == CODEC_ID_RAWVIDEO) {
1957 /* raw pictures are written as AVPicture structure to
1958 avoid any copies. We support temporarily the older
1960 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1961 enc->coded_frame->top_field_first = in_picture->top_field_first;
1962 pkt.data = (uint8_t *)in_picture;
1963 pkt.size = sizeof(AVPicture);
1964 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1965 pkt.flags |= AV_PKT_FLAG_KEY;
1967 write_frame(s, &pkt, ost);
1970 AVFrame big_picture;
1972 big_picture = *in_picture;
1973 /* better than nothing: use input picture interlaced
1975 big_picture.interlaced_frame = in_picture->interlaced_frame;
1976 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1977 if (ost->top_field_first == -1)
1978 big_picture.top_field_first = in_picture->top_field_first;
1980 big_picture.top_field_first = !!ost->top_field_first;
1983 /* handles same_quant here. This is not correct because it may
1984 not be a global option */
1985 big_picture.quality = quality;
1986 if (!enc->me_threshold)
1987 big_picture.pict_type = 0;
1988 big_picture.pts = ost->sync_opts;
1989 if (ost->forced_kf_index < ost->forced_kf_count &&
1990 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1991 big_picture.pict_type = AV_PICTURE_TYPE_I;
1992 ost->forced_kf_index++;
1994 update_benchmark(NULL);
1995 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
1996 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1998 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
2003 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
2004 pkt.pts = ost->sync_opts;
2006 if (pkt.pts != AV_NOPTS_VALUE)
2007 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2008 if (pkt.dts != AV_NOPTS_VALUE)
2009 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2012 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
2013 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
2014 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
2015 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
2018 write_frame(s, &pkt, ost);
2019 frame_size = pkt.size;
2020 video_size += pkt.size;
2021 av_free_packet(&pkt);
2023 /* if two pass, output log */
2024 if (ost->logfile && enc->stats_out) {
2025 fprintf(ost->logfile, "%s", enc->stats_out);
2031 * For video, number of frames in == number of packets out.
2032 * But there may be reordering, so we can't throw away frames on encoder
2033 * flush, we need to limit them here, before they go into encoder.
2035 ost->frame_number++;
2037 if (vstats_filename && frame_size)
2038 do_video_stats(output_files[ost->file_index]->ctx, ost, frame_size);
2041 /* check for new output on any of the filtergraphs */
2042 static int poll_filters(void)
2044 AVFilterBufferRef *picref;
2045 AVFrame *filtered_frame = NULL;
2048 for (i = 0; i < nb_output_streams; i++) {
2049 OutputStream *ost = output_streams[i];
2050 OutputFile *of = output_files[ost->file_index];
2052 if (!ost->filter || ost->is_past_recording_time)
2055 if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
2056 return AVERROR(ENOMEM);
2058 avcodec_get_frame_defaults(ost->filtered_frame);
2059 filtered_frame = ost->filtered_frame;
2061 while (avfilter_poll_frame(ost->filter->filter->inputs[0])) {
2062 AVRational ist_pts_tb = ost->filter->filter->inputs[0]->time_base;
2063 if ((ret = av_buffersink_get_buffer_ref(ost->filter->filter,
2066 av_log(NULL, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");
2069 filtered_frame->pts = av_rescale_q(picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2070 // if (ost->source_index >= 0)
2071 // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
2073 if (of->start_time && filtered_frame->pts < of->start_time)
2076 switch (ost->filter->filter->inputs[0]->type) {
2077 case AVMEDIA_TYPE_VIDEO:
2078 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, picref);
2079 if (!ost->frame_aspect_ratio)
2080 ost->st->codec->sample_aspect_ratio = picref->video->sample_aspect_ratio;
2082 do_video_out(of->ctx, ost, filtered_frame,
2083 same_quant ? ost->last_quality :
2084 ost->st->codec->global_quality);
2087 // TODO support audio/subtitle filters
2091 avfilter_unref_buffer(picref);
2097 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
2101 AVFormatContext *oc;
2103 AVCodecContext *enc;
2104 int frame_number, vid, i;
2106 int64_t pts = INT64_MAX;
2107 static int64_t last_time = -1;
2108 static int qp_histogram[52];
2109 int hours, mins, secs, us;
2111 if (!print_stats && !is_last_report)
2114 if (!is_last_report) {
2115 if (last_time == -1) {
2116 last_time = cur_time;
2119 if ((cur_time - last_time) < 500000)
2121 last_time = cur_time;
2125 oc = output_files[0]->ctx;
2127 total_size = avio_size(oc->pb);
2128 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
2129 total_size = avio_tell(oc->pb);
2136 for (i = 0; i < nb_output_streams; i++) {
2138 ost = output_streams[i];
2139 enc = ost->st->codec;
2140 if (!ost->stream_copy && enc->coded_frame)
2141 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
2142 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2143 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
2145 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
2146 float fps, t = (cur_time-timer_start) / 1000000.0;
2148 frame_number = ost->frame_number;
2149 fps = t > 1 ? frame_number / t : 0;
2150 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
2151 frame_number, fps < 9.95, fps, q);
2153 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
2157 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
2159 for (j = 0; j < 32; j++)
2160 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
2162 if (enc->flags&CODEC_FLAG_PSNR) {
2164 double error, error_sum = 0;
2165 double scale, scale_sum = 0;
2166 char type[3] = { 'Y','U','V' };
2167 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
2168 for (j = 0; j < 3; j++) {
2169 if (is_last_report) {
2170 error = enc->error[j];
2171 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
2173 error = enc->coded_frame->error[j];
2174 scale = enc->width * enc->height * 255.0 * 255.0;
2180 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
2182 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
2186 /* compute min output value */
2187 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
2188 ost->st->time_base, AV_TIME_BASE_Q));
2191 secs = pts / AV_TIME_BASE;
2192 us = pts % AV_TIME_BASE;
2198 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
2200 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2201 "size=%8.0fkB time=", total_size / 1024.0);
2202 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2203 "%02d:%02d:%02d.%02d ", hours, mins, secs,
2204 (100 * us) / AV_TIME_BASE);
2205 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
2206 "bitrate=%6.1fkbits/s", bitrate);
2208 if (nb_frames_dup || nb_frames_drop)
2209 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
2210 nb_frames_dup, nb_frames_drop);
2212 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
2216 if (is_last_report) {
2217 int64_t raw= audio_size + video_size + extra_size;
2218 av_log(NULL, AV_LOG_INFO, "\n");
2219 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
2220 video_size / 1024.0,
2221 audio_size / 1024.0,
2222 extra_size / 1024.0,
2223 100.0 * (total_size - raw) / raw
2225 if(video_size + audio_size + extra_size == 0){
2226 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
2231 static void flush_encoders(void)
2235 for (i = 0; i < nb_output_streams; i++) {
2236 OutputStream *ost = output_streams[i];
2237 AVCodecContext *enc = ost->st->codec;
2238 AVFormatContext *os = output_files[ost->file_index]->ctx;
2239 int stop_encoding = 0;
2241 if (!ost->encoding_needed)
2244 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
2246 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
2251 int fifo_bytes, got_packet;
2252 av_init_packet(&pkt);
2256 switch (ost->st->codec->codec_type) {
2257 case AVMEDIA_TYPE_AUDIO:
2258 fifo_bytes = av_fifo_size(ost->fifo);
2259 if (fifo_bytes > 0) {
2260 /* encode any samples remaining in fifo */
2261 int frame_bytes = fifo_bytes;
2263 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
2265 /* pad last frame with silence if needed */
2266 if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
2267 frame_bytes = enc->frame_size * enc->channels *
2268 av_get_bytes_per_sample(enc->sample_fmt);
2269 if (allocated_audio_buf_size < frame_bytes)
2271 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
2273 encode_audio_frame(os, ost, audio_buf, frame_bytes);
2275 /* flush encoder with NULL frames until it is done
2276 returning packets */
2277 if (encode_audio_frame(os, ost, NULL, 0) == 0) {
2283 case AVMEDIA_TYPE_VIDEO:
2284 update_benchmark(NULL);
2285 ret = avcodec_encode_video2(enc, &pkt, NULL, &got_packet);
2286 update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
2288 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
2291 video_size += pkt.size;
2292 if (ost->logfile && enc->stats_out) {
2293 fprintf(ost->logfile, "%s", enc->stats_out);
2299 if (pkt.pts != AV_NOPTS_VALUE)
2300 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
2301 if (pkt.dts != AV_NOPTS_VALUE)
2302 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
2303 write_frame(os, &pkt, ost);
2315 * Check whether a packet from ist should be written into ost at this time
2317 static int check_output_constraints(InputStream *ist, OutputStream *ost)
2319 OutputFile *of = output_files[ost->file_index];
2320 int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
2322 if (ost->source_index != ist_index)
2325 if (of->start_time && ist->pts < of->start_time)
2328 if (of->recording_time != INT64_MAX &&
2329 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
2330 (AVRational){ 1, 1000000 }) >= 0) {
2331 ost->is_past_recording_time = 1;
2338 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
2340 OutputFile *of = output_files[ost->file_index];
2341 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
2345 av_init_packet(&opkt);
2347 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2348 !ost->copy_initial_nonkeyframes)
2351 /* force the input stream PTS */
2352 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
2353 audio_size += pkt->size;
2354 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2355 video_size += pkt->size;
2359 if (pkt->pts != AV_NOPTS_VALUE)
2360 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
2362 opkt.pts = AV_NOPTS_VALUE;
2364 if (pkt->dts == AV_NOPTS_VALUE)
2365 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
2367 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
2368 opkt.dts -= ost_tb_start_time;
2370 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
2371 opkt.flags = pkt->flags;
2373 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
2374 if ( ost->st->codec->codec_id != CODEC_ID_H264
2375 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
2376 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
2377 && ost->st->codec->codec_id != CODEC_ID_VC1
2379 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
2380 opkt.destruct = av_destruct_packet;
2382 opkt.data = pkt->data;
2383 opkt.size = pkt->size;
2385 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2386 /* store AVPicture in AVPacket, as expected by the output format */
2387 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2388 opkt.data = (uint8_t *)&pict;
2389 opkt.size = sizeof(AVPicture);
2390 opkt.flags |= AV_PKT_FLAG_KEY;
2393 write_frame(of->ctx, &opkt, ost);
2394 ost->st->codec->frame_number++;
2395 av_free_packet(&opkt);
2398 static void rate_emu_sleep(InputStream *ist)
2400 if (input_files[ist->file_index]->rate_emu) {
2401 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2402 int64_t now = av_gettime() - ist->start;
2408 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2410 AVFrame *decoded_frame;
2411 AVCodecContext *avctx = ist->st->codec;
2412 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
2415 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2416 return AVERROR(ENOMEM);
2418 avcodec_get_frame_defaults(ist->decoded_frame);
2419 decoded_frame = ist->decoded_frame;
2421 update_benchmark(NULL);
2422 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2423 update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2427 if (avctx->sample_rate <= 0) {
2428 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2429 return AVERROR_INVALIDDATA;
2433 /* no audio frame */
2437 /* if the decoder provides a pts, use it instead of the last packet pts.
2438 the decoder could be delaying output by a packet or more. */
2439 if (decoded_frame->pts != AV_NOPTS_VALUE)
2440 ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2442 /* increment next_dts to use for the case where the input stream does not
2443 have timestamps or there are multiple frames in the packet */
2444 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2446 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2450 // preprocess audio (volume)
2451 if (audio_volume != 256) {
2452 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
2453 void *samples = decoded_frame->data[0];
2454 switch (avctx->sample_fmt) {
2455 case AV_SAMPLE_FMT_U8:
2457 uint8_t *volp = samples;
2458 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2459 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
2460 *volp++ = av_clip_uint8(v);
2464 case AV_SAMPLE_FMT_S16:
2466 int16_t *volp = samples;
2467 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2468 int v = ((*volp) * audio_volume + 128) >> 8;
2469 *volp++ = av_clip_int16(v);
2473 case AV_SAMPLE_FMT_S32:
2475 int32_t *volp = samples;
2476 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2477 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
2478 *volp++ = av_clipl_int32(v);
2482 case AV_SAMPLE_FMT_FLT:
2484 float *volp = samples;
2485 float scale = audio_volume / 256.f;
2486 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2491 case AV_SAMPLE_FMT_DBL:
2493 double *volp = samples;
2494 double scale = audio_volume / 256.;
2495 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2501 av_log(NULL, AV_LOG_FATAL,
2502 "Audio volume adjustment on sample format %s is not supported.\n",
2503 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
2508 rate_emu_sleep(ist);
2510 for (i = 0; i < nb_output_streams; i++) {
2511 OutputStream *ost = output_streams[i];
2513 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2515 do_audio_out(output_files[ost->file_index]->ctx, ost, ist, decoded_frame);
2521 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
2523 AVFrame *decoded_frame;
2524 void *buffer_to_free = NULL;
2525 int i, ret = 0, resample_changed;
2526 int64_t *best_effort_timestamp;
2527 AVRational *frame_sample_aspect;
2530 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2531 return AVERROR(ENOMEM);
2533 avcodec_get_frame_defaults(ist->decoded_frame);
2534 decoded_frame = ist->decoded_frame;
2535 pkt->pts = *pkt_pts;
2536 pkt->dts = ist->dts;
2537 *pkt_pts = AV_NOPTS_VALUE;
2539 update_benchmark(NULL);
2540 ret = avcodec_decode_video2(ist->st->codec,
2541 decoded_frame, got_output, pkt);
2542 update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2546 quality = same_quant ? decoded_frame->quality : 0;
2548 /* no picture yet */
2550 for (i = 0; i < ist->nb_filters; i++)
2551 av_buffersrc_buffer(ist->filters[i]->filter, NULL);
2555 best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
2556 if(*best_effort_timestamp != AV_NOPTS_VALUE)
2557 ist->next_pts = ist->pts = decoded_frame->pts = *best_effort_timestamp;
2561 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2563 rate_emu_sleep(ist);
2565 if (ist->st->sample_aspect_ratio.num)
2566 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2568 resample_changed = ist->resample_width != decoded_frame->width ||
2569 ist->resample_height != decoded_frame->height ||
2570 ist->resample_pix_fmt != decoded_frame->format;
2571 if (resample_changed) {
2572 av_log(NULL, AV_LOG_INFO,
2573 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2574 ist->file_index, ist->st->index,
2575 ist->resample_width, ist->resample_height, av_get_pix_fmt_name(ist->resample_pix_fmt),
2576 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2578 ist->resample_width = decoded_frame->width;
2579 ist->resample_height = decoded_frame->height;
2580 ist->resample_pix_fmt = decoded_frame->format;
2582 for (i = 0; i < nb_filtergraphs; i++)
2583 if (ist_in_filtergraph(filtergraphs[i], ist) &&
2584 configure_filtergraph(filtergraphs[i]) < 0) {
2585 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2590 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2591 for (i = 0; i < ist->nb_filters; i++) {
2592 int changed = ist->st->codec->width != ist->filters[i]->filter->outputs[0]->w
2593 || ist->st->codec->height != ist->filters[i]->filter->outputs[0]->h
2594 || ist->st->codec->pix_fmt != ist->filters[i]->filter->outputs[0]->format;
2595 // XXX what an ugly hack
2596 if (ist->filters[i]->graph->nb_outputs == 1)
2597 ist->filters[i]->graph->outputs[0]->ost->last_quality = quality;
2599 if (!frame_sample_aspect->num)
2600 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2601 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2602 FrameBuffer *buf = decoded_frame->opaque;
2603 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2604 decoded_frame->data, decoded_frame->linesize,
2605 AV_PERM_READ | AV_PERM_PRESERVE,
2606 ist->st->codec->width, ist->st->codec->height,
2607 ist->st->codec->pix_fmt);
2609 avfilter_copy_frame_props(fb, decoded_frame);
2610 fb->buf->priv = buf;
2611 fb->buf->free = filter_release_buffer;
2614 av_buffersrc_buffer(ist->filters[i]->filter, fb);
2616 if(av_vsrc_buffer_add_frame(ist->filters[i]->filter, decoded_frame,AV_VSRC_BUF_FLAG_OVERWRITE)<0) {
2617 av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2623 av_free(buffer_to_free);
2627 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2629 AVSubtitle subtitle;
2630 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2631 &subtitle, got_output, pkt);
2637 rate_emu_sleep(ist);
2639 for (i = 0; i < nb_output_streams; i++) {
2640 OutputStream *ost = output_streams[i];
2642 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2645 do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
2648 avsubtitle_free(&subtitle);
2652 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2653 static int output_packet(InputStream *ist, const AVPacket *pkt)
2657 int64_t pkt_pts = AV_NOPTS_VALUE;
2661 if (ist->next_dts == AV_NOPTS_VALUE)
2662 ist->next_dts = ist->dts;
2663 if (ist->next_pts == AV_NOPTS_VALUE)
2664 ist->next_pts = ist->pts;
2668 av_init_packet(&avpkt);
2676 if (pkt->dts != AV_NOPTS_VALUE) {
2677 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2678 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2679 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2681 if(pkt->pts != AV_NOPTS_VALUE)
2682 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2684 // while we have more to decode or while the decoder did output something on EOF
2685 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2689 ist->pts = ist->next_pts;
2690 ist->dts = ist->next_dts;
2692 if (avpkt.size && avpkt.size != pkt->size) {
2693 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2694 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2695 ist->showed_multi_packet_warning = 1;
2698 switch (ist->st->codec->codec_type) {
2699 case AVMEDIA_TYPE_AUDIO:
2700 ret = transcode_audio (ist, &avpkt, &got_output);
2702 case AVMEDIA_TYPE_VIDEO:
2703 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
2704 if (avpkt.duration) {
2705 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2706 } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2707 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2708 duration = ((int64_t)AV_TIME_BASE *
2709 ist->st->codec->time_base.num * ticks) /
2710 ist->st->codec->time_base.den;
2714 if(ist->dts != AV_NOPTS_VALUE && duration) {
2715 ist->next_dts += duration;
2717 ist->next_dts = AV_NOPTS_VALUE;
2720 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2722 case AVMEDIA_TYPE_SUBTITLE:
2723 ret = transcode_subtitles(ist, &avpkt, &got_output);
2733 avpkt.pts= AV_NOPTS_VALUE;
2735 // touch data and size only if not EOF
2737 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2747 /* handle stream copy */
2748 if (!ist->decoding_needed) {
2749 rate_emu_sleep(ist);
2750 ist->dts = ist->next_dts;
2751 switch (ist->st->codec->codec_type) {
2752 case AVMEDIA_TYPE_AUDIO:
2753 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2754 ist->st->codec->sample_rate;
2756 case AVMEDIA_TYPE_VIDEO:
2757 if (pkt->duration) {
2758 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2759 } else if(ist->st->codec->time_base.num != 0) {
2760 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2761 ist->next_dts += ((int64_t)AV_TIME_BASE *
2762 ist->st->codec->time_base.num * ticks) /
2763 ist->st->codec->time_base.den;
2767 ist->pts = ist->dts;
2768 ist->next_pts = ist->next_dts;
2770 for (i = 0; pkt && i < nb_output_streams; i++) {
2771 OutputStream *ost = output_streams[i];
2773 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2776 do_streamcopy(ist, ost, pkt);
2782 static void print_sdp(void)
2786 AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
2790 for (i = 0; i < nb_output_files; i++)
2791 avc[i] = output_files[i]->ctx;
2793 av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
2794 printf("SDP:\n%s\n", sdp);
2799 static int init_input_stream(int ist_index, char *error, int error_len)
2802 InputStream *ist = input_streams[ist_index];
2804 if (ist->decoding_needed) {
2805 AVCodec *codec = ist->dec;
2807 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2808 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2809 return AVERROR(EINVAL);
2812 ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
2813 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2814 ist->st->codec->get_buffer = codec_get_buffer;
2815 ist->st->codec->release_buffer = codec_release_buffer;
2816 ist->st->codec->opaque = ist;
2819 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2820 av_dict_set(&ist->opts, "threads", "auto", 0);
2821 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2822 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2823 ist->file_index, ist->st->index);
2824 return AVERROR(EINVAL);
2826 assert_codec_experimental(ist->st->codec, 0);
2827 assert_avoptions(ist->opts);
2829 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
2830 for (i = 0; i < nb_output_streams; i++) {
2831 OutputStream *ost = output_streams[i];
2832 if (ost->source_index == ist_index) {
2833 if (!ist->st->codec->channel_layout || !ost->st->codec->channel_layout)
2834 get_default_channel_layouts(ost, ist);
2841 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;
2842 ist->next_pts = AV_NOPTS_VALUE;
2843 ist->next_dts = AV_NOPTS_VALUE;
2849 static InputStream *get_input_stream(OutputStream *ost)
2851 if (ost->source_index >= 0)
2852 return input_streams[ost->source_index];
2855 FilterGraph *fg = ost->filter->graph;
2858 for (i = 0; i < fg->nb_inputs; i++)
2859 if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
2860 return fg->inputs[i]->ist;
2866 static int transcode_init(void)
2868 int ret = 0, i, j, k;
2869 AVFormatContext *oc;
2870 AVCodecContext *codec, *icodec;
2876 /* init framerate emulation */
2877 for (i = 0; i < nb_input_files; i++) {
2878 InputFile *ifile = input_files[i];
2879 if (ifile->rate_emu)
2880 for (j = 0; j < ifile->nb_streams; j++)
2881 input_streams[j + ifile->ist_index]->start = av_gettime();
2884 /* output stream init */
2885 for (i = 0; i < nb_output_files; i++) {
2886 oc = output_files[i]->ctx;
2887 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2888 av_dump_format(oc, i, oc->filename, 1);
2889 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2890 return AVERROR(EINVAL);
2894 /* init complex filtergraphs */
2895 for (i = 0; i < nb_filtergraphs; i++)
2896 if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
2899 /* for each output stream, we compute the right encoding parameters */
2900 for (i = 0; i < nb_output_streams; i++) {
2901 ost = output_streams[i];
2902 oc = output_files[ost->file_index]->ctx;
2903 ist = get_input_stream(ost);
2905 if (ost->attachment_filename)
2908 codec = ost->st->codec;
2911 icodec = ist->st->codec;
2913 ost->st->disposition = ist->st->disposition;
2914 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2915 codec->chroma_sample_location = icodec->chroma_sample_location;
2918 if (ost->stream_copy) {
2919 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2921 if (extra_size > INT_MAX) {
2922 return AVERROR(EINVAL);
2925 /* if stream_copy is selected, no need to decode or encode */
2926 codec->codec_id = icodec->codec_id;
2927 codec->codec_type = icodec->codec_type;
2929 if (!codec->codec_tag) {
2930 if (!oc->oformat->codec_tag ||
2931 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2932 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2933 codec->codec_tag = icodec->codec_tag;
2936 codec->bit_rate = icodec->bit_rate;
2937 codec->rc_max_rate = icodec->rc_max_rate;
2938 codec->rc_buffer_size = icodec->rc_buffer_size;
2939 codec->field_order = icodec->field_order;
2940 codec->extradata = av_mallocz(extra_size);
2941 if (!codec->extradata) {
2942 return AVERROR(ENOMEM);
2944 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2945 codec->extradata_size= icodec->extradata_size;
2947 codec->time_base = ist->st->time_base;
2949 * Avi is a special case here because it supports variable fps but
2950 * having the fps and timebase differe significantly adds quite some
2953 if(!strcmp(oc->oformat->name, "avi")) {
2954 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2955 && av_q2d(ist->st->time_base) < 1.0/500
2957 codec->time_base = icodec->time_base;
2958 codec->time_base.num *= icodec->ticks_per_frame;
2959 codec->time_base.den *= 2;
2960 codec->ticks_per_frame = 2;
2962 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2963 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2964 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2966 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2967 && av_q2d(ist->st->time_base) < 1.0/500
2969 codec->time_base = icodec->time_base;
2970 codec->time_base.num *= icodec->ticks_per_frame;
2973 av_reduce(&codec->time_base.num, &codec->time_base.den,
2974 codec->time_base.num, codec->time_base.den, INT_MAX);
2976 switch (codec->codec_type) {
2977 case AVMEDIA_TYPE_AUDIO:
2978 if (audio_volume != 256) {
2979 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2982 codec->channel_layout = icodec->channel_layout;
2983 codec->sample_rate = icodec->sample_rate;
2984 codec->channels = icodec->channels;
2985 codec->frame_size = icodec->frame_size;
2986 codec->audio_service_type = icodec->audio_service_type;
2987 codec->block_align = icodec->block_align;
2989 case AVMEDIA_TYPE_VIDEO:
2990 codec->pix_fmt = icodec->pix_fmt;
2991 codec->width = icodec->width;
2992 codec->height = icodec->height;
2993 codec->has_b_frames = icodec->has_b_frames;
2994 if (!codec->sample_aspect_ratio.num) {
2995 codec->sample_aspect_ratio =
2996 ost->st->sample_aspect_ratio =
2997 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2998 ist->st->codec->sample_aspect_ratio.num ?
2999 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
3001 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3003 case AVMEDIA_TYPE_SUBTITLE:
3004 codec->width = icodec->width;
3005 codec->height = icodec->height;
3007 case AVMEDIA_TYPE_DATA:
3008 case AVMEDIA_TYPE_ATTACHMENT:
3015 ost->enc = avcodec_find_encoder(codec->codec_id);
3017 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
3018 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
3019 ret = AVERROR(EINVAL);
3024 ist->decoding_needed = 1;
3025 ost->encoding_needed = 1;
3027 switch (codec->codec_type) {
3028 case AVMEDIA_TYPE_AUDIO:
3029 ost->fifo = av_fifo_alloc(1024);
3031 return AVERROR(ENOMEM);
3033 if (!codec->sample_rate)
3034 codec->sample_rate = icodec->sample_rate;
3035 choose_sample_rate(ost->st, ost->enc);
3036 codec->time_base = (AVRational){ 1, codec->sample_rate };
3038 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
3039 codec->sample_fmt = icodec->sample_fmt;
3040 choose_sample_fmt(ost->st, ost->enc);
3042 if (ost->audio_channels_mapped) {
3043 /* the requested output channel is set to the number of
3044 * -map_channel only if no -ac are specified */
3045 if (!codec->channels) {
3046 codec->channels = ost->audio_channels_mapped;
3047 codec->channel_layout = av_get_default_channel_layout(codec->channels);
3048 if (!codec->channel_layout) {
3049 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
3053 /* fill unused channel mapping with -1 (which means a muted
3054 * channel in case the number of output channels is bigger
3055 * than the number of mapped channel) */
3056 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
3057 ost->audio_channels_map[j] = -1;
3058 } else if (!codec->channels) {
3059 codec->channels = icodec->channels;
3060 codec->channel_layout = icodec->channel_layout;
3062 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
3063 codec->channel_layout = 0;
3065 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
3066 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
3067 || codec->channel_layout != icodec->channel_layout;
3068 icodec->request_channels = codec->channels;
3069 ost->resample_sample_fmt = icodec->sample_fmt;
3070 ost->resample_sample_rate = icodec->sample_rate;
3071 ost->resample_channels = icodec->channels;
3073 case AVMEDIA_TYPE_VIDEO:
3076 fg = init_simple_filtergraph(ist, ost);
3077 if (configure_video_filters(fg)) {
3078 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
3083 if (ist && !ost->frame_rate.num)
3084 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
3085 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
3086 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3087 ost->frame_rate = ost->enc->supported_framerates[idx];
3089 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
3090 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3091 && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
3092 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3093 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3095 for (j = 0; j < ost->forced_kf_count; j++)
3096 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3100 codec->width = ost->filter->filter->inputs[0]->w;
3101 codec->height = ost->filter->filter->inputs[0]->h;
3102 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3103 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
3104 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
3105 ost->filter->filter->inputs[0]->sample_aspect_ratio;
3106 codec->pix_fmt = ost->filter->filter->inputs[0]->format;
3108 if (codec->width != icodec->width ||
3109 codec->height != icodec->height ||
3110 codec->pix_fmt != icodec->pix_fmt) {
3111 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
3115 case AVMEDIA_TYPE_SUBTITLE:
3116 codec->time_base = (AVRational){1, 1000};
3123 if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
3124 char logfilename[1024];
3127 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
3128 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
3130 if (!strcmp(ost->enc->name, "libx264")) {
3131 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
3133 if (codec->flags & CODEC_FLAG_PASS2) {
3135 size_t logbuffer_size;
3136 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
3137 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
3141 codec->stats_in = logbuffer;
3143 if (codec->flags & CODEC_FLAG_PASS1) {
3144 f = fopen(logfilename, "wb");
3146 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
3147 logfilename, strerror(errno));
3157 /* open each encoder */
3158 for (i = 0; i < nb_output_streams; i++) {
3159 ost = output_streams[i];
3160 if (ost->encoding_needed) {
3161 AVCodec *codec = ost->enc;
3162 AVCodecContext *dec = NULL;
3164 if ((ist = get_input_stream(ost)))
3165 dec = ist->st->codec;
3166 if (dec && dec->subtitle_header) {
3167 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
3168 if (!ost->st->codec->subtitle_header) {
3169 ret = AVERROR(ENOMEM);
3172 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3173 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
3175 if (!av_dict_get(ost->opts, "threads", NULL, 0))
3176 av_dict_set(&ost->opts, "threads", "auto", 0);
3177 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
3178 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
3179 ost->file_index, ost->index);
3180 ret = AVERROR(EINVAL);
3183 assert_codec_experimental(ost->st->codec, 1);
3184 assert_avoptions(ost->opts);
3185 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
3186 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3187 " It takes bits/s as argument, not kbits/s\n");
3188 extra_size += ost->st->codec->extradata_size;
3190 if (ost->st->codec->me_threshold)
3191 input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
3195 /* init input streams */
3196 for (i = 0; i < nb_input_streams; i++)
3197 if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
3200 /* discard unused programs */
3201 for (i = 0; i < nb_input_files; i++) {
3202 InputFile *ifile = input_files[i];
3203 for (j = 0; j < ifile->ctx->nb_programs; j++) {
3204 AVProgram *p = ifile->ctx->programs[j];
3205 int discard = AVDISCARD_ALL;
3207 for (k = 0; k < p->nb_stream_indexes; k++)
3208 if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3209 discard = AVDISCARD_DEFAULT;
3212 p->discard = discard;
3216 /* open files and write file headers */
3217 for (i = 0; i < nb_output_files; i++) {
3218 oc = output_files[i]->ctx;
3219 oc->interrupt_callback = int_cb;
3220 if (avformat_write_header(oc, &output_files[i]->opts) < 0) {
3221 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
3222 ret = AVERROR(EINVAL);
3225 // assert_avoptions(output_files[i]->opts);
3226 if (strcmp(oc->oformat->name, "rtp")) {
3232 /* dump the file output parameters - cannot be done before in case
3234 for (i = 0; i < nb_output_files; i++) {
3235 av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
3238 /* dump the stream mapping */
3239 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3240 for (i = 0; i < nb_input_streams; i++) {
3241 ist = input_streams[i];
3243 for (j = 0; j < ist->nb_filters; j++) {
3244 AVFilterLink *link = ist->filters[j]->filter->outputs[0];
3245 if (ist->filters[j]->graph->graph_desc) {
3246 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
3247 ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3248 link->dst->filter->name);
3249 if (link->dst->input_count > 1)
3250 av_log(NULL, AV_LOG_INFO, ":%s", link->dstpad->name);
3251 if (nb_filtergraphs > 1)
3252 av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3253 av_log(NULL, AV_LOG_INFO, "\n");
3258 for (i = 0; i < nb_output_streams; i++) {
3259 ost = output_streams[i];
3261 if (ost->attachment_filename) {
3262 /* an attached file */
3263 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
3264 ost->attachment_filename, ost->file_index, ost->index);
3268 if (ost->filter && ost->filter->graph->graph_desc) {
3269 /* output from a complex graph */
3270 AVFilterLink *link = ost->filter->filter->inputs[0];
3271 av_log(NULL, AV_LOG_INFO, " %s", link->src->filter->name);
3272 if (link->src->output_count > 1)
3273 av_log(NULL, AV_LOG_INFO, ":%s", link->srcpad->name);
3274 if (nb_filtergraphs > 1)
3275 av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3277 av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3278 ost->index, ost->enc ? ost->enc->name : "?");
3282 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
3283 input_streams[ost->source_index]->file_index,
3284 input_streams[ost->source_index]->st->index,
3287 if (ost->audio_channels_mapped) {
3288 av_log(NULL, AV_LOG_INFO, " [ch:");
3289 for (j = 0; j < ost->audio_channels_mapped; j++)
3290 if (ost->audio_channels_map[j] == -1)
3291 av_log(NULL, AV_LOG_INFO, " M");
3293 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
3294 av_log(NULL, AV_LOG_INFO, "]");
3296 if (ost->sync_ist != input_streams[ost->source_index])
3297 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3298 ost->sync_ist->file_index,
3299 ost->sync_ist->st->index);
3300 if (ost->stream_copy)
3301 av_log(NULL, AV_LOG_INFO, " (copy)");
3303 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
3304 input_streams[ost->source_index]->dec->name : "?",
3305 ost->enc ? ost->enc->name : "?");
3306 av_log(NULL, AV_LOG_INFO, "\n");
3310 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3322 * The following code is the main loop of the file converter
3324 static int transcode(void)
3327 AVFormatContext *is, *os;
3331 int no_packet_count = 0;
3332 int64_t timer_start;
3335 if (!(no_packet = av_mallocz(nb_input_files)))
3338 ret = transcode_init();
3343 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
3346 timer_start = av_gettime();
3348 for (; received_sigterm == 0;) {
3349 int file_index, ist_index, past_recording_time = 1;
3352 int64_t cur_time= av_gettime();
3354 ipts_min = INT64_MAX;
3355 /* if 'q' pressed, exits */
3357 static int64_t last_time;
3358 if (received_nb_signals)
3360 /* read_key() returns 0 on EOF */
3361 if(cur_time - last_time >= 100000 && !run_as_daemon){
3363 last_time = cur_time;
3368 if (key == '+') av_log_set_level(av_log_get_level()+10);
3369 if (key == '-') av_log_set_level(av_log_get_level()-10);
3370 if (key == 's') qp_hist ^= 1;
3373 do_hex_dump = do_pkt_dump = 0;
3374 } else if(do_pkt_dump){
3378 av_log_set_level(AV_LOG_DEBUG);
3380 if (key == 'c' || key == 'C'){
3381 char buf[4096], target[64], command[256], arg[256] = {0};
3384 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
3386 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3391 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3392 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3393 target, time, command, arg);
3394 for (i = 0; i < nb_filtergraphs; i++) {
3395 FilterGraph *fg = filtergraphs[i];
3398 ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3399 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3400 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
3402 ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3407 av_log(NULL, AV_LOG_ERROR,
3408 "Parse error, at least 3 arguments were expected, "
3409 "only %d given in string '%s'\n", n, buf);
3412 if (key == 'd' || key == 'D'){
3415 debug = input_streams[0]->st->codec->debug<<1;
3416 if(!debug) debug = 1;
3417 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
3420 if(scanf("%d", &debug)!=1)
3421 fprintf(stderr,"error parsing debug value\n");
3422 for(i=0;i<nb_input_streams;i++) {
3423 input_streams[i]->st->codec->debug = debug;
3425 for(i=0;i<nb_output_streams;i++) {
3426 ost = output_streams[i];
3427 ost->st->codec->debug = debug;
3429 if(debug) av_log_set_level(AV_LOG_DEBUG);
3430 fprintf(stderr,"debug=%d\n", debug);
3433 fprintf(stderr, "key function\n"
3434 "? show this help\n"
3435 "+ increase verbosity\n"
3436 "- decrease verbosity\n"
3437 "c Send command to filtergraph\n"
3438 "D cycle through available debug modes\n"
3439 "h dump packets/hex press to cycle through the 3 states\n"
3441 "s Show QP histogram\n"
3446 /* check if there's any stream where output is still needed */
3447 for (i = 0; i < nb_output_streams; i++) {
3449 ost = output_streams[i];
3450 of = output_files[ost->file_index];
3451 os = output_files[ost->file_index]->ctx;
3452 if (ost->is_past_recording_time ||
3453 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3455 if (ost->frame_number >= ost->max_frames) {
3457 for (j = 0; j < of->ctx->nb_streams; j++)
3458 output_streams[of->ost_index + j]->is_past_recording_time = 1;
3461 past_recording_time = 0;
3463 if (past_recording_time)
3466 /* select the stream that we must read now by looking at the
3467 smallest output pts */
3469 for (i = 0; i < nb_input_streams; i++) {
3471 ist = input_streams[i];
3473 if (ist->discard || no_packet[ist->file_index])
3475 if (!input_files[ist->file_index]->eof_reached) {
3476 if (ipts < ipts_min) {
3478 file_index = ist->file_index;
3482 /* if none, if is finished */
3483 if (file_index < 0) {
3484 if (no_packet_count) {
3485 no_packet_count = 0;
3486 memset(no_packet, 0, nb_input_files);
3493 /* read a frame from it and output it in the fifo */
3494 is = input_files[file_index]->ctx;
3495 ret = av_read_frame(is, &pkt);
3496 if (ret == AVERROR(EAGAIN)) {
3497 no_packet[file_index] = 1;
3502 input_files[file_index]->eof_reached = 1;
3504 for (i = 0; i < input_files[file_index]->nb_streams; i++) {
3505 ist = input_streams[input_files[file_index]->ist_index + i];
3506 if (ist->decoding_needed)
3507 output_packet(ist, NULL);
3516 no_packet_count = 0;
3517 memset(no_packet, 0, nb_input_files);
3520 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3521 is->streams[pkt.stream_index]);
3523 /* the following test is needed in case new streams appear
3524 dynamically in stream : we ignore them */
3525 if (pkt.stream_index >= input_files[file_index]->nb_streams)
3526 goto discard_packet;
3527 ist_index = input_files[file_index]->ist_index + pkt.stream_index;
3528 ist = input_streams[ist_index];
3530 goto discard_packet;
3532 if (pkt.dts != AV_NOPTS_VALUE)
3533 pkt.dts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3534 if (pkt.pts != AV_NOPTS_VALUE)
3535 pkt.pts += av_rescale_q(input_files[ist->file_index]->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3537 if (pkt.pts != AV_NOPTS_VALUE)
3538 pkt.pts *= ist->ts_scale;
3539 if (pkt.dts != AV_NOPTS_VALUE)
3540 pkt.dts *= ist->ts_scale;
3543 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3544 "next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%"PRId64"\n",
3545 ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3546 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3547 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3548 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3549 input_files[ist->file_index]->ts_offset);
3552 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3553 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3554 int64_t delta = pkt_dts - ist->next_dts;
3555 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3556 if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3557 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3558 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3559 pkt_dts+1<ist->pts){
3560 input_files[ist->file_index]->ts_offset -= delta;
3561 av_log(NULL, AV_LOG_DEBUG,
3562 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3563 delta, input_files[ist->file_index]->ts_offset);
3564 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3565 if (pkt.pts != AV_NOPTS_VALUE)
3566 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3569 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3570 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3571 pkt_dts+1<ist->pts){
3572 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3573 pkt.dts = AV_NOPTS_VALUE;
3575 if (pkt.pts != AV_NOPTS_VALUE){
3576 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3577 delta = pkt_pts - ist->next_dts;
3578 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3579 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3580 pkt_pts+1<ist->pts) {
3581 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3582 pkt.pts = AV_NOPTS_VALUE;
3588 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3589 if (output_packet(ist, &pkt) < 0 || poll_filters() < 0) {
3590 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3591 ist->file_index, ist->st->index);
3594 av_free_packet(&pkt);
3599 av_free_packet(&pkt);
3601 /* dump report by using the output first video and audio streams */
3602 print_report(0, timer_start, cur_time);
3605 /* at the end of stream, we must flush the decoder buffers */
3606 for (i = 0; i < nb_input_streams; i++) {
3607 ist = input_streams[i];
3608 if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
3609 output_packet(ist, NULL);
3617 /* write the trailer if needed and close file */
3618 for (i = 0; i < nb_output_files; i++) {
3619 os = output_files[i]->ctx;
3620 av_write_trailer(os);
3623 /* dump report by using the first video and audio streams */
3624 print_report(1, timer_start, av_gettime());
3626 /* close each encoder */
3627 for (i = 0; i < nb_output_streams; i++) {
3628 ost = output_streams[i];
3629 if (ost->encoding_needed) {
3630 av_freep(&ost->st->codec->stats_in);
3631 avcodec_close(ost->st->codec);
3635 /* close each decoder */
3636 for (i = 0; i < nb_input_streams; i++) {
3637 ist = input_streams[i];
3638 if (ist->decoding_needed) {
3639 avcodec_close(ist->st->codec);
3647 av_freep(&no_packet);
3649 if (output_streams) {
3650 for (i = 0; i < nb_output_streams; i++) {
3651 ost = output_streams[i];
3653 if (ost->stream_copy)
3654 av_freep(&ost->st->codec->extradata);
3656 fclose(ost->logfile);
3657 ost->logfile = NULL;
3659 av_fifo_free(ost->fifo); /* works even if fifo is not
3660 initialized but set to zero */
3661 av_freep(&ost->st->codec->subtitle_header);
3662 av_free(ost->forced_kf_pts);
3663 swr_free(&ost->swr);
3664 av_dict_free(&ost->opts);
3671 static int opt_frame_crop(const char *opt, const char *arg)
3673 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3674 return AVERROR(EINVAL);
3677 static int opt_pad(const char *opt, const char *arg)
3679 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3683 static int opt_video_channel(const char *opt, const char *arg)
3685 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3686 return opt_default("channel", arg);
3689 static int opt_video_standard(const char *opt, const char *arg)
3691 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3692 return opt_default("standard", arg);
3695 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3697 audio_codec_name = arg;
3698 return parse_option(o, "codec:a", arg, options);
3701 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3703 video_codec_name = arg;
3704 return parse_option(o, "codec:v", arg, options);
3707 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3709 subtitle_codec_name = arg;
3710 return parse_option(o, "codec:s", arg, options);
3713 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3715 return parse_option(o, "codec:d", arg, options);
3718 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3720 StreamMap *m = NULL;
3721 int i, negative = 0, file_idx;
3722 int sync_file_idx = -1, sync_stream_idx = 0;
3730 map = av_strdup(arg);
3732 /* parse sync stream first, just pick first matching stream */
3733 if (sync = strchr(map, ',')) {
3735 sync_file_idx = strtol(sync + 1, &sync, 0);
3736 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3737 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3742 for (i = 0; i < input_files[sync_file_idx]->nb_streams; i++)
3743 if (check_stream_specifier(input_files[sync_file_idx]->ctx,
3744 input_files[sync_file_idx]->ctx->streams[i], sync) == 1) {
3745 sync_stream_idx = i;
3748 if (i == input_files[sync_file_idx]->nb_streams) {
3749 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3750 "match any streams.\n", arg);
3756 if (map[0] == '[') {
3757 /* this mapping refers to lavfi output */
3758 const char *c = map + 1;
3759 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3760 &o->nb_stream_maps, o->nb_stream_maps + 1);
3761 m = &o->stream_maps[o->nb_stream_maps - 1];
3762 m->linklabel = av_get_token(&c, "]");
3763 if (!m->linklabel) {
3764 av_log(NULL, AV_LOG_ERROR, "Invalid output link label: %s.\n", map);
3768 file_idx = strtol(map, &p, 0);
3769 if (file_idx >= nb_input_files || file_idx < 0) {
3770 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3774 /* disable some already defined maps */
3775 for (i = 0; i < o->nb_stream_maps; i++) {
3776 m = &o->stream_maps[i];
3777 if (file_idx == m->file_index &&
3778 check_stream_specifier(input_files[m->file_index]->ctx,
3779 input_files[m->file_index]->ctx->streams[m->stream_index],
3780 *p == ':' ? p + 1 : p) > 0)
3784 for (i = 0; i < input_files[file_idx]->nb_streams; i++) {
3785 if (check_stream_specifier(input_files[file_idx]->ctx, input_files[file_idx]->ctx->streams[i],
3786 *p == ':' ? p + 1 : p) <= 0)
3788 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3789 &o->nb_stream_maps, o->nb_stream_maps + 1);
3790 m = &o->stream_maps[o->nb_stream_maps - 1];
3792 m->file_index = file_idx;
3793 m->stream_index = i;
3795 if (sync_file_idx >= 0) {
3796 m->sync_file_index = sync_file_idx;
3797 m->sync_stream_index = sync_stream_idx;
3799 m->sync_file_index = file_idx;
3800 m->sync_stream_index = i;
3806 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3814 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3816 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3817 &o->nb_attachments, o->nb_attachments + 1);
3818 o->attachments[o->nb_attachments - 1] = arg;
3822 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3828 o->audio_channel_maps =
3829 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3830 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3831 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3833 /* muted channel syntax */
3834 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3835 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3836 m->file_idx = m->stream_idx = -1;
3838 m->ofile_idx = m->ostream_idx = -1;
3843 n = sscanf(arg, "%d.%d.%d:%d.%d",
3844 &m->file_idx, &m->stream_idx, &m->channel_idx,
3845 &m->ofile_idx, &m->ostream_idx);
3847 if (n != 3 && n != 5) {
3848 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3849 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3853 if (n != 5) // only file.stream.channel specified
3854 m->ofile_idx = m->ostream_idx = -1;
3857 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3858 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3862 if (m->stream_idx < 0 ||
3863 m->stream_idx >= input_files[m->file_idx]->nb_streams) {
3864 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3865 m->file_idx, m->stream_idx);
3868 st = input_files[m->file_idx]->ctx->streams[m->stream_idx];
3869 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3870 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3871 m->file_idx, m->stream_idx);
3874 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3875 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3876 m->file_idx, m->stream_idx, m->channel_idx);
3883 * Parse a metadata specifier in arg.
3884 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3885 * @param index for type c/p, chapter/program index is written here
3886 * @param stream_spec for type s, the stream specifier is written here
3888 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3896 if (*(++arg) && *arg != ':') {
3897 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3900 *stream_spec = *arg == ':' ? arg + 1 : "";
3904 if (*(++arg) == ':')
3905 *index = strtol(++arg, NULL, 0);
3908 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3915 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3917 AVDictionary **meta_in = NULL;
3918 AVDictionary **meta_out = NULL;
3920 char type_in, type_out;
3921 const char *istream_spec = NULL, *ostream_spec = NULL;
3922 int idx_in = 0, idx_out = 0;
3924 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3925 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3928 if (type_out == 'g' || !*outspec)
3929 o->metadata_global_manual = 1;
3930 if (type_out == 's' || !*outspec)
3931 o->metadata_streams_manual = 1;
3932 if (type_out == 'c' || !*outspec)
3933 o->metadata_chapters_manual = 1;
3937 if (type_in == 'g' || type_out == 'g')
3938 o->metadata_global_manual = 1;
3939 if (type_in == 's' || type_out == 's')
3940 o->metadata_streams_manual = 1;
3941 if (type_in == 'c' || type_out == 'c')
3942 o->metadata_chapters_manual = 1;
3944 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3945 if ((index) < 0 || (index) >= (nb_elems)) {\
3946 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3951 #define SET_DICT(type, meta, context, index)\
3954 meta = &context->metadata;\
3957 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3958 meta = &context->chapters[index]->metadata;\
3961 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3962 meta = &context->programs[index]->metadata;\
3966 SET_DICT(type_in, meta_in, ic, idx_in);
3967 SET_DICT(type_out, meta_out, oc, idx_out);
3969 /* for input streams choose first matching stream */
3970 if (type_in == 's') {
3971 for (i = 0; i < ic->nb_streams; i++) {
3972 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3973 meta_in = &ic->streams[i]->metadata;
3979 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3984 if (type_out == 's') {
3985 for (i = 0; i < oc->nb_streams; i++) {
3986 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3987 meta_out = &oc->streams[i]->metadata;
3988 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3993 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3998 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
4001 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
4002 struct tm time = *gmtime((time_t*)&recording_timestamp);
4003 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
4004 parse_option(o, "metadata", buf, options);
4006 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
4007 "tag instead.\n", opt);
4011 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
4013 const char *codec_string = encoder ? "encoder" : "decoder";
4017 avcodec_find_encoder_by_name(name) :
4018 avcodec_find_decoder_by_name(name);
4020 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
4023 if (codec->type != type) {
4024 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
4030 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
4032 char *codec_name = NULL;
4034 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
4036 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
4037 st->codec->codec_id = codec->id;
4040 return avcodec_find_decoder(st->codec->codec_id);
4044 * Add all the streams from the given input file to the global
4045 * list of input streams.
4047 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
4050 char *next, *codec_tag = NULL;
4052 for (i = 0; i < ic->nb_streams; i++) {
4053 AVStream *st = ic->streams[i];
4054 AVCodecContext *dec = st->codec;
4055 InputStream *ist = av_mallocz(sizeof(*ist));
4060 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
4061 input_streams[nb_input_streams - 1] = ist;
4064 ist->file_index = nb_input_files;
4066 st->discard = AVDISCARD_ALL;
4067 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
4069 ist->ts_scale = 1.0;
4070 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
4072 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
4074 uint32_t tag = strtol(codec_tag, &next, 0);
4076 tag = AV_RL32(codec_tag);
4077 st->codec->codec_tag = tag;
4080 ist->dec = choose_decoder(o, ic, st);
4082 switch (dec->codec_type) {
4083 case AVMEDIA_TYPE_VIDEO:
4085 ist->dec = avcodec_find_decoder(dec->codec_id);
4087 dec->flags |= CODEC_FLAG_EMU_EDGE;
4090 ist->resample_height = dec->height;
4091 ist->resample_width = dec->width;
4092 ist->resample_pix_fmt = dec->pix_fmt;
4095 case AVMEDIA_TYPE_AUDIO:
4096 case AVMEDIA_TYPE_DATA:
4097 case AVMEDIA_TYPE_SUBTITLE:
4099 ist->dec = avcodec_find_decoder(dec->codec_id);
4101 case AVMEDIA_TYPE_ATTACHMENT:
4102 case AVMEDIA_TYPE_UNKNOWN:
4110 static void assert_file_overwrite(const char *filename)
4112 if ((!file_overwrite || no_file_overwrite) &&
4113 (strchr(filename, ':') == NULL || filename[1] == ':' ||
4114 av_strstart(filename, "file:", NULL))) {
4115 if (avio_check(filename, 0) == 0) {
4116 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
4117 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
4120 signal(SIGINT, SIG_DFL);
4121 if (!read_yesno()) {
4122 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
4128 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
4135 static void dump_attachment(AVStream *st, const char *filename)
4138 AVIOContext *out = NULL;
4139 AVDictionaryEntry *e;
4141 if (!st->codec->extradata_size) {
4142 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
4143 nb_input_files - 1, st->index);
4146 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
4147 filename = e->value;
4149 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
4150 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
4154 assert_file_overwrite(filename);
4156 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
4157 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
4162 avio_write(out, st->codec->extradata, st->codec->extradata_size);
4167 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
4169 AVFormatContext *ic;
4170 AVInputFormat *file_iformat = NULL;
4174 AVDictionary **opts;
4175 int orig_nb_streams; // number of streams before avformat_find_stream_info
4178 if (!(file_iformat = av_find_input_format(o->format))) {
4179 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
4184 if (!strcmp(filename, "-"))
4187 using_stdin |= !strncmp(filename, "pipe:", 5) ||
4188 !strcmp(filename, "/dev/stdin");
4190 /* get default parameters from command line */
4191 ic = avformat_alloc_context();
4193 print_error(filename, AVERROR(ENOMEM));
4196 if (o->nb_audio_sample_rate) {
4197 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
4198 av_dict_set(&format_opts, "sample_rate", buf, 0);
4200 if (o->nb_audio_channels) {
4201 /* because we set audio_channels based on both the "ac" and
4202 * "channel_layout" options, we need to check that the specified
4203 * demuxer actually has the "channels" option before setting it */
4204 if (file_iformat && file_iformat->priv_class &&
4205 av_opt_find(&file_iformat->priv_class, "channels", NULL, 0,
4206 AV_OPT_SEARCH_FAKE_OBJ)) {
4207 snprintf(buf, sizeof(buf), "%d",
4208 o->audio_channels[o->nb_audio_channels - 1].u.i);
4209 av_dict_set(&format_opts, "channels", buf, 0);
4212 if (o->nb_frame_rates) {
4213 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
4215 if (o->nb_frame_sizes) {
4216 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
4218 if (o->nb_frame_pix_fmts)
4219 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
4221 ic->video_codec_id = video_codec_name ?
4222 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
4223 ic->audio_codec_id = audio_codec_name ?
4224 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
4225 ic->subtitle_codec_id= subtitle_codec_name ?
4226 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
4227 ic->flags |= AVFMT_FLAG_NONBLOCK;
4228 ic->interrupt_callback = int_cb;
4230 /* open the input file with generic avformat function */
4231 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
4233 print_error(filename, err);
4236 assert_avoptions(format_opts);
4238 /* apply forced codec ids */
4239 for (i = 0; i < ic->nb_streams; i++)
4240 choose_decoder(o, ic, ic->streams[i]);
4242 /* Set AVCodecContext options for avformat_find_stream_info */
4243 opts = setup_find_stream_info_opts(ic, codec_opts);
4244 orig_nb_streams = ic->nb_streams;
4246 /* If not enough info to get the stream parameters, we decode the
4247 first frames to get it. (used in mpeg case for example) */
4248 ret = avformat_find_stream_info(ic, opts);
4250 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
4251 avformat_close_input(&ic);
4255 timestamp = o->start_time;
4256 /* add the stream start time */
4257 if (ic->start_time != AV_NOPTS_VALUE)
4258 timestamp += ic->start_time;
4260 /* if seeking requested, we execute it */
4261 if (o->start_time != 0) {
4262 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
4264 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
4265 filename, (double)timestamp / AV_TIME_BASE);
4269 /* update the current parameters so that they match the one of the input stream */
4270 add_input_streams(o, ic);
4272 /* dump the file content */
4273 av_dump_format(ic, nb_input_files, filename, 0);
4275 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
4276 if (!(input_files[nb_input_files - 1] = av_mallocz(sizeof(*input_files[0]))))
4279 input_files[nb_input_files - 1]->ctx = ic;
4280 input_files[nb_input_files - 1]->ist_index = nb_input_streams - ic->nb_streams;
4281 input_files[nb_input_files - 1]->ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
4282 input_files[nb_input_files - 1]->nb_streams = ic->nb_streams;
4283 input_files[nb_input_files - 1]->rate_emu = o->rate_emu;
4285 for (i = 0; i < o->nb_dump_attachment; i++) {
4288 for (j = 0; j < ic->nb_streams; j++) {
4289 AVStream *st = ic->streams[j];
4291 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
4292 dump_attachment(st, o->dump_attachment[i].u.str);
4296 for (i = 0; i < orig_nb_streams; i++)
4297 av_dict_free(&opts[i]);
4300 reset_options(o, 1);
4304 static void parse_forced_key_frames(char *kf, OutputStream *ost)
4309 for (p = kf; *p; p++)
4312 ost->forced_kf_count = n;
4313 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
4314 if (!ost->forced_kf_pts) {
4315 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
4318 for (i = 0; i < n; i++) {
4319 p = i ? strchr(p, ',') + 1 : kf;
4320 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
4324 static uint8_t *get_line(AVIOContext *s)
4330 if (avio_open_dyn_buf(&line) < 0) {
4331 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
4335 while ((c = avio_r8(s)) && c != '\n')
4338 avio_close_dyn_buf(line, &buf);
4343 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
4346 char filename[1000];
4347 const char *base[3] = { getenv("AVCONV_DATADIR"),
4352 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
4356 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
4357 i != 1 ? "" : "/.avconv", codec_name, preset_name);
4358 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4361 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
4362 i != 1 ? "" : "/.avconv", preset_name);
4363 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
4369 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
4371 char *codec_name = NULL;
4373 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
4375 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
4376 NULL, ost->st->codec->codec_type);
4377 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
4378 } else if (!strcmp(codec_name, "copy"))
4379 ost->stream_copy = 1;
4381 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
4382 ost->st->codec->codec_id = ost->enc->id;
4386 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
4389 AVStream *st = avformat_new_stream(oc, NULL);
4390 int idx = oc->nb_streams - 1, ret = 0;
4391 char *bsf = NULL, *next, *codec_tag = NULL;
4392 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
4394 char *buf = NULL, *arg = NULL, *preset = NULL;
4395 AVIOContext *s = NULL;
4398 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
4402 if (oc->nb_streams - 1 < o->nb_streamid_map)
4403 st->id = o->streamid_map[oc->nb_streams - 1];
4405 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
4406 nb_output_streams + 1);
4407 if (!(ost = av_mallocz(sizeof(*ost))))
4409 output_streams[nb_output_streams - 1] = ost;
4411 ost->file_index = nb_output_files;
4414 st->codec->codec_type = type;
4415 choose_encoder(o, oc, ost);
4417 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
4420 avcodec_get_context_defaults3(st->codec, ost->enc);
4421 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
4423 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
4424 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
4427 if (!buf[0] || buf[0] == '#') {
4431 if (!(arg = strchr(buf, '='))) {
4432 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
4436 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
4438 } while (!s->eof_reached);
4442 av_log(NULL, AV_LOG_FATAL,
4443 "Preset %s specified for stream %d:%d, but could not be opened.\n",
4444 preset, ost->file_index, ost->index);
4448 ost->max_frames = INT64_MAX;
4449 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
4451 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
4453 if (next = strchr(bsf, ','))
4455 if (!(bsfc = av_bitstream_filter_init(bsf))) {
4456 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
4460 bsfc_prev->next = bsfc;
4462 ost->bitstream_filters = bsfc;
4468 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
4470 uint32_t tag = strtol(codec_tag, &next, 0);
4472 tag = AV_RL32(codec_tag);
4473 st->codec->codec_tag = tag;
4476 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4477 if (qscale >= 0 || same_quant) {
4478 st->codec->flags |= CODEC_FLAG_QSCALE;
4479 st->codec->global_quality = FF_QP2LAMBDA * qscale;
4482 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4483 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4485 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4486 av_opt_get_int (swr_opts, "dither_method", 0, &ost->swr_dither_method);
4487 av_opt_get_double(swr_opts, "dither_scale" , 0, &ost->swr_dither_scale);
4489 ost->source_index = source_index;
4490 if (source_index >= 0) {
4491 ost->sync_ist = input_streams[source_index];
4492 input_streams[source_index]->discard = 0;
4493 input_streams[source_index]->st->discard = AVDISCARD_NONE;
4496 ost->pix_fmts[0] = ost->pix_fmts[1] = PIX_FMT_NONE;
4501 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4504 const char *p = str;
4511 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4518 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4522 AVCodecContext *video_enc;
4524 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4526 video_enc = st->codec;
4528 if (!ost->stream_copy) {
4529 const char *p = NULL;
4530 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
4531 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4532 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
4535 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4536 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4537 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4541 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4542 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4543 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4547 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4548 if (frame_aspect_ratio) {
4550 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4551 q.num <= 0 || q.den <= 0) {
4552 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4555 ost->frame_aspect_ratio = av_q2d(q);
4558 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4559 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4560 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4561 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4564 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4567 video_enc->gop_size = 0;
4568 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4570 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4571 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4574 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4576 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4578 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4579 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4582 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4585 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4586 for (i = 0; p; i++) {
4588 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4590 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4593 /* FIXME realloc failure */
4594 video_enc->rc_override =
4595 av_realloc(video_enc->rc_override,
4596 sizeof(RcOverride) * (i + 1));
4597 video_enc->rc_override[i].start_frame = start;
4598 video_enc->rc_override[i].end_frame = end;
4600 video_enc->rc_override[i].qscale = q;
4601 video_enc->rc_override[i].quality_factor = 1.0;
4604 video_enc->rc_override[i].qscale = 0;
4605 video_enc->rc_override[i].quality_factor = -q/100.0;
4610 video_enc->rc_override_count = i;
4611 if (!video_enc->rc_initial_buffer_occupancy)
4612 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4613 video_enc->intra_dc_precision = intra_dc_precision - 8;
4616 video_enc->flags|= CODEC_FLAG_PSNR;
4621 video_enc->flags |= CODEC_FLAG_PASS1;
4624 video_enc->flags |= CODEC_FLAG_PASS2;
4628 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4629 if (forced_key_frames)
4630 parse_forced_key_frames(forced_key_frames, ost);
4632 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4634 ost->top_field_first = -1;
4635 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4637 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4639 ost->avfilter = av_strdup(filters);
4641 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4647 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4652 AVCodecContext *audio_enc;
4654 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4657 audio_enc = st->codec;
4658 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4660 if (!ost->stream_copy) {
4661 char *sample_fmt = NULL;
4663 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4665 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4667 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4668 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4672 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4674 ost->rematrix_volume=1.0;
4675 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4678 /* check for channel mapping for this audio stream */
4679 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4680 AudioChannelMap *map = &o->audio_channel_maps[n];
4681 InputStream *ist = input_streams[ost->source_index];
4682 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4683 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4684 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4685 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4686 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4688 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4689 ost->file_index, ost->st->index);
4696 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4700 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4701 if (!ost->stream_copy) {
4702 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4709 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4711 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4712 ost->stream_copy = 1;
4716 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4720 AVCodecContext *subtitle_enc;
4722 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4724 subtitle_enc = st->codec;
4726 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4728 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc, st);
4733 /* arg format is "output-stream-index:streamid-value". */
4734 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4740 av_strlcpy(idx_str, arg, sizeof(idx_str));
4741 p = strchr(idx_str, ':');
4743 av_log(NULL, AV_LOG_FATAL,
4744 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4749 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4750 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4751 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4755 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4757 AVFormatContext *is = ifile->ctx;
4758 AVFormatContext *os = ofile->ctx;
4761 for (i = 0; i < is->nb_chapters; i++) {
4762 AVChapter *in_ch = is->chapters[i], *out_ch;
4763 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4764 AV_TIME_BASE_Q, in_ch->time_base);
4765 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4766 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4769 if (in_ch->end < ts_off)
4771 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4774 out_ch = av_mallocz(sizeof(AVChapter));
4776 return AVERROR(ENOMEM);
4778 out_ch->id = in_ch->id;
4779 out_ch->time_base = in_ch->time_base;
4780 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4781 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4784 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4787 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4789 return AVERROR(ENOMEM);
4790 os->chapters[os->nb_chapters - 1] = out_ch;
4795 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4798 AVFormatContext *ic = avformat_alloc_context();
4800 ic->interrupt_callback = int_cb;
4801 err = avformat_open_input(&ic, filename, NULL, NULL);
4804 /* copy stream format */
4805 for(i=0;i<ic->nb_streams;i++) {
4809 AVCodecContext *avctx;
4811 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4812 ost = new_output_stream(o, s, codec->type, -1);
4817 // FIXME: a more elegant solution is needed
4818 memcpy(st, ic->streams[i], sizeof(AVStream));
4820 st->info = av_malloc(sizeof(*st->info));
4821 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4823 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4825 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4826 choose_sample_fmt(st, codec);
4827 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4828 choose_pixel_fmt(st, codec, st->codec->pix_fmt);
4831 avformat_close_input(&ic);
4835 static void init_output_filter(OutputFilter *ofilter, OptionsContext *o,
4836 AVFormatContext *oc)
4840 if (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type != AVMEDIA_TYPE_VIDEO) {
4841 av_log(NULL, AV_LOG_FATAL, "Only video filters are supported currently.\n");
4845 ost = new_video_stream(o, oc, -1);
4846 ost->source_index = -1;
4847 ost->filter = ofilter;
4851 if (configure_output_filter(ofilter->graph, ofilter, ofilter->out_tmp) < 0) {
4852 av_log(NULL, AV_LOG_FATAL, "Error configuring filter.\n");
4855 avfilter_inout_free(&ofilter->out_tmp);
4858 static void opt_output_file(void *optctx, const char *filename)
4860 OptionsContext *o = optctx;
4861 AVFormatContext *oc;
4863 AVOutputFormat *file_oformat;
4867 if (configure_complex_filters() < 0) {
4868 av_log(NULL, AV_LOG_FATAL, "Error configuring filters.\n");
4872 if (!strcmp(filename, "-"))
4875 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4877 print_error(filename, err);
4880 file_oformat= oc->oformat;
4881 oc->interrupt_callback = int_cb;
4883 /* create streams for all unlabeled output pads */
4884 for (i = 0; i < nb_filtergraphs; i++) {
4885 FilterGraph *fg = filtergraphs[i];
4886 for (j = 0; j < fg->nb_outputs; j++) {
4887 OutputFilter *ofilter = fg->outputs[j];
4889 if (!ofilter->out_tmp || ofilter->out_tmp->name)
4892 switch (ofilter->out_tmp->filter_ctx->output_pads[ofilter->out_tmp->pad_idx].type) {
4893 case AVMEDIA_TYPE_VIDEO: o->video_disable = 1; break;
4894 case AVMEDIA_TYPE_AUDIO: o->audio_disable = 1; break;
4895 case AVMEDIA_TYPE_SUBTITLE: o->subtitle_disable = 1; break;
4897 init_output_filter(ofilter, o, oc);
4901 if (!strcmp(file_oformat->name, "ffm") &&
4902 av_strstart(filename, "http:", NULL)) {
4904 /* special case for files sent to ffserver: we get the stream
4905 parameters from ffserver */
4906 int err = read_ffserver_streams(o, oc, filename);
4908 print_error(filename, err);
4911 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4912 ost = output_streams[j];
4913 for (i = 0; i < nb_input_streams; i++) {
4914 ist = input_streams[i];
4915 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4917 ost->source_index= i;
4919 ist->st->discard = AVDISCARD_NONE;
4924 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));
4928 } else if (!o->nb_stream_maps) {
4929 /* pick the "best" stream of each type */
4931 /* video: highest resolution */
4932 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4933 int area = 0, idx = -1;
4934 for (i = 0; i < nb_input_streams; i++) {
4935 ist = input_streams[i];
4936 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4937 ist->st->codec->width * ist->st->codec->height > area) {
4938 area = ist->st->codec->width * ist->st->codec->height;
4943 new_video_stream(o, oc, idx);
4946 /* audio: most channels */
4947 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4948 int channels = 0, idx = -1;
4949 for (i = 0; i < nb_input_streams; i++) {
4950 ist = input_streams[i];
4951 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4952 ist->st->codec->channels > channels) {
4953 channels = ist->st->codec->channels;
4958 new_audio_stream(o, oc, idx);
4961 /* subtitles: pick first */
4962 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4963 for (i = 0; i < nb_input_streams; i++)
4964 if (input_streams[i]->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4965 new_subtitle_stream(o, oc, i);
4969 /* do something with data? */
4971 for (i = 0; i < o->nb_stream_maps; i++) {
4972 StreamMap *map = &o->stream_maps[i];
4973 int src_idx = input_files[map->file_index]->ist_index + map->stream_index;
4978 if (map->linklabel) {
4980 OutputFilter *ofilter = NULL;
4983 for (j = 0; j < nb_filtergraphs; j++) {
4984 fg = filtergraphs[j];
4985 for (k = 0; k < fg->nb_outputs; k++) {
4986 AVFilterInOut *out = fg->outputs[k]->out_tmp;
4987 if (out && !strcmp(out->name, map->linklabel)) {
4988 ofilter = fg->outputs[k];
4995 av_log(NULL, AV_LOG_FATAL, "Output with label '%s' does not exist "
4996 "in any defined filter graph.\n", map->linklabel);
4999 init_output_filter(ofilter, o, oc);
5001 ist = input_streams[input_files[map->file_index]->ist_index + map->stream_index];
5002 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
5004 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
5006 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
5008 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
5011 switch (ist->st->codec->codec_type) {
5012 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream (o, oc, src_idx); break;
5013 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream (o, oc, src_idx); break;
5014 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream (o, oc, src_idx); break;
5015 case AVMEDIA_TYPE_DATA: ost = new_data_stream (o, oc, src_idx); break;
5016 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
5018 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
5019 map->file_index, map->stream_index);
5027 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
5028 AVDictionaryEntry *e;
5029 ost = output_streams[i];
5031 if ( ost->stream_copy
5032 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
5033 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
5034 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
5038 /* handle attached files */
5039 for (i = 0; i < o->nb_attachments; i++) {
5041 uint8_t *attachment;
5045 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
5046 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
5050 if ((len = avio_size(pb)) <= 0) {
5051 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
5055 if (!(attachment = av_malloc(len))) {
5056 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
5060 avio_read(pb, attachment, len);
5062 ost = new_attachment_stream(o, oc, -1);
5063 ost->stream_copy = 0;
5064 ost->attachment_filename = o->attachments[i];
5065 ost->st->codec->extradata = attachment;
5066 ost->st->codec->extradata_size = len;
5068 p = strrchr(o->attachments[i], '/');
5069 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
5073 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
5074 if (!(output_files[nb_output_files - 1] = av_mallocz(sizeof(*output_files[0]))))
5077 output_files[nb_output_files - 1]->ctx = oc;
5078 output_files[nb_output_files - 1]->ost_index = nb_output_streams - oc->nb_streams;
5079 output_files[nb_output_files - 1]->recording_time = o->recording_time;
5080 if (o->recording_time != INT64_MAX)
5081 oc->duration = o->recording_time;
5082 output_files[nb_output_files - 1]->start_time = o->start_time;
5083 output_files[nb_output_files - 1]->limit_filesize = o->limit_filesize;
5084 av_dict_copy(&output_files[nb_output_files - 1]->opts, format_opts, 0);
5086 /* check filename in case of an image number is expected */
5087 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
5088 if (!av_filename_number_test(oc->filename)) {
5089 print_error(oc->filename, AVERROR(EINVAL));
5094 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
5095 /* test if it already exists to avoid losing precious files */
5096 assert_file_overwrite(filename);
5099 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
5100 &oc->interrupt_callback,
5101 &output_files[nb_output_files - 1]->opts)) < 0) {
5102 print_error(filename, err);
5107 if (o->mux_preload) {
5109 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
5110 av_dict_set(&output_files[nb_output_files - 1]->opts, "preload", buf, 0);
5112 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
5115 for (i = 0; i < o->nb_metadata_map; i++) {
5117 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
5119 if (in_file_index >= nb_input_files) {
5120 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
5123 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index]->ctx : NULL, o);
5127 if (o->chapters_input_file >= nb_input_files) {
5128 if (o->chapters_input_file == INT_MAX) {
5129 /* copy chapters from the first input file that has them*/
5130 o->chapters_input_file = -1;
5131 for (i = 0; i < nb_input_files; i++)
5132 if (input_files[i]->ctx->nb_chapters) {
5133 o->chapters_input_file = i;
5137 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
5138 o->chapters_input_file);
5142 if (o->chapters_input_file >= 0)
5143 copy_chapters(input_files[o->chapters_input_file], output_files[nb_output_files - 1],
5144 !o->metadata_chapters_manual);
5146 /* copy global metadata by default */
5147 if (!o->metadata_global_manual && nb_input_files){
5148 av_dict_copy(&oc->metadata, input_files[0]->ctx->metadata,
5149 AV_DICT_DONT_OVERWRITE);
5150 if(o->recording_time != INT64_MAX)
5151 av_dict_set(&oc->metadata, "duration", NULL, 0);
5153 if (!o->metadata_streams_manual)
5154 for (i = output_files[nb_output_files - 1]->ost_index; i < nb_output_streams; i++) {
5156 if (output_streams[i]->source_index < 0) /* this is true e.g. for attached files */
5158 ist = input_streams[output_streams[i]->source_index];
5159 av_dict_copy(&output_streams[i]->st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
5162 /* process manually set metadata */
5163 for (i = 0; i < o->nb_metadata; i++) {
5166 const char *stream_spec;
5167 int index = 0, j, ret = 0;
5169 val = strchr(o->metadata[i].u.str, '=');
5171 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
5172 o->metadata[i].u.str);
5177 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
5179 for (j = 0; j < oc->nb_streams; j++) {
5180 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
5181 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
5185 printf("ret %d, stream_spec %s\n", ret, stream_spec);
5193 if (index < 0 || index >= oc->nb_chapters) {
5194 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
5197 m = &oc->chapters[index]->metadata;
5200 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
5203 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
5207 reset_options(o, 0);
5210 /* same option as mencoder */
5211 static int opt_pass(const char *opt, const char *arg)
5213 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
5217 static int64_t getmaxrss(void)
5219 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
5220 struct rusage rusage;
5221 getrusage(RUSAGE_SELF, &rusage);
5222 return (int64_t)rusage.ru_maxrss * 1024;
5223 #elif HAVE_GETPROCESSMEMORYINFO
5225 PROCESS_MEMORY_COUNTERS memcounters;
5226 proc = GetCurrentProcess();
5227 memcounters.cb = sizeof(memcounters);
5228 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
5229 return memcounters.PeakPagefileUsage;
5235 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
5237 return parse_option(o, "q:a", arg, options);
5240 static void show_usage(void)
5242 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
5243 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
5244 av_log(NULL, AV_LOG_INFO, "\n");
5247 static int opt_help(const char *opt, const char *arg)
5249 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
5250 av_log_set_callback(log_callback_help);
5252 show_help_options(options, "Main options:\n",
5253 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
5254 show_help_options(options, "\nAdvanced options:\n",
5255 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
5257 show_help_options(options, "\nVideo options:\n",
5258 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5260 show_help_options(options, "\nAdvanced Video options:\n",
5261 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5262 OPT_VIDEO | OPT_EXPERT);
5263 show_help_options(options, "\nAudio options:\n",
5264 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5266 show_help_options(options, "\nAdvanced Audio options:\n",
5267 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
5268 OPT_AUDIO | OPT_EXPERT);
5269 show_help_options(options, "\nSubtitle options:\n",
5270 OPT_SUBTITLE | OPT_GRAB,
5272 show_help_options(options, "\nAudio/Video grab options:\n",
5276 show_help_children(avcodec_get_class(), flags);
5277 show_help_children(avformat_get_class(), flags);
5278 show_help_children(sws_get_class(), flags);
5283 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
5285 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
5286 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
5288 if (!strncmp(arg, "pal-", 4)) {
5291 } else if (!strncmp(arg, "ntsc-", 5)) {
5294 } else if (!strncmp(arg, "film-", 5)) {
5298 /* Try to determine PAL/NTSC by peeking in the input files */
5299 if (nb_input_files) {
5301 for (j = 0; j < nb_input_files; j++) {
5302 for (i = 0; i < input_files[j]->nb_streams; i++) {
5303 AVCodecContext *c = input_files[j]->ctx->streams[i]->codec;
5304 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
5306 fr = c->time_base.den * 1000 / c->time_base.num;
5310 } else if ((fr == 29970) || (fr == 23976)) {
5315 if (norm != UNKNOWN)
5319 if (norm != UNKNOWN)
5320 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
5323 if (norm == UNKNOWN) {
5324 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
5325 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
5326 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
5330 if (!strcmp(arg, "vcd")) {
5331 opt_video_codec(o, "c:v", "mpeg1video");
5332 opt_audio_codec(o, "c:a", "mp2");
5333 parse_option(o, "f", "vcd", options);
5335 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
5336 parse_option(o, "r", frame_rates[norm], options);
5337 opt_default("g", norm == PAL ? "15" : "18");
5339 opt_default("b:v", "1150000");
5340 opt_default("maxrate", "1150000");
5341 opt_default("minrate", "1150000");
5342 opt_default("bufsize", "327680"); // 40*1024*8;
5344 opt_default("b:a", "224000");
5345 parse_option(o, "ar", "44100", options);
5346 parse_option(o, "ac", "2", options);
5348 opt_default("packetsize", "2324");
5349 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
5351 /* We have to offset the PTS, so that it is consistent with the SCR.
5352 SCR starts at 36000, but the first two packs contain only padding
5353 and the first pack from the other stream, respectively, may also have
5354 been written before.
5355 So the real data starts at SCR 36000+3*1200. */
5356 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
5357 } else if (!strcmp(arg, "svcd")) {
5359 opt_video_codec(o, "c:v", "mpeg2video");
5360 opt_audio_codec(o, "c:a", "mp2");
5361 parse_option(o, "f", "svcd", options);
5363 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
5364 parse_option(o, "r", frame_rates[norm], options);
5365 parse_option(o, "pix_fmt", "yuv420p", options);
5366 opt_default("g", norm == PAL ? "15" : "18");
5368 opt_default("b:v", "2040000");
5369 opt_default("maxrate", "2516000");
5370 opt_default("minrate", "0"); // 1145000;
5371 opt_default("bufsize", "1835008"); // 224*1024*8;
5372 opt_default("scan_offset", "1");
5375 opt_default("b:a", "224000");
5376 parse_option(o, "ar", "44100", options);
5378 opt_default("packetsize", "2324");
5380 } else if (!strcmp(arg, "dvd")) {
5382 opt_video_codec(o, "c:v", "mpeg2video");
5383 opt_audio_codec(o, "c:a", "ac3");
5384 parse_option(o, "f", "dvd", options);
5386 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5387 parse_option(o, "r", frame_rates[norm], options);
5388 parse_option(o, "pix_fmt", "yuv420p", options);
5389 opt_default("g", norm == PAL ? "15" : "18");
5391 opt_default("b:v", "6000000");
5392 opt_default("maxrate", "9000000");
5393 opt_default("minrate", "0"); // 1500000;
5394 opt_default("bufsize", "1835008"); // 224*1024*8;
5396 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
5397 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
5399 opt_default("b:a", "448000");
5400 parse_option(o, "ar", "48000", options);
5402 } else if (!strncmp(arg, "dv", 2)) {
5404 parse_option(o, "f", "dv", options);
5406 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
5407 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
5408 norm == PAL ? "yuv420p" : "yuv411p", options);
5409 parse_option(o, "r", frame_rates[norm], options);
5411 parse_option(o, "ar", "48000", options);
5412 parse_option(o, "ac", "2", options);
5415 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
5416 return AVERROR(EINVAL);
5421 static int opt_vstats_file(const char *opt, const char *arg)
5423 av_free (vstats_filename);
5424 vstats_filename = av_strdup (arg);
5428 static int opt_vstats(const char *opt, const char *arg)
5431 time_t today2 = time(NULL);
5432 struct tm *today = localtime(&today2);
5434 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
5436 return opt_vstats_file(opt, filename);
5439 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
5441 return parse_option(o, "frames:v", arg, options);
5444 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
5446 return parse_option(o, "frames:a", arg, options);
5449 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
5451 return parse_option(o, "frames:d", arg, options);
5454 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
5457 char filename[1000], tmp[1000], tmp2[1000], line[1000];
5458 const char *codec_name = *opt == 'v' ? video_codec_name :
5459 *opt == 'a' ? audio_codec_name :
5460 subtitle_codec_name;
5462 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
5463 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
5464 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
5466 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
5471 int e= fscanf(f, "%999[^\n]\n", line) - 1;
5472 if(line[0] == '#' && !e)
5474 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
5476 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
5479 if(!strcmp(tmp, "acodec")){
5480 opt_audio_codec(o, tmp, tmp2);
5481 }else if(!strcmp(tmp, "vcodec")){
5482 opt_video_codec(o, tmp, tmp2);
5483 }else if(!strcmp(tmp, "scodec")){
5484 opt_subtitle_codec(o, tmp, tmp2);
5485 }else if(!strcmp(tmp, "dcodec")){
5486 opt_data_codec(o, tmp, tmp2);
5487 }else if(opt_default(tmp, tmp2) < 0){
5488 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
5498 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
5502 static int opt_passlogfile(const char *opt, const char *arg)
5504 pass_logfilename_prefix = arg;
5505 #if CONFIG_LIBX264_ENCODER
5506 return opt_default(opt, arg);
5512 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
5514 char *s = av_asprintf("%s:%c", opt + 1, *opt);
5515 int ret = parse_option(o, s, arg, options);
5520 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
5522 if(!strcmp(opt, "b")){
5523 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
5524 return parse_option(o, "b:v", arg, options);
5526 return opt_default(opt, arg);
5529 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
5533 if(!strcmp(opt, "qscale")){
5534 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5535 return parse_option(o, "q:v", arg, options);
5537 s = av_asprintf("q%s", opt + 6);
5538 ret = parse_option(o, s, arg, options);
5543 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5545 if(!strcmp(opt, "profile")){
5546 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5547 return parse_option(o, "profile:v", arg, options);
5549 return opt_default(opt, arg);
5552 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5554 return parse_option(o, "filter:v", arg, options);
5557 static int opt_vsync(const char *opt, const char *arg)
5559 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
5560 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
5561 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5562 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
5564 if (video_sync_method == VSYNC_AUTO)
5565 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5569 static int opt_deinterlace(const char *opt, const char *arg)
5571 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5576 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5578 int idx = locate_option(argc, argv, options, "cpuflags");
5579 if (idx && argv[idx + 1])
5580 opt_cpuflags("cpuflags", argv[idx + 1]);
5583 static int opt_channel_layout(OptionsContext *o, const char *opt, const char *arg)
5585 char layout_str[32];
5588 int ret, channels, ac_str_size;
5591 layout = av_get_channel_layout(arg);
5593 av_log(NULL, AV_LOG_ERROR, "Unknown channel layout: %s\n", arg);
5594 return AVERROR(EINVAL);
5596 snprintf(layout_str, sizeof(layout_str), "%"PRIu64, layout);
5597 ret = opt_default(opt, layout_str);
5601 /* set 'ac' option based on channel layout */
5602 channels = av_get_channel_layout_nb_channels(layout);
5603 snprintf(layout_str, sizeof(layout_str), "%d", channels);
5604 stream_str = strchr(opt, ':');
5605 ac_str_size = 3 + (stream_str ? strlen(stream_str) : 0);
5606 ac_str = av_mallocz(ac_str_size);
5608 return AVERROR(ENOMEM);
5609 av_strlcpy(ac_str, "ac", 3);
5611 av_strlcat(ac_str, stream_str, ac_str_size);
5612 ret = parse_option(o, ac_str, layout_str, options);
5618 static int opt_filter_complex(const char *opt, const char *arg)
5620 filtergraphs = grow_array(filtergraphs, sizeof(*filtergraphs),
5621 &nb_filtergraphs, nb_filtergraphs + 1);
5622 if (!(filtergraphs[nb_filtergraphs - 1] = av_mallocz(sizeof(*filtergraphs[0]))))
5623 return AVERROR(ENOMEM);
5624 filtergraphs[nb_filtergraphs - 1]->index = nb_filtergraphs - 1;
5625 filtergraphs[nb_filtergraphs - 1]->graph_desc = arg;
5629 #define OFFSET(x) offsetof(OptionsContext, x)
5630 static const OptionDef options[] = {
5632 #include "cmdutils_common_opts.h"
5633 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5634 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5635 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5636 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5637 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5638 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5639 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5640 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5641 { "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]" },
5642 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5643 "outfile[,metadata]:infile[,metadata]" },
5644 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
5645 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5646 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5647 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5648 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5649 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5650 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5651 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5652 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5653 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5654 "add timings for benchmarking" },
5655 { "benchmark_all", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark_all},
5656 "add timings for each task" },
5657 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5658 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5659 "dump each input packet" },
5660 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5661 "when dumping packets, also dump the payload" },
5662 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5663 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5664 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5665 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5666 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5667 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
5668 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
5669 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5670 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5671 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5672 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5673 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5674 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5675 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5676 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5677 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5678 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5679 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5680 { "filter_complex", HAS_ARG | OPT_EXPERT, {(void*)opt_filter_complex}, "create a complex filtergraph", "graph_description" },
5681 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5682 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5683 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5684 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5687 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5688 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5689 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5690 { "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" },
5691 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5692 { "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" },
5693 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5694 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5695 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5696 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5697 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5698 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5699 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5700 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5701 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5702 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5703 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5704 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5705 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5706 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5707 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5708 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5709 "use same quantizer as source (implies VBR)" },
5710 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5711 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5712 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5713 "this option is deprecated, use the yadif filter instead" },
5714 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5715 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5716 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5717 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5718 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5719 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5720 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5721 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5722 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5723 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5724 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5725 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5726 { "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" },
5727 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5730 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5731 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5732 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5733 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5734 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5735 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5736 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5737 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5738 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5739 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
5740 { "channel_layout", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_channel_layout}, "set channel layout", "layout" },
5742 /* subtitle options */
5743 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5744 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5745 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5748 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5749 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5750 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5753 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5754 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5756 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5757 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5758 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5760 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5761 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5762 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5763 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5764 /* data codec support */
5765 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5766 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5768 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5772 int main(int argc, char **argv)
5774 OptionsContext o = { 0 };
5777 reset_options(&o, 0);
5779 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5780 parse_loglevel(argc, argv, options);
5782 if(argc>1 && !strcmp(argv[1], "-d")){
5784 av_log_set_callback(log_callback_null);
5789 avcodec_register_all();
5791 avdevice_register_all();
5793 avfilter_register_all();
5795 avformat_network_init();
5797 show_banner(argc, argv, options);
5801 parse_cpuflags(argc, argv, options);
5804 parse_options(&o, argc, argv, options, opt_output_file);
5806 if (nb_output_files <= 0 && nb_input_files == 0) {
5808 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5812 /* file converter / grab */
5813 if (nb_output_files <= 0) {
5814 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5818 if (nb_input_files == 0) {
5819 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5823 current_time = ti = getutime();
5824 if (transcode() < 0)
5826 ti = getutime() - ti;
5828 int maxrss = getmaxrss() / 1024;
5829 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);