3 * Copyright (c) 2000-2011 The libav developers.
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavutil/imgutils.h"
48 #include "libavformat/os_support.h"
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/avfiltergraph.h"
53 # include "libavfilter/buffersrc.h"
54 # include "libavfilter/vsrc_buffer.h"
57 #if HAVE_SYS_RESOURCE_H
58 #include <sys/types.h>
60 #include <sys/resource.h>
61 #elif HAVE_GETPROCESSTIMES
64 #if HAVE_GETPROCESSMEMORYINFO
70 #include <sys/select.h>
77 #include "libavutil/avassert.h"
80 #define VSYNC_PASSTHROUGH 0
84 const char program_name[] = "avconv";
85 const int program_birth_year = 2000;
87 /* select an input stream for an output stream */
88 typedef struct StreamMap {
89 int disabled; /** 1 is this mapping is disabled by a negative map */
93 int sync_stream_index;
97 * select an input file for an output file
99 typedef struct MetadataMap {
100 int file; ///< file index
101 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
102 int index; ///< stream/chapter/program number
105 static const OptionDef options[];
107 static int video_discard = 0;
108 static int same_quant = 0;
109 static int do_deinterlace = 0;
110 static int intra_dc_precision = 8;
111 static int qp_hist = 0;
113 static int file_overwrite = 0;
114 static int do_benchmark = 0;
115 static int do_hex_dump = 0;
116 static int do_pkt_dump = 0;
117 static int do_pass = 0;
118 static char *pass_logfilename_prefix = NULL;
119 static int video_sync_method = VSYNC_AUTO;
120 static int audio_sync_method = 0;
121 static float audio_drift_threshold = 0.1;
122 static int copy_ts = 0;
123 static int copy_tb = 1;
124 static int opt_shortest = 0;
125 static char *vstats_filename;
126 static FILE *vstats_file;
128 static int audio_volume = 256;
130 static int exit_on_error = 0;
131 static int using_stdin = 0;
132 static int64_t video_size = 0;
133 static int64_t audio_size = 0;
134 static int64_t extra_size = 0;
135 static int nb_frames_dup = 0;
136 static int nb_frames_drop = 0;
137 static int input_sync;
139 static float dts_delta_threshold = 10;
141 static int print_stats = 1;
143 static uint8_t *audio_buf;
144 static unsigned int allocated_audio_buf_size;
146 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
148 typedef struct FrameBuffer {
154 enum PixelFormat pix_fmt;
157 struct InputStream *ist;
158 struct FrameBuffer *next;
161 typedef struct InputStream {
164 int discard; /* true if stream data should be discarded */
165 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
167 AVFrame *decoded_frame;
168 AVFrame *filtered_frame;
170 int64_t start; /* time when read started */
171 int64_t next_pts; /* synthetic pts for cases where pkt.pts
173 int64_t pts; /* current pts */
174 PtsCorrectionContext pts_ctx;
176 int is_start; /* is 1 at the start and after a discontinuity */
177 int showed_multi_packet_warning;
180 /* a pool of free buffers for decoded data */
181 FrameBuffer *buffer_pool;
184 typedef struct InputFile {
185 AVFormatContext *ctx;
186 int eof_reached; /* true if eof reached */
187 int ist_index; /* index of first stream in ist_table */
188 int buffer_size; /* current total buffer size */
190 int nb_streams; /* number of stream that avconv is aware of; may be different
191 from ctx.nb_streams if new streams appear during av_read_frame() */
195 typedef struct OutputStream {
196 int file_index; /* file index */
197 int index; /* stream index in the output file */
198 int source_index; /* InputStream index */
199 AVStream *st; /* stream in the output file */
200 int encoding_needed; /* true if encoding needed for this stream */
202 /* input pts and corresponding output pts
204 // double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
205 struct InputStream *sync_ist; /* input stream to sync against */
206 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
207 AVBitStreamFilterContext *bitstream_filters;
210 AVFrame *output_frame;
214 AVFrame pict_tmp; /* temporary image for resampling */
215 struct SwsContext *img_resample_ctx; /* for image resampling */
218 int resample_pix_fmt;
219 AVRational frame_rate;
223 float frame_aspect_ratio;
225 /* forced key frames */
226 int64_t *forced_kf_pts;
232 ReSampleContext *resample; /* for audio resampling */
233 int resample_sample_fmt;
234 int resample_channels;
235 int resample_sample_rate;
237 AVAudioConvert *reformat_ctx;
238 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
242 AVFilterContext *output_video_filter;
243 AVFilterContext *input_video_filter;
244 AVFilterBufferRef *picref;
246 AVFilterGraph *graph;
251 int is_past_recording_time;
253 const char *attachment_filename;
254 int copy_initial_nonkeyframes;
258 typedef struct OutputFile {
259 AVFormatContext *ctx;
261 int ost_index; /* index of the first stream in output_streams */
262 int64_t recording_time; /* desired length of the resulting file in microseconds */
263 int64_t start_time; /* start time in microseconds */
264 uint64_t limit_filesize;
267 static InputStream *input_streams = NULL;
268 static int nb_input_streams = 0;
269 static InputFile *input_files = NULL;
270 static int nb_input_files = 0;
272 static OutputStream *output_streams = NULL;
273 static int nb_output_streams = 0;
274 static OutputFile *output_files = NULL;
275 static int nb_output_files = 0;
277 typedef struct OptionsContext {
278 /* input/output options */
282 SpecifierOpt *codec_names;
284 SpecifierOpt *audio_channels;
285 int nb_audio_channels;
286 SpecifierOpt *audio_sample_rate;
287 int nb_audio_sample_rate;
288 SpecifierOpt *frame_rates;
290 SpecifierOpt *frame_sizes;
292 SpecifierOpt *frame_pix_fmts;
293 int nb_frame_pix_fmts;
296 int64_t input_ts_offset;
299 SpecifierOpt *ts_scale;
301 SpecifierOpt *dump_attachment;
302 int nb_dump_attachment;
305 StreamMap *stream_maps;
307 /* first item specifies output metadata, second is input */
308 MetadataMap (*meta_data_maps)[2];
309 int nb_meta_data_maps;
310 int metadata_global_manual;
311 int metadata_streams_manual;
312 int metadata_chapters_manual;
313 const char **attachments;
316 int chapters_input_file;
318 int64_t recording_time;
319 uint64_t limit_filesize;
325 int subtitle_disable;
328 /* indexed by output file stream index */
332 SpecifierOpt *metadata;
334 SpecifierOpt *max_frames;
336 SpecifierOpt *bitstream_filters;
337 int nb_bitstream_filters;
338 SpecifierOpt *codec_tags;
340 SpecifierOpt *sample_fmts;
342 SpecifierOpt *qscale;
344 SpecifierOpt *forced_key_frames;
345 int nb_forced_key_frames;
346 SpecifierOpt *force_fps;
348 SpecifierOpt *frame_aspect_ratios;
349 int nb_frame_aspect_ratios;
350 SpecifierOpt *rc_overrides;
352 SpecifierOpt *intra_matrices;
353 int nb_intra_matrices;
354 SpecifierOpt *inter_matrices;
355 int nb_inter_matrices;
356 SpecifierOpt *top_field_first;
357 int nb_top_field_first;
358 SpecifierOpt *metadata_map;
360 SpecifierOpt *presets;
362 SpecifierOpt *copy_initial_nonkeyframes;
363 int nb_copy_initial_nonkeyframes;
365 SpecifierOpt *filters;
370 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
373 for (i = 0; i < o->nb_ ## name; i++) {\
374 char *spec = o->name[i].specifier;\
375 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
376 outvar = o->name[i].u.type;\
382 static void reset_options(OptionsContext *o)
384 const OptionDef *po = options;
386 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
388 void *dst = (uint8_t*)o + po->u.off;
390 if (po->flags & OPT_SPEC) {
391 SpecifierOpt **so = dst;
392 int i, *count = (int*)(so + 1);
393 for (i = 0; i < *count; i++) {
394 av_freep(&(*so)[i].specifier);
395 if (po->flags & OPT_STRING)
396 av_freep(&(*so)[i].u.str);
400 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
405 av_freep(&o->stream_maps);
406 av_freep(&o->meta_data_maps);
407 av_freep(&o->streamid_map);
409 memset(o, 0, sizeof(*o));
411 o->mux_max_delay = 0.7;
412 o->recording_time = INT64_MAX;
413 o->limit_filesize = UINT64_MAX;
414 o->chapters_input_file = INT_MAX;
420 static int alloc_buffer(InputStream *ist, FrameBuffer **pbuf)
422 AVCodecContext *s = ist->st->codec;
423 FrameBuffer *buf = av_mallocz(sizeof(*buf));
425 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
426 int h_chroma_shift, v_chroma_shift;
427 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
428 int w = s->width, h = s->height;
431 return AVERROR(ENOMEM);
433 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
438 avcodec_align_dimensions(s, &w, &h);
439 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
440 s->pix_fmt, 32)) < 0) {
444 /* XXX this shouldn't be needed, but some tests break without this line
445 * those decoders are buggy and need to be fixed.
446 * the following tests fail:
447 * bethsoft-vid, cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
449 memset(buf->base[0], 128, ret);
451 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
452 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
453 const int h_shift = i==0 ? 0 : h_chroma_shift;
454 const int v_shift = i==0 ? 0 : v_chroma_shift;
455 if (s->flags & CODEC_FLAG_EMU_EDGE)
456 buf->data[i] = buf->base[i];
458 buf->data[i] = buf->base[i] +
459 FFALIGN((buf->linesize[i]*edge >> v_shift) +
460 (pixel_size*edge >> h_shift), 32);
464 buf->pix_fmt = s->pix_fmt;
471 static void free_buffer_pool(InputStream *ist)
473 FrameBuffer *buf = ist->buffer_pool;
475 ist->buffer_pool = buf->next;
476 av_freep(&buf->base[0]);
478 buf = ist->buffer_pool;
482 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
484 av_assert0(buf->refcount);
486 if (!buf->refcount) {
487 buf->next = ist->buffer_pool;
488 ist->buffer_pool = buf;
492 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
494 InputStream *ist = s->opaque;
498 if (!ist->buffer_pool && (ret = alloc_buffer(ist, &ist->buffer_pool)) < 0)
501 buf = ist->buffer_pool;
502 ist->buffer_pool = buf->next;
504 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
505 av_freep(&buf->base[0]);
507 if ((ret = alloc_buffer(ist, &buf)) < 0)
513 frame->type = FF_BUFFER_TYPE_USER;
514 frame->extended_data = frame->data;
515 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
517 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
518 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
519 frame->data[i] = buf->data[i];
520 frame->linesize[i] = buf->linesize[i];
526 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
528 InputStream *ist = s->opaque;
529 FrameBuffer *buf = frame->opaque;
532 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
533 frame->data[i] = NULL;
535 unref_buffer(ist, buf);
538 static void filter_release_buffer(AVFilterBuffer *fb)
540 FrameBuffer *buf = fb->priv;
542 unref_buffer(buf->ist, buf);
547 static int configure_video_filters(InputStream *ist, OutputStream *ost)
549 AVFilterContext *last_filter, *filter;
550 /** filter graph containing all filters including input & output */
551 AVCodecContext *codec = ost->st->codec;
552 AVCodecContext *icodec = ist->st->codec;
553 SinkContext sink_ctx = { .pix_fmt = codec->pix_fmt };
554 AVRational sample_aspect_ratio;
558 ost->graph = avfilter_graph_alloc();
560 if (ist->st->sample_aspect_ratio.num) {
561 sample_aspect_ratio = ist->st->sample_aspect_ratio;
563 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
565 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
566 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
567 sample_aspect_ratio.num, sample_aspect_ratio.den);
569 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
570 "src", args, NULL, ost->graph);
573 ret = avfilter_graph_create_filter(&ost->output_video_filter, &sink,
574 "out", NULL, &sink_ctx, ost->graph);
577 last_filter = ost->input_video_filter;
579 if (codec->width != icodec->width || codec->height != icodec->height) {
580 snprintf(args, 255, "%d:%d:flags=0x%X",
583 (unsigned)ost->sws_flags);
584 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
585 NULL, args, NULL, ost->graph)) < 0)
587 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
589 last_filter = filter;
592 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
593 ost->graph->scale_sws_opts = av_strdup(args);
596 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
597 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
599 outputs->name = av_strdup("in");
600 outputs->filter_ctx = last_filter;
601 outputs->pad_idx = 0;
602 outputs->next = NULL;
604 inputs->name = av_strdup("out");
605 inputs->filter_ctx = ost->output_video_filter;
609 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
612 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
616 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
619 codec->width = ost->output_video_filter->inputs[0]->w;
620 codec->height = ost->output_video_filter->inputs[0]->h;
621 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
622 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
623 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
624 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
628 #endif /* CONFIG_AVFILTER */
630 static void term_exit(void)
632 av_log(NULL, AV_LOG_QUIET, "");
635 static volatile int received_sigterm = 0;
636 static volatile int received_nb_signals = 0;
639 sigterm_handler(int sig)
641 received_sigterm = sig;
642 received_nb_signals++;
646 static void term_init(void)
648 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
649 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
651 signal(SIGXCPU, sigterm_handler);
655 static int decode_interrupt_cb(void *ctx)
657 return received_nb_signals > 1;
660 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
662 void exit_program(int ret)
667 for (i = 0; i < nb_output_files; i++) {
668 AVFormatContext *s = output_files[i].ctx;
669 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
671 avformat_free_context(s);
672 av_dict_free(&output_files[i].opts);
674 for (i = 0; i < nb_output_streams; i++) {
675 AVBitStreamFilterContext *bsfc = output_streams[i].bitstream_filters;
677 AVBitStreamFilterContext *next = bsfc->next;
678 av_bitstream_filter_close(bsfc);
681 output_streams[i].bitstream_filters = NULL;
683 if (output_streams[i].output_frame) {
684 AVFrame *frame = output_streams[i].output_frame;
685 if (frame->extended_data != frame->data)
686 av_freep(&frame->extended_data);
691 av_freep(&output_streams[i].avfilter);
694 for (i = 0; i < nb_input_files; i++) {
695 avformat_close_input(&input_files[i].ctx);
697 for (i = 0; i < nb_input_streams; i++) {
698 av_freep(&input_streams[i].decoded_frame);
699 av_freep(&input_streams[i].filtered_frame);
700 av_dict_free(&input_streams[i].opts);
701 free_buffer_pool(&input_streams[i]);
706 av_free(vstats_filename);
708 av_freep(&input_streams);
709 av_freep(&input_files);
710 av_freep(&output_streams);
711 av_freep(&output_files);
715 allocated_audio_buf_size = 0;
720 avformat_network_deinit();
722 if (received_sigterm) {
723 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
724 (int) received_sigterm);
731 static void assert_avoptions(AVDictionary *m)
733 AVDictionaryEntry *t;
734 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
735 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
740 static void assert_codec_experimental(AVCodecContext *c, int encoder)
742 const char *codec_string = encoder ? "encoder" : "decoder";
744 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
745 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
746 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
747 "results.\nAdd '-strict experimental' if you want to use it.\n",
748 codec_string, c->codec->name);
749 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
750 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
751 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
752 codec_string, codec->name);
757 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
759 if (codec && codec->sample_fmts) {
760 const enum AVSampleFormat *p = codec->sample_fmts;
761 for (; *p != -1; p++) {
762 if (*p == st->codec->sample_fmt)
766 av_log(NULL, AV_LOG_WARNING,
767 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
768 av_get_sample_fmt_name(st->codec->sample_fmt),
770 av_get_sample_fmt_name(codec->sample_fmts[0]));
771 st->codec->sample_fmt = codec->sample_fmts[0];
777 * Update the requested input sample format based on the output sample format.
778 * This is currently only used to request float output from decoders which
779 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
780 * Ideally this will be removed in the future when decoders do not do format
781 * conversion and only output in their native format.
783 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
786 /* if sample formats match or a decoder sample format has already been
787 requested, just return */
788 if (enc->sample_fmt == dec->sample_fmt ||
789 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
792 /* if decoder supports more than one output format */
793 if (dec_codec && dec_codec->sample_fmts &&
794 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
795 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
796 const enum AVSampleFormat *p;
797 int min_dec = -1, min_inc = -1;
799 /* find a matching sample format in the encoder */
800 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
801 if (*p == enc->sample_fmt) {
802 dec->request_sample_fmt = *p;
804 } else if (*p > enc->sample_fmt) {
805 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
807 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
810 /* if none match, provide the one that matches quality closest */
811 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
812 enc->sample_fmt - min_dec;
816 static void choose_sample_rate(AVStream *st, AVCodec *codec)
818 if (codec && codec->supported_samplerates) {
819 const int *p = codec->supported_samplerates;
821 int best_dist = INT_MAX;
823 int dist = abs(st->codec->sample_rate - *p);
824 if (dist < best_dist) {
830 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
832 st->codec->sample_rate = best;
836 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
838 if (codec && codec->pix_fmts) {
839 const enum PixelFormat *p = codec->pix_fmts;
840 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
841 if (st->codec->codec_id == CODEC_ID_MJPEG) {
842 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
843 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
844 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
845 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
848 for (; *p != PIX_FMT_NONE; p++) {
849 if (*p == st->codec->pix_fmt)
852 if (*p == PIX_FMT_NONE) {
853 if (st->codec->pix_fmt != PIX_FMT_NONE)
854 av_log(NULL, AV_LOG_WARNING,
855 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
856 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
858 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
859 st->codec->pix_fmt = codec->pix_fmts[0];
865 get_sync_ipts(const OutputStream *ost)
867 const InputStream *ist = ost->sync_ist;
868 OutputFile *of = &output_files[ost->file_index];
869 return (double)(ist->pts - of->start_time) / AV_TIME_BASE;
872 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
874 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
875 AVCodecContext *avctx = ost->st->codec;
879 * Audio encoders may split the packets -- #frames in != #packets out.
880 * But there is no reordering, so we can limit the number of output packets
881 * by simply dropping them here.
882 * Counting encoded video frames needs to be done separately because of
883 * reordering, see do_video_out()
885 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
886 if (ost->frame_number >= ost->max_frames)
892 AVPacket new_pkt = *pkt;
893 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
894 &new_pkt.data, &new_pkt.size,
895 pkt->data, pkt->size,
896 pkt->flags & AV_PKT_FLAG_KEY);
899 new_pkt.destruct = av_destruct_packet;
901 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
902 bsfc->filter->name, pkt->stream_index,
903 avctx->codec ? avctx->codec->name : "copy");
913 ret = av_interleaved_write_frame(s, pkt);
915 print_error("av_interleaved_write_frame()", ret);
920 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
922 int fill_char = 0x00;
923 if (sample_fmt == AV_SAMPLE_FMT_U8)
925 memset(buf, fill_char, size);
928 static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,
929 const uint8_t *buf, int buf_size)
931 AVCodecContext *enc = ost->st->codec;
932 AVFrame *frame = NULL;
936 av_init_packet(&pkt);
941 if (!ost->output_frame) {
942 ost->output_frame = avcodec_alloc_frame();
943 if (!ost->output_frame) {
944 av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");
948 frame = ost->output_frame;
949 if (frame->extended_data != frame->data)
950 av_freep(&frame->extended_data);
951 avcodec_get_frame_defaults(frame);
953 frame->nb_samples = buf_size /
954 (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
955 if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,
956 buf, buf_size, 1)) < 0) {
957 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
963 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
964 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
969 pkt.stream_index = ost->index;
970 if (pkt.pts != AV_NOPTS_VALUE)
971 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
972 if (pkt.duration > 0)
973 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
975 write_frame(s, &pkt, ost);
977 audio_size += pkt.size;
981 ost->sync_opts += frame->nb_samples;
986 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
987 InputStream *ist, AVFrame *decoded_frame)
990 int64_t audio_buf_size;
992 int size_out, frame_bytes, resample_changed;
993 AVCodecContext *enc = ost->st->codec;
994 AVCodecContext *dec = ist->st->codec;
995 int osize = av_get_bytes_per_sample(enc->sample_fmt);
996 int isize = av_get_bytes_per_sample(dec->sample_fmt);
997 uint8_t *buf = decoded_frame->data[0];
998 int size = decoded_frame->nb_samples * dec->channels * isize;
999 int64_t allocated_for_size = size;
1002 audio_buf_size = (allocated_for_size + isize * dec->channels - 1) / (isize * dec->channels);
1003 audio_buf_size = (audio_buf_size * enc->sample_rate + dec->sample_rate) / dec->sample_rate;
1004 audio_buf_size = audio_buf_size * 2 + 10000; // safety factors for the deprecated resampling API
1005 audio_buf_size = FFMAX(audio_buf_size, enc->frame_size);
1006 audio_buf_size *= osize * enc->channels;
1008 if (audio_buf_size > INT_MAX) {
1009 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
1013 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
1015 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1019 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
1020 ost->audio_resample = 1;
1022 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1023 ost->resample_channels != dec->channels ||
1024 ost->resample_sample_rate != dec->sample_rate;
1026 if ((ost->audio_resample && !ost->resample) || resample_changed) {
1027 if (resample_changed) {
1028 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",
1029 ist->file_index, ist->st->index,
1030 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
1031 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
1032 ost->resample_sample_fmt = dec->sample_fmt;
1033 ost->resample_channels = dec->channels;
1034 ost->resample_sample_rate = dec->sample_rate;
1036 audio_resample_close(ost->resample);
1038 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1039 if (audio_sync_method <= 1 &&
1040 ost->resample_sample_fmt == enc->sample_fmt &&
1041 ost->resample_channels == enc->channels &&
1042 ost->resample_sample_rate == enc->sample_rate) {
1043 ost->resample = NULL;
1044 ost->audio_resample = 0;
1045 } else if (ost->audio_resample) {
1046 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
1047 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
1048 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
1049 enc->sample_rate, dec->sample_rate,
1050 enc->sample_fmt, dec->sample_fmt,
1052 if (!ost->resample) {
1053 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1054 dec->channels, dec->sample_rate,
1055 enc->channels, enc->sample_rate);
1061 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
1062 if (!ost->audio_resample && dec->sample_fmt != enc->sample_fmt &&
1063 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt) != ost->reformat_pair) {
1064 if (ost->reformat_ctx)
1065 av_audio_convert_free(ost->reformat_ctx);
1066 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
1067 dec->sample_fmt, 1, NULL, 0);
1068 if (!ost->reformat_ctx) {
1069 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
1070 av_get_sample_fmt_name(dec->sample_fmt),
1071 av_get_sample_fmt_name(enc->sample_fmt));
1074 ost->reformat_pair = MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
1077 if (audio_sync_method) {
1078 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts -
1079 av_fifo_size(ost->fifo) / (enc->channels * osize);
1080 int idelta = delta * dec->sample_rate / enc->sample_rate;
1081 int byte_delta = idelta * isize * dec->channels;
1083 // FIXME resample delay
1084 if (fabs(delta) > 50) {
1085 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1086 if (byte_delta < 0) {
1087 byte_delta = FFMAX(byte_delta, -size);
1090 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1091 -byte_delta / (isize * dec->channels));
1096 static uint8_t *input_tmp = NULL;
1097 input_tmp = av_realloc(input_tmp, byte_delta + size);
1099 if (byte_delta > allocated_for_size - size) {
1100 allocated_for_size = byte_delta + (int64_t)size;
1105 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
1106 memcpy(input_tmp + byte_delta, buf, size);
1109 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1111 } else if (audio_sync_method > 1) {
1112 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1113 av_assert0(ost->audio_resample);
1114 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1115 delta, comp, enc->sample_rate);
1116 // 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));
1117 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
1121 ost->sync_opts = lrintf(get_sync_ipts(ost) * enc->sample_rate) -
1122 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1124 if (ost->audio_resample) {
1126 size_out = audio_resample(ost->resample,
1127 (short *)buftmp, (short *)buf,
1128 size / (dec->channels * isize));
1129 size_out = size_out * enc->channels * osize;
1135 if (!ost->audio_resample && dec->sample_fmt != enc->sample_fmt) {
1136 const void *ibuf[6] = { buftmp };
1137 void *obuf[6] = { audio_buf };
1138 int istride[6] = { isize };
1139 int ostride[6] = { osize };
1140 int len = size_out / istride[0];
1141 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len) < 0) {
1142 printf("av_audio_convert() failed\n");
1148 size_out = len * osize;
1151 /* now encode as many frames as possible */
1152 if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1153 /* output resampled raw samples */
1154 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1155 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1158 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1160 frame_bytes = enc->frame_size * osize * enc->channels;
1162 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1163 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1164 encode_audio_frame(s, ost, audio_buf, frame_bytes);
1167 encode_audio_frame(s, ost, buftmp, size_out);
1171 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1173 AVCodecContext *dec;
1174 AVPicture *picture2;
1175 AVPicture picture_tmp;
1178 dec = ist->st->codec;
1180 /* deinterlace : must be done before any resize */
1181 if (do_deinterlace) {
1184 /* create temporary picture */
1185 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1186 buf = av_malloc(size);
1190 picture2 = &picture_tmp;
1191 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1193 if (avpicture_deinterlace(picture2, picture,
1194 dec->pix_fmt, dec->width, dec->height) < 0) {
1195 /* if error, do not deinterlace */
1196 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1205 if (picture != picture2)
1206 *picture = *picture2;
1210 static void do_subtitle_out(AVFormatContext *s,
1216 static uint8_t *subtitle_out = NULL;
1217 int subtitle_out_max_size = 1024 * 1024;
1218 int subtitle_out_size, nb, i;
1219 AVCodecContext *enc;
1222 if (pts == AV_NOPTS_VALUE) {
1223 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1229 enc = ost->st->codec;
1231 if (!subtitle_out) {
1232 subtitle_out = av_malloc(subtitle_out_max_size);
1235 /* Note: DVB subtitle need one packet to draw them and one other
1236 packet to clear them */
1237 /* XXX: signal it in the codec context ? */
1238 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1243 for (i = 0; i < nb; i++) {
1244 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1245 // start_display_time is required to be 0
1246 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1247 sub->end_display_time -= sub->start_display_time;
1248 sub->start_display_time = 0;
1249 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1250 subtitle_out_max_size, sub);
1251 if (subtitle_out_size < 0) {
1252 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1256 av_init_packet(&pkt);
1257 pkt.stream_index = ost->index;
1258 pkt.data = subtitle_out;
1259 pkt.size = subtitle_out_size;
1260 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1261 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1262 /* XXX: the pts correction is handled here. Maybe handling
1263 it in the codec would be better */
1265 pkt.pts += 90 * sub->start_display_time;
1267 pkt.pts += 90 * sub->end_display_time;
1269 write_frame(s, &pkt, ost);
1273 static int bit_buffer_size = 1024 * 256;
1274 static uint8_t *bit_buffer = NULL;
1276 #if !CONFIG_AVFILTER
1277 static void do_video_resample(OutputStream *ost,
1279 AVFrame *in_picture,
1280 AVFrame **out_picture)
1282 int resample_changed = 0;
1283 *out_picture = in_picture;
1285 resample_changed = ost->resample_width != in_picture->width ||
1286 ost->resample_height != in_picture->height ||
1287 ost->resample_pix_fmt != in_picture->format;
1289 if (resample_changed) {
1290 av_log(NULL, AV_LOG_INFO,
1291 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1292 ist->file_index, ist->st->index,
1293 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1294 in_picture->width, in_picture->height, av_get_pix_fmt_name(in_picture->format));
1295 if (!ost->video_resample)
1296 ost->video_resample = 1;
1299 if (ost->video_resample) {
1300 *out_picture = &ost->pict_tmp;
1301 if (resample_changed) {
1302 /* initialize a new scaler context */
1303 sws_freeContext(ost->img_resample_ctx);
1304 ost->img_resample_ctx = sws_getContext(
1305 ist->st->codec->width,
1306 ist->st->codec->height,
1307 ist->st->codec->pix_fmt,
1308 ost->st->codec->width,
1309 ost->st->codec->height,
1310 ost->st->codec->pix_fmt,
1311 ost->sws_flags, NULL, NULL, NULL);
1312 if (ost->img_resample_ctx == NULL) {
1313 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1317 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1318 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1320 if (resample_changed) {
1321 ost->resample_width = in_picture->width;
1322 ost->resample_height = in_picture->height;
1323 ost->resample_pix_fmt = in_picture->format;
1329 static void do_video_out(AVFormatContext *s,
1332 AVFrame *in_picture,
1333 int *frame_size, float quality)
1335 int nb_frames, i, ret, format_video_sync;
1336 AVFrame *final_picture;
1337 AVCodecContext *enc;
1340 enc = ost->st->codec;
1342 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1344 /* by default, we output a single frame */
1349 format_video_sync = video_sync_method;
1350 if (format_video_sync == VSYNC_AUTO)
1351 format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
1352 (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
1354 if (format_video_sync != VSYNC_PASSTHROUGH) {
1355 double vdelta = sync_ipts - ost->sync_opts;
1356 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1359 else if (format_video_sync == VSYNC_VFR) {
1360 if (vdelta <= -0.6) {
1362 } else if (vdelta > 0.6)
1363 ost->sync_opts = lrintf(sync_ipts);
1364 } else if (vdelta > 1.1)
1365 nb_frames = lrintf(vdelta);
1366 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1367 if (nb_frames == 0) {
1369 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1370 } else if (nb_frames > 1) {
1371 nb_frames_dup += nb_frames - 1;
1372 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1375 ost->sync_opts = lrintf(sync_ipts);
1377 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1381 #if !CONFIG_AVFILTER
1382 do_video_resample(ost, ist, in_picture, &final_picture);
1384 final_picture = in_picture;
1387 /* duplicates frame if needed */
1388 for (i = 0; i < nb_frames; i++) {
1390 av_init_packet(&pkt);
1391 pkt.stream_index = ost->index;
1393 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1394 enc->codec->id == CODEC_ID_RAWVIDEO) {
1395 /* raw pictures are written as AVPicture structure to
1396 avoid any copies. We support temporarily the older
1398 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1399 enc->coded_frame->top_field_first = in_picture->top_field_first;
1400 pkt.data = (uint8_t *)final_picture;
1401 pkt.size = sizeof(AVPicture);
1402 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1403 pkt.flags |= AV_PKT_FLAG_KEY;
1405 write_frame(s, &pkt, ost);
1407 AVFrame big_picture;
1409 big_picture = *final_picture;
1410 /* better than nothing: use input picture interlaced
1412 big_picture.interlaced_frame = in_picture->interlaced_frame;
1413 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1414 if (ost->top_field_first == -1)
1415 big_picture.top_field_first = in_picture->top_field_first;
1417 big_picture.top_field_first = !!ost->top_field_first;
1420 /* handles same_quant here. This is not correct because it may
1421 not be a global option */
1422 big_picture.quality = quality;
1423 if (!enc->me_threshold)
1424 big_picture.pict_type = 0;
1425 // big_picture.pts = AV_NOPTS_VALUE;
1426 big_picture.pts = ost->sync_opts;
1427 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1428 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1429 if (ost->forced_kf_index < ost->forced_kf_count &&
1430 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1431 big_picture.pict_type = AV_PICTURE_TYPE_I;
1432 ost->forced_kf_index++;
1434 ret = avcodec_encode_video(enc,
1435 bit_buffer, bit_buffer_size,
1438 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1443 pkt.data = bit_buffer;
1445 if (enc->coded_frame->pts != AV_NOPTS_VALUE)
1446 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1447 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1448 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1449 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1451 if (enc->coded_frame->key_frame)
1452 pkt.flags |= AV_PKT_FLAG_KEY;
1453 write_frame(s, &pkt, ost);
1456 // fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1457 // enc->frame_number-1, ret, enc->pict_type);
1458 /* if two pass, output log */
1459 if (ost->logfile && enc->stats_out) {
1460 fprintf(ost->logfile, "%s", enc->stats_out);
1466 * For video, number of frames in == number of packets out.
1467 * But there may be reordering, so we can't throw away frames on encoder
1468 * flush, we need to limit them here, before they go into encoder.
1470 ost->frame_number++;
1474 static double psnr(double d)
1476 return -10.0 * log(d) / log(10.0);
1479 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1482 AVCodecContext *enc;
1484 double ti1, bitrate, avg_bitrate;
1486 /* this is executed just the first time do_video_stats is called */
1488 vstats_file = fopen(vstats_filename, "w");
1495 enc = ost->st->codec;
1496 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1497 frame_number = ost->frame_number;
1498 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1499 if (enc->flags&CODEC_FLAG_PSNR)
1500 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1502 fprintf(vstats_file,"f_size= %6d ", frame_size);
1503 /* compute pts value */
1504 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1508 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1509 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1510 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1511 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1512 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1516 static void print_report(OutputFile *output_files,
1517 OutputStream *ost_table, int nb_ostreams,
1518 int is_last_report, int64_t timer_start)
1522 AVFormatContext *oc;
1524 AVCodecContext *enc;
1525 int frame_number, vid, i;
1526 double bitrate, ti1, pts;
1527 static int64_t last_time = -1;
1528 static int qp_histogram[52];
1530 if (!print_stats && !is_last_report)
1533 if (!is_last_report) {
1535 /* display the report every 0.5 seconds */
1536 cur_time = av_gettime();
1537 if (last_time == -1) {
1538 last_time = cur_time;
1541 if ((cur_time - last_time) < 500000)
1543 last_time = cur_time;
1547 oc = output_files[0].ctx;
1549 total_size = avio_size(oc->pb);
1550 if (total_size < 0) // FIXME improve avio_size() so it works with non seekable output too
1551 total_size = avio_tell(oc->pb);
1556 for (i = 0; i < nb_ostreams; i++) {
1558 ost = &ost_table[i];
1559 enc = ost->st->codec;
1560 if (!ost->stream_copy && enc->coded_frame)
1561 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1562 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1563 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1565 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1566 float t = (av_gettime() - timer_start) / 1000000.0;
1568 frame_number = ost->frame_number;
1569 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1570 frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1572 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1576 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1578 for (j = 0; j < 32; j++)
1579 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1581 if (enc->flags&CODEC_FLAG_PSNR) {
1583 double error, error_sum = 0;
1584 double scale, scale_sum = 0;
1585 char type[3] = { 'Y','U','V' };
1586 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1587 for (j = 0; j < 3; j++) {
1588 if (is_last_report) {
1589 error = enc->error[j];
1590 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1592 error = enc->coded_frame->error[j];
1593 scale = enc->width * enc->height * 255.0 * 255.0;
1599 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1601 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1605 /* compute min output value */
1606 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1607 if ((pts < ti1) && (pts > 0))
1613 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1615 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1616 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1617 (double)total_size / 1024, ti1, bitrate);
1619 if (nb_frames_dup || nb_frames_drop)
1620 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1621 nb_frames_dup, nb_frames_drop);
1623 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1627 if (is_last_report) {
1628 int64_t raw= audio_size + video_size + extra_size;
1629 av_log(NULL, AV_LOG_INFO, "\n");
1630 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1631 video_size / 1024.0,
1632 audio_size / 1024.0,
1633 extra_size / 1024.0,
1634 100.0 * (total_size - raw) / raw
1639 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1643 for (i = 0; i < nb_ostreams; i++) {
1644 OutputStream *ost = &ost_table[i];
1645 AVCodecContext *enc = ost->st->codec;
1646 AVFormatContext *os = output_files[ost->file_index].ctx;
1647 int stop_encoding = 0;
1649 if (!ost->encoding_needed)
1652 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1654 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1660 av_init_packet(&pkt);
1664 switch (ost->st->codec->codec_type) {
1665 case AVMEDIA_TYPE_AUDIO:
1666 fifo_bytes = av_fifo_size(ost->fifo);
1667 if (fifo_bytes > 0) {
1668 /* encode any samples remaining in fifo */
1669 int frame_bytes = fifo_bytes;
1671 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1673 /* pad last frame with silence if needed */
1674 if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
1675 frame_bytes = enc->frame_size * enc->channels *
1676 av_get_bytes_per_sample(enc->sample_fmt);
1677 if (allocated_audio_buf_size < frame_bytes)
1679 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1681 encode_audio_frame(os, ost, audio_buf, frame_bytes);
1683 /* flush encoder with NULL frames until it is done
1684 returning packets */
1685 if (encode_audio_frame(os, ost, NULL, 0) == 0) {
1691 case AVMEDIA_TYPE_VIDEO:
1692 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1694 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1698 if (enc->coded_frame && enc->coded_frame->key_frame)
1699 pkt.flags |= AV_PKT_FLAG_KEY;
1700 if (ost->logfile && enc->stats_out) {
1701 fprintf(ost->logfile, "%s", enc->stats_out);
1707 pkt.stream_index = ost->index;
1708 pkt.data = bit_buffer;
1710 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1711 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1712 write_frame(os, &pkt, ost);
1724 * Check whether a packet from ist should be written into ost at this time
1726 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1728 OutputFile *of = &output_files[ost->file_index];
1729 int ist_index = ist - input_streams;
1731 if (ost->source_index != ist_index)
1734 if (of->start_time && ist->pts < of->start_time)
1737 if (of->recording_time != INT64_MAX &&
1738 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1739 (AVRational){ 1, 1000000 }) >= 0) {
1740 ost->is_past_recording_time = 1;
1747 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1749 OutputFile *of = &output_files[ost->file_index];
1750 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1753 av_init_packet(&opkt);
1755 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1756 !ost->copy_initial_nonkeyframes)
1759 /* force the input stream PTS */
1760 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1761 audio_size += pkt->size;
1762 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1763 video_size += pkt->size;
1767 opkt.stream_index = ost->index;
1768 if (pkt->pts != AV_NOPTS_VALUE)
1769 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1771 opkt.pts = AV_NOPTS_VALUE;
1773 if (pkt->dts == AV_NOPTS_VALUE)
1774 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1776 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1777 opkt.dts -= ost_tb_start_time;
1779 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1780 opkt.flags = pkt->flags;
1782 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1783 if ( ost->st->codec->codec_id != CODEC_ID_H264
1784 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1785 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1787 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1788 opkt.destruct = av_destruct_packet;
1790 opkt.data = pkt->data;
1791 opkt.size = pkt->size;
1794 write_frame(of->ctx, &opkt, ost);
1795 ost->st->codec->frame_number++;
1796 av_free_packet(&opkt);
1799 static void rate_emu_sleep(InputStream *ist)
1801 if (input_files[ist->file_index].rate_emu) {
1802 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1803 int64_t now = av_gettime() - ist->start;
1809 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1811 AVFrame *decoded_frame;
1812 AVCodecContext *avctx = ist->st->codec;
1813 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1816 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1817 return AVERROR(ENOMEM);
1819 avcodec_get_frame_defaults(ist->decoded_frame);
1820 decoded_frame = ist->decoded_frame;
1822 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1828 /* no audio frame */
1832 /* if the decoder provides a pts, use it instead of the last packet pts.
1833 the decoder could be delaying output by a packet or more. */
1834 if (decoded_frame->pts != AV_NOPTS_VALUE)
1835 ist->next_pts = decoded_frame->pts;
1837 /* increment next_pts to use for the case where the input stream does not
1838 have timestamps or there are multiple frames in the packet */
1839 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1842 // preprocess audio (volume)
1843 if (audio_volume != 256) {
1844 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1845 void *samples = decoded_frame->data[0];
1846 switch (avctx->sample_fmt) {
1847 case AV_SAMPLE_FMT_U8:
1849 uint8_t *volp = samples;
1850 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1851 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1852 *volp++ = av_clip_uint8(v);
1856 case AV_SAMPLE_FMT_S16:
1858 int16_t *volp = samples;
1859 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1860 int v = ((*volp) * audio_volume + 128) >> 8;
1861 *volp++ = av_clip_int16(v);
1865 case AV_SAMPLE_FMT_S32:
1867 int32_t *volp = samples;
1868 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1869 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1870 *volp++ = av_clipl_int32(v);
1874 case AV_SAMPLE_FMT_FLT:
1876 float *volp = samples;
1877 float scale = audio_volume / 256.f;
1878 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1883 case AV_SAMPLE_FMT_DBL:
1885 double *volp = samples;
1886 double scale = audio_volume / 256.;
1887 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1893 av_log(NULL, AV_LOG_FATAL,
1894 "Audio volume adjustment on sample format %s is not supported.\n",
1895 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1900 rate_emu_sleep(ist);
1902 for (i = 0; i < nb_output_streams; i++) {
1903 OutputStream *ost = &output_streams[i];
1905 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1907 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
1913 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
1915 AVFrame *decoded_frame, *filtered_frame = NULL;
1916 void *buffer_to_free = NULL;
1920 int frame_available = 1;
1923 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1924 return AVERROR(ENOMEM);
1926 avcodec_get_frame_defaults(ist->decoded_frame);
1927 decoded_frame = ist->decoded_frame;
1928 pkt->pts = *pkt_pts;
1929 pkt->dts = ist->pts;
1930 *pkt_pts = AV_NOPTS_VALUE;
1932 ret = avcodec_decode_video2(ist->st->codec,
1933 decoded_frame, got_output, pkt);
1937 quality = same_quant ? decoded_frame->quality : 0;
1939 /* no picture yet */
1942 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1943 decoded_frame->pkt_dts);
1945 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
1946 else if (ist->st->codec->time_base.num != 0) {
1947 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1948 ist->st->codec->ticks_per_frame;
1949 ist->next_pts += ((int64_t)AV_TIME_BASE *
1950 ist->st->codec->time_base.num * ticks) /
1951 ist->st->codec->time_base.den;
1954 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1956 rate_emu_sleep(ist);
1958 for (i = 0; i < nb_output_streams; i++) {
1959 OutputStream *ost = &output_streams[i];
1960 int frame_size, resample_changed;
1962 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1966 resample_changed = ost->resample_width != decoded_frame->width ||
1967 ost->resample_height != decoded_frame->height ||
1968 ost->resample_pix_fmt != decoded_frame->format;
1969 if (resample_changed) {
1970 av_log(NULL, AV_LOG_INFO,
1971 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1972 ist->file_index, ist->st->index,
1973 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1974 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
1976 avfilter_graph_free(&ost->graph);
1977 if (configure_video_filters(ist, ost)) {
1978 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1982 ost->resample_width = decoded_frame->width;
1983 ost->resample_height = decoded_frame->height;
1984 ost->resample_pix_fmt = decoded_frame->format;
1987 if (ist->st->sample_aspect_ratio.num)
1988 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1989 if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
1990 FrameBuffer *buf = decoded_frame->opaque;
1991 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
1992 decoded_frame->data, decoded_frame->linesize,
1993 AV_PERM_READ | AV_PERM_PRESERVE,
1994 ist->st->codec->width, ist->st->codec->height,
1995 ist->st->codec->pix_fmt);
1997 avfilter_copy_frame_props(fb, decoded_frame);
1999 fb->buf->priv = buf;
2000 fb->buf->free = filter_release_buffer;
2003 av_buffersrc_buffer(ost->input_video_filter, fb);
2005 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame,
2006 ist->pts, decoded_frame->sample_aspect_ratio);
2008 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2009 av_free(buffer_to_free);
2010 return AVERROR(ENOMEM);
2012 avcodec_get_frame_defaults(ist->filtered_frame);
2013 filtered_frame = ist->filtered_frame;
2015 frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2016 while (frame_available) {
2017 AVRational ist_pts_tb;
2018 if (ost->output_video_filter)
2019 get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
2021 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2022 if (ost->picref->video && !ost->frame_aspect_ratio)
2023 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
2025 filtered_frame = decoded_frame;
2028 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
2029 same_quant ? quality : ost->st->codec->global_quality);
2030 if (vstats_filename && frame_size)
2031 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
2033 frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2035 avfilter_unref_buffer(ost->picref);
2040 av_free(buffer_to_free);
2044 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2046 AVSubtitle subtitle;
2047 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2048 &subtitle, got_output, pkt);
2054 rate_emu_sleep(ist);
2056 for (i = 0; i < nb_output_streams; i++) {
2057 OutputStream *ost = &output_streams[i];
2059 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2062 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2065 avsubtitle_free(&subtitle);
2069 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2070 static int output_packet(InputStream *ist,
2071 OutputStream *ost_table, int nb_ostreams,
2072 const AVPacket *pkt)
2076 int64_t pkt_pts = AV_NOPTS_VALUE;
2079 if (ist->next_pts == AV_NOPTS_VALUE)
2080 ist->next_pts = ist->pts;
2084 av_init_packet(&avpkt);
2092 if (pkt->dts != AV_NOPTS_VALUE)
2093 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2094 if (pkt->pts != AV_NOPTS_VALUE)
2095 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2097 // while we have more to decode or while the decoder did output something on EOF
2098 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2102 ist->pts = ist->next_pts;
2104 if (avpkt.size && avpkt.size != pkt->size) {
2105 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2106 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2107 ist->showed_multi_packet_warning = 1;
2110 switch (ist->st->codec->codec_type) {
2111 case AVMEDIA_TYPE_AUDIO:
2112 ret = transcode_audio (ist, &avpkt, &got_output);
2114 case AVMEDIA_TYPE_VIDEO:
2115 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
2117 case AVMEDIA_TYPE_SUBTITLE:
2118 ret = transcode_subtitles(ist, &avpkt, &got_output);
2126 // touch data and size only if not EOF
2136 /* handle stream copy */
2137 if (!ist->decoding_needed) {
2138 rate_emu_sleep(ist);
2139 ist->pts = ist->next_pts;
2140 switch (ist->st->codec->codec_type) {
2141 case AVMEDIA_TYPE_AUDIO:
2142 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2143 ist->st->codec->sample_rate;
2145 case AVMEDIA_TYPE_VIDEO:
2146 if (ist->st->codec->time_base.num != 0) {
2147 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2148 ist->next_pts += ((int64_t)AV_TIME_BASE *
2149 ist->st->codec->time_base.num * ticks) /
2150 ist->st->codec->time_base.den;
2155 for (i = 0; pkt && i < nb_ostreams; i++) {
2156 OutputStream *ost = &ost_table[i];
2158 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2161 do_streamcopy(ist, ost, pkt);
2167 static void print_sdp(OutputFile *output_files, int n)
2171 AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2175 for (i = 0; i < n; i++)
2176 avc[i] = output_files[i].ctx;
2178 av_sdp_create(avc, n, sdp, sizeof(sdp));
2179 printf("SDP:\n%s\n", sdp);
2184 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2185 char *error, int error_len)
2188 InputStream *ist = &input_streams[ist_index];
2189 if (ist->decoding_needed) {
2190 AVCodec *codec = ist->dec;
2192 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
2193 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2194 return AVERROR(EINVAL);
2197 /* update requested sample format for the decoder based on the
2198 corresponding encoder sample format */
2199 for (i = 0; i < nb_output_streams; i++) {
2200 OutputStream *ost = &output_streams[i];
2201 if (ost->source_index == ist_index) {
2202 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
2207 if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
2208 ist->st->codec->get_buffer = codec_get_buffer;
2209 ist->st->codec->release_buffer = codec_release_buffer;
2210 ist->st->codec->opaque = ist;
2213 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2214 av_dict_set(&ist->opts, "threads", "auto", 0);
2215 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2216 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2217 ist->file_index, ist->st->index);
2218 return AVERROR(EINVAL);
2220 assert_codec_experimental(ist->st->codec, 0);
2221 assert_avoptions(ist->opts);
2224 ist->pts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
2225 ist->next_pts = AV_NOPTS_VALUE;
2226 init_pts_correction(&ist->pts_ctx);
2232 static int transcode_init(OutputFile *output_files,
2233 int nb_output_files,
2234 InputFile *input_files,
2237 int ret = 0, i, j, k;
2238 AVFormatContext *oc;
2239 AVCodecContext *codec, *icodec;
2245 /* init framerate emulation */
2246 for (i = 0; i < nb_input_files; i++) {
2247 InputFile *ifile = &input_files[i];
2248 if (ifile->rate_emu)
2249 for (j = 0; j < ifile->nb_streams; j++)
2250 input_streams[j + ifile->ist_index].start = av_gettime();
2253 /* output stream init */
2254 for (i = 0; i < nb_output_files; i++) {
2255 oc = output_files[i].ctx;
2256 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2257 av_dump_format(oc, i, oc->filename, 1);
2258 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2259 return AVERROR(EINVAL);
2263 /* for each output stream, we compute the right encoding parameters */
2264 for (i = 0; i < nb_output_streams; i++) {
2265 ost = &output_streams[i];
2266 oc = output_files[ost->file_index].ctx;
2267 ist = &input_streams[ost->source_index];
2269 if (ost->attachment_filename)
2272 codec = ost->st->codec;
2273 icodec = ist->st->codec;
2275 ost->st->disposition = ist->st->disposition;
2276 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2277 codec->chroma_sample_location = icodec->chroma_sample_location;
2279 if (ost->stream_copy) {
2280 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2282 if (extra_size > INT_MAX) {
2283 return AVERROR(EINVAL);
2286 /* if stream_copy is selected, no need to decode or encode */
2287 codec->codec_id = icodec->codec_id;
2288 codec->codec_type = icodec->codec_type;
2290 if (!codec->codec_tag) {
2291 if (!oc->oformat->codec_tag ||
2292 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2293 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2294 codec->codec_tag = icodec->codec_tag;
2297 codec->bit_rate = icodec->bit_rate;
2298 codec->rc_max_rate = icodec->rc_max_rate;
2299 codec->rc_buffer_size = icodec->rc_buffer_size;
2300 codec->field_order = icodec->field_order;
2301 codec->extradata = av_mallocz(extra_size);
2302 if (!codec->extradata) {
2303 return AVERROR(ENOMEM);
2305 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2306 codec->extradata_size = icodec->extradata_size;
2308 codec->time_base = icodec->time_base;
2309 codec->time_base.num *= icodec->ticks_per_frame;
2310 av_reduce(&codec->time_base.num, &codec->time_base.den,
2311 codec->time_base.num, codec->time_base.den, INT_MAX);
2313 codec->time_base = ist->st->time_base;
2315 switch (codec->codec_type) {
2316 case AVMEDIA_TYPE_AUDIO:
2317 if (audio_volume != 256) {
2318 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2321 codec->channel_layout = icodec->channel_layout;
2322 codec->sample_rate = icodec->sample_rate;
2323 codec->channels = icodec->channels;
2324 codec->frame_size = icodec->frame_size;
2325 codec->audio_service_type = icodec->audio_service_type;
2326 codec->block_align = icodec->block_align;
2328 case AVMEDIA_TYPE_VIDEO:
2329 codec->pix_fmt = icodec->pix_fmt;
2330 codec->width = icodec->width;
2331 codec->height = icodec->height;
2332 codec->has_b_frames = icodec->has_b_frames;
2333 if (!codec->sample_aspect_ratio.num) {
2334 codec->sample_aspect_ratio =
2335 ost->st->sample_aspect_ratio =
2336 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2337 ist->st->codec->sample_aspect_ratio.num ?
2338 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2341 case AVMEDIA_TYPE_SUBTITLE:
2342 codec->width = icodec->width;
2343 codec->height = icodec->height;
2345 case AVMEDIA_TYPE_DATA:
2346 case AVMEDIA_TYPE_ATTACHMENT:
2353 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2355 ist->decoding_needed = 1;
2356 ost->encoding_needed = 1;
2358 switch (codec->codec_type) {
2359 case AVMEDIA_TYPE_AUDIO:
2360 ost->fifo = av_fifo_alloc(1024);
2362 return AVERROR(ENOMEM);
2364 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2366 if (!codec->sample_rate)
2367 codec->sample_rate = icodec->sample_rate;
2368 choose_sample_rate(ost->st, ost->enc);
2369 codec->time_base = (AVRational){ 1, codec->sample_rate };
2371 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2372 codec->sample_fmt = icodec->sample_fmt;
2373 choose_sample_fmt(ost->st, ost->enc);
2375 if (!codec->channels)
2376 codec->channels = icodec->channels;
2377 codec->channel_layout = icodec->channel_layout;
2378 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2379 codec->channel_layout = 0;
2381 ost->audio_resample = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2382 icodec->request_channels = codec-> channels;
2383 ost->resample_sample_fmt = icodec->sample_fmt;
2384 ost->resample_sample_rate = icodec->sample_rate;
2385 ost->resample_channels = icodec->channels;
2387 case AVMEDIA_TYPE_VIDEO:
2388 if (codec->pix_fmt == PIX_FMT_NONE)
2389 codec->pix_fmt = icodec->pix_fmt;
2390 choose_pixel_fmt(ost->st, ost->enc);
2392 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2393 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2397 if (!codec->width || !codec->height) {
2398 codec->width = icodec->width;
2399 codec->height = icodec->height;
2402 ost->video_resample = codec->width != icodec->width ||
2403 codec->height != icodec->height ||
2404 codec->pix_fmt != icodec->pix_fmt;
2405 if (ost->video_resample) {
2406 #if !CONFIG_AVFILTER
2407 avcodec_get_frame_defaults(&ost->pict_tmp);
2408 if (avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2409 codec->width, codec->height)) {
2410 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2413 ost->img_resample_ctx = sws_getContext(
2420 ost->sws_flags, NULL, NULL, NULL);
2421 if (ost->img_resample_ctx == NULL) {
2422 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2426 codec->bits_per_raw_sample = 0;
2429 ost->resample_height = icodec->height;
2430 ost->resample_width = icodec->width;
2431 ost->resample_pix_fmt = icodec->pix_fmt;
2433 if (!ost->frame_rate.num)
2434 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2435 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2436 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2437 ost->frame_rate = ost->enc->supported_framerates[idx];
2439 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2442 if (configure_video_filters(ist, ost)) {
2443 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2448 case AVMEDIA_TYPE_SUBTITLE:
2455 if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2456 char logfilename[1024];
2459 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2460 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2462 if (codec->flags & CODEC_FLAG_PASS1) {
2463 f = fopen(logfilename, "wb");
2465 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2466 logfilename, strerror(errno));
2472 size_t logbuffer_size;
2473 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2474 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2478 codec->stats_in = logbuffer;
2482 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2483 int size = codec->width * codec->height;
2484 bit_buffer_size = FFMAX(bit_buffer_size, 6 * size + 200);
2489 bit_buffer = av_malloc(bit_buffer_size);
2491 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2493 return AVERROR(ENOMEM);
2496 /* open each encoder */
2497 for (i = 0; i < nb_output_streams; i++) {
2498 ost = &output_streams[i];
2499 if (ost->encoding_needed) {
2500 AVCodec *codec = ost->enc;
2501 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2503 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2504 ost->st->codec->codec_id, ost->file_index, ost->index);
2505 ret = AVERROR(EINVAL);
2508 if (dec->subtitle_header) {
2509 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2510 if (!ost->st->codec->subtitle_header) {
2511 ret = AVERROR(ENOMEM);
2514 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2515 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2517 if (!av_dict_get(ost->opts, "threads", NULL, 0))
2518 av_dict_set(&ost->opts, "threads", "auto", 0);
2519 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2520 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2521 ost->file_index, ost->index);
2522 ret = AVERROR(EINVAL);
2525 assert_codec_experimental(ost->st->codec, 1);
2526 assert_avoptions(ost->opts);
2527 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2528 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2529 "It takes bits/s as argument, not kbits/s\n");
2530 extra_size += ost->st->codec->extradata_size;
2532 if (ost->st->codec->me_threshold)
2533 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2537 /* init input streams */
2538 for (i = 0; i < nb_input_streams; i++)
2539 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2542 /* discard unused programs */
2543 for (i = 0; i < nb_input_files; i++) {
2544 InputFile *ifile = &input_files[i];
2545 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2546 AVProgram *p = ifile->ctx->programs[j];
2547 int discard = AVDISCARD_ALL;
2549 for (k = 0; k < p->nb_stream_indexes; k++)
2550 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2551 discard = AVDISCARD_DEFAULT;
2554 p->discard = discard;
2558 /* open files and write file headers */
2559 for (i = 0; i < nb_output_files; i++) {
2560 oc = output_files[i].ctx;
2561 oc->interrupt_callback = int_cb;
2562 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2563 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2564 ret = AVERROR(EINVAL);
2567 assert_avoptions(output_files[i].opts);
2568 if (strcmp(oc->oformat->name, "rtp")) {
2574 /* dump the file output parameters - cannot be done before in case
2576 for (i = 0; i < nb_output_files; i++) {
2577 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2580 /* dump the stream mapping */
2581 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2582 for (i = 0; i < nb_output_streams; i++) {
2583 ost = &output_streams[i];
2585 if (ost->attachment_filename) {
2586 /* an attached file */
2587 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2588 ost->attachment_filename, ost->file_index, ost->index);
2591 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2592 input_streams[ost->source_index].file_index,
2593 input_streams[ost->source_index].st->index,
2596 if (ost->sync_ist != &input_streams[ost->source_index])
2597 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2598 ost->sync_ist->file_index,
2599 ost->sync_ist->st->index);
2600 if (ost->stream_copy)
2601 av_log(NULL, AV_LOG_INFO, " (copy)");
2603 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2604 input_streams[ost->source_index].dec->name : "?",
2605 ost->enc ? ost->enc->name : "?");
2606 av_log(NULL, AV_LOG_INFO, "\n");
2610 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2615 print_sdp(output_files, nb_output_files);
2622 * The following code is the main loop of the file converter
2624 static int transcode(OutputFile *output_files,
2625 int nb_output_files,
2626 InputFile *input_files,
2630 AVFormatContext *is, *os;
2634 int no_packet_count = 0;
2635 int64_t timer_start;
2637 if (!(no_packet = av_mallocz(nb_input_files)))
2640 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2644 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2647 timer_start = av_gettime();
2649 for (; received_sigterm == 0;) {
2650 int file_index, ist_index;
2655 ipts_min = INT64_MAX;
2658 /* select the stream that we must read now by looking at the
2659 smallest output pts */
2661 for (i = 0; i < nb_output_streams; i++) {
2665 ost = &output_streams[i];
2666 of = &output_files[ost->file_index];
2667 os = output_files[ost->file_index].ctx;
2668 ist = &input_streams[ost->source_index];
2669 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2670 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2672 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2674 if (!input_files[ist->file_index].eof_reached) {
2675 if (ipts < ipts_min) {
2678 file_index = ist->file_index;
2680 if (opts < opts_min) {
2682 if (!input_sync) file_index = ist->file_index;
2685 if (ost->frame_number >= ost->max_frames) {
2687 for (j = 0; j < of->ctx->nb_streams; j++)
2688 output_streams[of->ost_index + j].is_past_recording_time = 1;
2692 /* if none, if is finished */
2693 if (file_index < 0) {
2694 if (no_packet_count) {
2695 no_packet_count = 0;
2696 memset(no_packet, 0, nb_input_files);
2703 /* read a frame from it and output it in the fifo */
2704 is = input_files[file_index].ctx;
2705 ret = av_read_frame(is, &pkt);
2706 if (ret == AVERROR(EAGAIN)) {
2707 no_packet[file_index] = 1;
2712 input_files[file_index].eof_reached = 1;
2719 no_packet_count = 0;
2720 memset(no_packet, 0, nb_input_files);
2723 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2724 is->streams[pkt.stream_index]);
2726 /* the following test is needed in case new streams appear
2727 dynamically in stream : we ignore them */
2728 if (pkt.stream_index >= input_files[file_index].nb_streams)
2729 goto discard_packet;
2730 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2731 ist = &input_streams[ist_index];
2733 goto discard_packet;
2735 if (pkt.dts != AV_NOPTS_VALUE)
2736 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2737 if (pkt.pts != AV_NOPTS_VALUE)
2738 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2740 if (pkt.pts != AV_NOPTS_VALUE)
2741 pkt.pts *= ist->ts_scale;
2742 if (pkt.dts != AV_NOPTS_VALUE)
2743 pkt.dts *= ist->ts_scale;
2745 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
2747 // pkt.dts, input_files[ist->file_index].ts_offset,
2748 // ist->st->codec->codec_type);
2749 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2750 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2751 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2752 int64_t delta = pkt_dts - ist->next_pts;
2753 if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->pts) && !copy_ts) {
2754 input_files[ist->file_index].ts_offset -= delta;
2755 av_log(NULL, AV_LOG_DEBUG,
2756 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2757 delta, input_files[ist->file_index].ts_offset);
2758 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2759 if (pkt.pts != AV_NOPTS_VALUE)
2760 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2764 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2765 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2767 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2768 ist->file_index, ist->st->index);
2771 av_free_packet(&pkt);
2776 av_free_packet(&pkt);
2778 /* dump report by using the output first video and audio streams */
2779 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2782 /* at the end of stream, we must flush the decoder buffers */
2783 for (i = 0; i < nb_input_streams; i++) {
2784 ist = &input_streams[i];
2785 if (ist->decoding_needed) {
2786 output_packet(ist, output_streams, nb_output_streams, NULL);
2789 flush_encoders(output_streams, nb_output_streams);
2793 /* write the trailer if needed and close file */
2794 for (i = 0; i < nb_output_files; i++) {
2795 os = output_files[i].ctx;
2796 av_write_trailer(os);
2799 /* dump report by using the first video and audio streams */
2800 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2802 /* close each encoder */
2803 for (i = 0; i < nb_output_streams; i++) {
2804 ost = &output_streams[i];
2805 if (ost->encoding_needed) {
2806 av_freep(&ost->st->codec->stats_in);
2807 avcodec_close(ost->st->codec);
2810 avfilter_graph_free(&ost->graph);
2814 /* close each decoder */
2815 for (i = 0; i < nb_input_streams; i++) {
2816 ist = &input_streams[i];
2817 if (ist->decoding_needed) {
2818 avcodec_close(ist->st->codec);
2826 av_freep(&bit_buffer);
2827 av_freep(&no_packet);
2829 if (output_streams) {
2830 for (i = 0; i < nb_output_streams; i++) {
2831 ost = &output_streams[i];
2833 if (ost->stream_copy)
2834 av_freep(&ost->st->codec->extradata);
2836 fclose(ost->logfile);
2837 ost->logfile = NULL;
2839 av_fifo_free(ost->fifo); /* works even if fifo is not
2840 initialized but set to zero */
2841 av_freep(&ost->st->codec->subtitle_header);
2842 av_free(ost->pict_tmp.data[0]);
2843 av_free(ost->forced_kf_pts);
2844 if (ost->video_resample)
2845 sws_freeContext(ost->img_resample_ctx);
2847 audio_resample_close(ost->resample);
2848 if (ost->reformat_ctx)
2849 av_audio_convert_free(ost->reformat_ctx);
2850 av_dict_free(&ost->opts);
2857 static double parse_frame_aspect_ratio(const char *arg)
2864 p = strchr(arg, ':');
2866 x = strtol(arg, &end, 10);
2868 y = strtol(end + 1, &end, 10);
2870 ar = (double)x / (double)y;
2872 ar = strtod(arg, NULL);
2875 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2881 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2883 return parse_option(o, "codec:a", arg, options);
2886 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2888 return parse_option(o, "codec:v", arg, options);
2891 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2893 return parse_option(o, "codec:s", arg, options);
2896 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2898 return parse_option(o, "codec:d", arg, options);
2901 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2903 StreamMap *m = NULL;
2904 int i, negative = 0, file_idx;
2905 int sync_file_idx = -1, sync_stream_idx;
2913 map = av_strdup(arg);
2915 /* parse sync stream first, just pick first matching stream */
2916 if (sync = strchr(map, ',')) {
2918 sync_file_idx = strtol(sync + 1, &sync, 0);
2919 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2920 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2925 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2926 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2927 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2928 sync_stream_idx = i;
2931 if (i == input_files[sync_file_idx].nb_streams) {
2932 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2933 "match any streams.\n", arg);
2939 file_idx = strtol(map, &p, 0);
2940 if (file_idx >= nb_input_files || file_idx < 0) {
2941 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2945 /* disable some already defined maps */
2946 for (i = 0; i < o->nb_stream_maps; i++) {
2947 m = &o->stream_maps[i];
2948 if (file_idx == m->file_index &&
2949 check_stream_specifier(input_files[m->file_index].ctx,
2950 input_files[m->file_index].ctx->streams[m->stream_index],
2951 *p == ':' ? p + 1 : p) > 0)
2955 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2956 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2957 *p == ':' ? p + 1 : p) <= 0)
2959 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2960 &o->nb_stream_maps, o->nb_stream_maps + 1);
2961 m = &o->stream_maps[o->nb_stream_maps - 1];
2963 m->file_index = file_idx;
2964 m->stream_index = i;
2966 if (sync_file_idx >= 0) {
2967 m->sync_file_index = sync_file_idx;
2968 m->sync_stream_index = sync_stream_idx;
2970 m->sync_file_index = file_idx;
2971 m->sync_stream_index = i;
2976 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2984 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
2986 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
2987 &o->nb_attachments, o->nb_attachments + 1);
2988 o->attachments[o->nb_attachments - 1] = arg;
2993 * Parse a metadata specifier in arg.
2994 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
2995 * @param index for type c/p, chapter/program index is written here
2996 * @param stream_spec for type s, the stream specifier is written here
2998 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3006 if (*(++arg) && *arg != ':') {
3007 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3010 *stream_spec = *arg == ':' ? arg + 1 : "";
3014 if (*(++arg) == ':')
3015 *index = strtol(++arg, NULL, 0);
3018 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3025 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3027 AVDictionary **meta_in = NULL;
3028 AVDictionary **meta_out;
3030 char type_in, type_out;
3031 const char *istream_spec = NULL, *ostream_spec = NULL;
3032 int idx_in = 0, idx_out = 0;
3034 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3035 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3037 if (type_in == 'g' || type_out == 'g')
3038 o->metadata_global_manual = 1;
3039 if (type_in == 's' || type_out == 's')
3040 o->metadata_streams_manual = 1;
3041 if (type_in == 'c' || type_out == 'c')
3042 o->metadata_chapters_manual = 1;
3044 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3045 if ((index) < 0 || (index) >= (nb_elems)) {\
3046 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3051 #define SET_DICT(type, meta, context, index)\
3054 meta = &context->metadata;\
3057 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3058 meta = &context->chapters[index]->metadata;\
3061 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3062 meta = &context->programs[index]->metadata;\
3066 SET_DICT(type_in, meta_in, ic, idx_in);
3067 SET_DICT(type_out, meta_out, oc, idx_out);
3069 /* for input streams choose first matching stream */
3070 if (type_in == 's') {
3071 for (i = 0; i < ic->nb_streams; i++) {
3072 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3073 meta_in = &ic->streams[i]->metadata;
3079 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3084 if (type_out == 's') {
3085 for (i = 0; i < oc->nb_streams; i++) {
3086 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3087 meta_out = &oc->streams[i]->metadata;
3088 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3093 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3098 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3100 const char *codec_string = encoder ? "encoder" : "decoder";
3104 avcodec_find_encoder_by_name(name) :
3105 avcodec_find_decoder_by_name(name);
3107 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3110 if (codec->type != type) {
3111 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3117 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3119 char *codec_name = NULL;
3121 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3123 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3124 st->codec->codec_id = codec->id;
3127 return avcodec_find_decoder(st->codec->codec_id);
3131 * Add all the streams from the given input file to the global
3132 * list of input streams.
3134 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3138 for (i = 0; i < ic->nb_streams; i++) {
3139 AVStream *st = ic->streams[i];
3140 AVCodecContext *dec = st->codec;
3143 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3144 ist = &input_streams[nb_input_streams - 1];
3146 ist->file_index = nb_input_files;
3148 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3150 ist->ts_scale = 1.0;
3151 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3153 ist->dec = choose_decoder(o, ic, st);
3155 switch (dec->codec_type) {
3156 case AVMEDIA_TYPE_AUDIO:
3157 if (o->audio_disable)
3158 st->discard = AVDISCARD_ALL;
3160 case AVMEDIA_TYPE_VIDEO:
3162 dec->flags |= CODEC_FLAG_EMU_EDGE;
3163 dec->height >>= dec->lowres;
3164 dec->width >>= dec->lowres;
3167 if (o->video_disable)
3168 st->discard = AVDISCARD_ALL;
3169 else if (video_discard)
3170 st->discard = video_discard;
3172 case AVMEDIA_TYPE_DATA:
3174 case AVMEDIA_TYPE_SUBTITLE:
3175 if (o->subtitle_disable)
3176 st->discard = AVDISCARD_ALL;
3178 case AVMEDIA_TYPE_ATTACHMENT:
3179 case AVMEDIA_TYPE_UNKNOWN:
3187 static void assert_file_overwrite(const char *filename)
3189 if (!file_overwrite &&
3190 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3191 av_strstart(filename, "file:", NULL))) {
3192 if (avio_check(filename, 0) == 0) {
3194 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3196 if (!read_yesno()) {
3197 fprintf(stderr, "Not overwriting - exiting\n");
3202 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3209 static void dump_attachment(AVStream *st, const char *filename)
3212 AVIOContext *out = NULL;
3213 AVDictionaryEntry *e;
3215 if (!st->codec->extradata_size) {
3216 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3217 nb_input_files - 1, st->index);
3220 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3221 filename = e->value;
3223 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3224 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3228 assert_file_overwrite(filename);
3230 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3231 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3236 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3241 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3243 AVFormatContext *ic;
3244 AVInputFormat *file_iformat = NULL;
3248 AVDictionary **opts;
3249 int orig_nb_streams; // number of streams before avformat_find_stream_info
3252 if (!(file_iformat = av_find_input_format(o->format))) {
3253 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3258 if (!strcmp(filename, "-"))
3261 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3262 !strcmp(filename, "/dev/stdin");
3264 /* get default parameters from command line */
3265 ic = avformat_alloc_context();
3267 print_error(filename, AVERROR(ENOMEM));
3270 if (o->nb_audio_sample_rate) {
3271 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3272 av_dict_set(&format_opts, "sample_rate", buf, 0);
3274 if (o->nb_audio_channels) {
3275 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3276 av_dict_set(&format_opts, "channels", buf, 0);
3278 if (o->nb_frame_rates) {
3279 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3281 if (o->nb_frame_sizes) {
3282 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3284 if (o->nb_frame_pix_fmts)
3285 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3287 ic->flags |= AVFMT_FLAG_NONBLOCK;
3288 ic->interrupt_callback = int_cb;
3290 /* open the input file with generic libav function */
3291 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3293 print_error(filename, err);
3296 assert_avoptions(format_opts);
3298 /* apply forced codec ids */
3299 for (i = 0; i < ic->nb_streams; i++)
3300 choose_decoder(o, ic, ic->streams[i]);
3302 /* Set AVCodecContext options for avformat_find_stream_info */
3303 opts = setup_find_stream_info_opts(ic, codec_opts);
3304 orig_nb_streams = ic->nb_streams;
3306 /* If not enough info to get the stream parameters, we decode the
3307 first frames to get it. (used in mpeg case for example) */
3308 ret = avformat_find_stream_info(ic, opts);
3310 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3311 avformat_close_input(&ic);
3315 timestamp = o->start_time;
3316 /* add the stream start time */
3317 if (ic->start_time != AV_NOPTS_VALUE)
3318 timestamp += ic->start_time;
3320 /* if seeking requested, we execute it */
3321 if (o->start_time != 0) {
3322 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3324 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3325 filename, (double)timestamp / AV_TIME_BASE);
3329 /* update the current parameters so that they match the one of the input stream */
3330 add_input_streams(o, ic);
3332 /* dump the file content */
3333 av_dump_format(ic, nb_input_files, filename, 0);
3335 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3336 input_files[nb_input_files - 1].ctx = ic;
3337 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3338 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3339 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3340 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3342 for (i = 0; i < o->nb_dump_attachment; i++) {
3345 for (j = 0; j < ic->nb_streams; j++) {
3346 AVStream *st = ic->streams[j];
3348 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3349 dump_attachment(st, o->dump_attachment[i].u.str);
3353 for (i = 0; i < orig_nb_streams; i++)
3354 av_dict_free(&opts[i]);
3361 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3362 AVCodecContext *avctx)
3368 for (p = kf; *p; p++)
3371 ost->forced_kf_count = n;
3372 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3373 if (!ost->forced_kf_pts) {
3374 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3377 for (i = 0; i < n; i++) {
3378 p = i ? strchr(p, ',') + 1 : kf;
3379 t = parse_time_or_die("force_key_frames", p, 1);
3380 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3384 static uint8_t *get_line(AVIOContext *s)
3390 if (avio_open_dyn_buf(&line) < 0) {
3391 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3395 while ((c = avio_r8(s)) && c != '\n')
3398 avio_close_dyn_buf(line, &buf);
3403 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3406 char filename[1000];
3407 const char *base[3] = { getenv("AVCONV_DATADIR"),
3412 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3416 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3417 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3418 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3421 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3422 i != 1 ? "" : "/.avconv", preset_name);
3423 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3429 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3431 char *codec_name = NULL;
3433 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3435 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3436 NULL, ost->st->codec->codec_type);
3437 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3438 } else if (!strcmp(codec_name, "copy"))
3439 ost->stream_copy = 1;
3441 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3442 ost->st->codec->codec_id = ost->enc->id;
3446 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3449 AVStream *st = avformat_new_stream(oc, NULL);
3450 int idx = oc->nb_streams - 1, ret = 0;
3451 char *bsf = NULL, *next, *codec_tag = NULL;
3452 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3454 char *buf = NULL, *arg = NULL, *preset = NULL;
3455 AVIOContext *s = NULL;
3458 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3462 if (oc->nb_streams - 1 < o->nb_streamid_map)
3463 st->id = o->streamid_map[oc->nb_streams - 1];
3465 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3466 nb_output_streams + 1);
3467 ost = &output_streams[nb_output_streams - 1];
3468 ost->file_index = nb_output_files;
3471 st->codec->codec_type = type;
3472 choose_encoder(o, oc, ost);
3474 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3477 avcodec_get_context_defaults3(st->codec, ost->enc);
3478 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3480 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3481 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3484 if (!buf[0] || buf[0] == '#') {
3488 if (!(arg = strchr(buf, '='))) {
3489 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3493 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3495 } while (!s->eof_reached);
3499 av_log(NULL, AV_LOG_FATAL,
3500 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3501 preset, ost->file_index, ost->index);
3505 ost->max_frames = INT64_MAX;
3506 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3508 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3510 if (next = strchr(bsf, ','))
3512 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3513 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3517 bsfc_prev->next = bsfc;
3519 ost->bitstream_filters = bsfc;
3525 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3527 uint32_t tag = strtol(codec_tag, &next, 0);
3529 tag = AV_RL32(codec_tag);
3530 st->codec->codec_tag = tag;
3533 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3534 if (qscale >= 0 || same_quant) {
3535 st->codec->flags |= CODEC_FLAG_QSCALE;
3536 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3539 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3540 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3542 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3546 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3549 const char *p = str;
3556 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3563 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3567 AVCodecContext *video_enc;
3569 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3571 video_enc = st->codec;
3573 if (!ost->stream_copy) {
3574 const char *p = NULL;
3575 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3576 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3577 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3580 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3581 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3582 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3586 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3587 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3588 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3592 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3593 if (frame_aspect_ratio)
3594 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3596 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3597 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3598 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3601 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3603 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3605 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3606 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3609 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3611 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3613 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3614 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3617 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3620 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3621 for (i = 0; p; i++) {
3623 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3625 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3628 video_enc->rc_override =
3629 av_realloc(video_enc->rc_override,
3630 sizeof(RcOverride) * (i + 1));
3631 video_enc->rc_override[i].start_frame = start;
3632 video_enc->rc_override[i].end_frame = end;
3634 video_enc->rc_override[i].qscale = q;
3635 video_enc->rc_override[i].quality_factor = 1.0;
3638 video_enc->rc_override[i].qscale = 0;
3639 video_enc->rc_override[i].quality_factor = -q/100.0;
3644 video_enc->rc_override_count = i;
3645 if (!video_enc->rc_initial_buffer_occupancy)
3646 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
3647 video_enc->intra_dc_precision = intra_dc_precision - 8;
3652 video_enc->flags |= CODEC_FLAG_PASS1;
3654 video_enc->flags |= CODEC_FLAG_PASS2;
3658 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3659 if (forced_key_frames)
3660 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3662 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3664 ost->top_field_first = -1;
3665 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3668 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3670 ost->avfilter = av_strdup(filters);
3673 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3679 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3683 AVCodecContext *audio_enc;
3685 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3688 audio_enc = st->codec;
3689 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3691 if (!ost->stream_copy) {
3692 char *sample_fmt = NULL;
3694 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3696 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3698 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3699 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3703 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3709 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3713 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3714 if (!ost->stream_copy) {
3715 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3722 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3724 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3725 ost->stream_copy = 1;
3729 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3733 AVCodecContext *subtitle_enc;
3735 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3737 subtitle_enc = st->codec;
3739 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3744 /* arg format is "output-stream-index:streamid-value". */
3745 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3751 av_strlcpy(idx_str, arg, sizeof(idx_str));
3752 p = strchr(idx_str, ':');
3754 av_log(NULL, AV_LOG_FATAL,
3755 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3760 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3761 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3762 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3766 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3768 AVFormatContext *is = ifile->ctx;
3769 AVFormatContext *os = ofile->ctx;
3772 for (i = 0; i < is->nb_chapters; i++) {
3773 AVChapter *in_ch = is->chapters[i], *out_ch;
3774 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3775 AV_TIME_BASE_Q, in_ch->time_base);
3776 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3777 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3780 if (in_ch->end < ts_off)
3782 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3785 out_ch = av_mallocz(sizeof(AVChapter));
3787 return AVERROR(ENOMEM);
3789 out_ch->id = in_ch->id;
3790 out_ch->time_base = in_ch->time_base;
3791 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3792 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3795 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3798 os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
3800 return AVERROR(ENOMEM);
3801 os->chapters[os->nb_chapters - 1] = out_ch;
3806 static void opt_output_file(void *optctx, const char *filename)
3808 OptionsContext *o = optctx;
3809 AVFormatContext *oc;
3811 AVOutputFormat *file_oformat;
3815 if (!strcmp(filename, "-"))
3818 oc = avformat_alloc_context();
3820 print_error(filename, AVERROR(ENOMEM));
3825 file_oformat = av_guess_format(o->format, NULL, NULL);
3826 if (!file_oformat) {
3827 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3831 file_oformat = av_guess_format(NULL, filename, NULL);
3832 if (!file_oformat) {
3833 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3839 oc->oformat = file_oformat;
3840 oc->interrupt_callback = int_cb;
3841 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3843 if (!o->nb_stream_maps) {
3844 /* pick the "best" stream of each type */
3845 #define NEW_STREAM(type, index)\
3847 ost = new_ ## type ## _stream(o, oc);\
3848 ost->source_index = index;\
3849 ost->sync_ist = &input_streams[index];\
3850 input_streams[index].discard = 0;\
3853 /* video: highest resolution */
3854 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3855 int area = 0, idx = -1;
3856 for (i = 0; i < nb_input_streams; i++) {
3857 ist = &input_streams[i];
3858 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3859 ist->st->codec->width * ist->st->codec->height > area) {
3860 area = ist->st->codec->width * ist->st->codec->height;
3864 NEW_STREAM(video, idx);
3867 /* audio: most channels */
3868 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3869 int channels = 0, idx = -1;
3870 for (i = 0; i < nb_input_streams; i++) {
3871 ist = &input_streams[i];
3872 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3873 ist->st->codec->channels > channels) {
3874 channels = ist->st->codec->channels;
3878 NEW_STREAM(audio, idx);
3881 /* subtitles: pick first */
3882 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3883 for (i = 0; i < nb_input_streams; i++)
3884 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3885 NEW_STREAM(subtitle, i);
3889 /* do something with data? */
3891 for (i = 0; i < o->nb_stream_maps; i++) {
3892 StreamMap *map = &o->stream_maps[i];
3897 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3898 switch (ist->st->codec->codec_type) {
3899 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3900 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3901 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3902 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3903 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3905 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
3906 map->file_index, map->stream_index);
3910 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3911 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3912 map->sync_stream_index];
3917 /* handle attached files */
3918 for (i = 0; i < o->nb_attachments; i++) {
3920 uint8_t *attachment;
3924 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
3925 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
3929 if ((len = avio_size(pb)) <= 0) {
3930 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
3934 if (!(attachment = av_malloc(len))) {
3935 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
3939 avio_read(pb, attachment, len);
3941 ost = new_attachment_stream(o, oc);
3942 ost->stream_copy = 0;
3943 ost->source_index = -1;
3944 ost->attachment_filename = o->attachments[i];
3945 ost->st->codec->extradata = attachment;
3946 ost->st->codec->extradata_size = len;
3948 p = strrchr(o->attachments[i], '/');
3949 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
3953 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3954 output_files[nb_output_files - 1].ctx = oc;
3955 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3956 output_files[nb_output_files - 1].recording_time = o->recording_time;
3957 output_files[nb_output_files - 1].start_time = o->start_time;
3958 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3959 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3961 /* check filename in case of an image number is expected */
3962 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3963 if (!av_filename_number_test(oc->filename)) {
3964 print_error(oc->filename, AVERROR(EINVAL));
3969 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3970 /* test if it already exists to avoid losing precious files */
3971 assert_file_overwrite(filename);
3974 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
3975 &oc->interrupt_callback,
3976 &output_files[nb_output_files - 1].opts)) < 0) {
3977 print_error(filename, err);
3982 if (o->mux_preload) {
3984 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
3985 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
3987 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3988 oc->flags |= AVFMT_FLAG_NONBLOCK;
3991 for (i = 0; i < o->nb_metadata_map; i++) {
3993 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
3995 if (in_file_index < 0)
3997 if (in_file_index >= nb_input_files) {
3998 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4001 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4005 if (o->chapters_input_file >= nb_input_files) {
4006 if (o->chapters_input_file == INT_MAX) {
4007 /* copy chapters from the first input file that has them*/
4008 o->chapters_input_file = -1;
4009 for (i = 0; i < nb_input_files; i++)
4010 if (input_files[i].ctx->nb_chapters) {
4011 o->chapters_input_file = i;
4015 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4016 o->chapters_input_file);
4020 if (o->chapters_input_file >= 0)
4021 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4022 !o->metadata_chapters_manual);
4024 /* copy global metadata by default */
4025 if (!o->metadata_global_manual && nb_input_files)
4026 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4027 AV_DICT_DONT_OVERWRITE);
4028 if (!o->metadata_streams_manual)
4029 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4031 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4033 ist = &input_streams[output_streams[i].source_index];
4034 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4037 /* process manually set metadata */
4038 for (i = 0; i < o->nb_metadata; i++) {
4041 const char *stream_spec;
4042 int index = 0, j, ret;
4044 val = strchr(o->metadata[i].u.str, '=');
4046 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4047 o->metadata[i].u.str);
4052 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4054 for (j = 0; j < oc->nb_streams; j++) {
4055 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4056 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4060 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4068 if (index < 0 || index >= oc->nb_chapters) {
4069 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4072 m = &oc->chapters[index]->metadata;
4075 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4078 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4085 /* same option as mencoder */
4086 static int opt_pass(const char *opt, const char *arg)
4088 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4092 static int64_t getutime(void)
4095 struct rusage rusage;
4097 getrusage(RUSAGE_SELF, &rusage);
4098 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4099 #elif HAVE_GETPROCESSTIMES
4101 FILETIME c, e, k, u;
4102 proc = GetCurrentProcess();
4103 GetProcessTimes(proc, &c, &e, &k, &u);
4104 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4106 return av_gettime();
4110 static int64_t getmaxrss(void)
4112 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4113 struct rusage rusage;
4114 getrusage(RUSAGE_SELF, &rusage);
4115 return (int64_t)rusage.ru_maxrss * 1024;
4116 #elif HAVE_GETPROCESSMEMORYINFO
4118 PROCESS_MEMORY_COUNTERS memcounters;
4119 proc = GetCurrentProcess();
4120 memcounters.cb = sizeof(memcounters);
4121 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4122 return memcounters.PeakPagefileUsage;
4128 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4130 return parse_option(o, "q:a", arg, options);
4133 static void show_usage(void)
4135 printf("Hyper fast Audio and Video encoder\n");
4136 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4140 static void show_help(void)
4142 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4143 av_log_set_callback(log_callback_help);
4145 show_help_options(options, "Main options:\n",
4146 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4147 show_help_options(options, "\nAdvanced options:\n",
4148 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4150 show_help_options(options, "\nVideo options:\n",
4151 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4153 show_help_options(options, "\nAdvanced Video options:\n",
4154 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4155 OPT_VIDEO | OPT_EXPERT);
4156 show_help_options(options, "\nAudio options:\n",
4157 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4159 show_help_options(options, "\nAdvanced Audio options:\n",
4160 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4161 OPT_AUDIO | OPT_EXPERT);
4162 show_help_options(options, "\nSubtitle options:\n",
4163 OPT_SUBTITLE | OPT_GRAB,
4165 show_help_options(options, "\nAudio/Video grab options:\n",
4169 show_help_children(avcodec_get_class(), flags);
4170 show_help_children(avformat_get_class(), flags);
4171 show_help_children(sws_get_class(), flags);
4174 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4176 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4177 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4179 if (!strncmp(arg, "pal-", 4)) {
4182 } else if (!strncmp(arg, "ntsc-", 5)) {
4185 } else if (!strncmp(arg, "film-", 5)) {
4189 /* Try to determine PAL/NTSC by peeking in the input files */
4190 if (nb_input_files) {
4192 for (j = 0; j < nb_input_files; j++) {
4193 for (i = 0; i < input_files[j].nb_streams; i++) {
4194 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4195 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4197 fr = c->time_base.den * 1000 / c->time_base.num;
4201 } else if ((fr == 29970) || (fr == 23976)) {
4206 if (norm != UNKNOWN)
4210 if (norm != UNKNOWN)
4211 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4214 if (norm == UNKNOWN) {
4215 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4216 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4217 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4221 if (!strcmp(arg, "vcd")) {
4222 opt_video_codec(o, "c:v", "mpeg1video");
4223 opt_audio_codec(o, "c:a", "mp2");
4224 parse_option(o, "f", "vcd", options);
4226 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4227 parse_option(o, "r", frame_rates[norm], options);
4228 opt_default("g", norm == PAL ? "15" : "18");
4230 opt_default("b", "1150000");
4231 opt_default("maxrate", "1150000");
4232 opt_default("minrate", "1150000");
4233 opt_default("bufsize", "327680"); // 40*1024*8;
4235 opt_default("b:a", "224000");
4236 parse_option(o, "ar", "44100", options);
4237 parse_option(o, "ac", "2", options);
4239 opt_default("packetsize", "2324");
4240 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4242 /* We have to offset the PTS, so that it is consistent with the SCR.
4243 SCR starts at 36000, but the first two packs contain only padding
4244 and the first pack from the other stream, respectively, may also have
4245 been written before.
4246 So the real data starts at SCR 36000+3*1200. */
4247 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4248 } else if (!strcmp(arg, "svcd")) {
4250 opt_video_codec(o, "c:v", "mpeg2video");
4251 opt_audio_codec(o, "c:a", "mp2");
4252 parse_option(o, "f", "svcd", options);
4254 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4255 parse_option(o, "r", frame_rates[norm], options);
4256 opt_default("g", norm == PAL ? "15" : "18");
4258 opt_default("b", "2040000");
4259 opt_default("maxrate", "2516000");
4260 opt_default("minrate", "0"); // 1145000;
4261 opt_default("bufsize", "1835008"); // 224*1024*8;
4262 opt_default("flags", "+scan_offset");
4265 opt_default("b:a", "224000");
4266 parse_option(o, "ar", "44100", options);
4268 opt_default("packetsize", "2324");
4270 } else if (!strcmp(arg, "dvd")) {
4272 opt_video_codec(o, "c:v", "mpeg2video");
4273 opt_audio_codec(o, "c:a", "ac3");
4274 parse_option(o, "f", "dvd", options);
4276 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4277 parse_option(o, "r", frame_rates[norm], options);
4278 opt_default("g", norm == PAL ? "15" : "18");
4280 opt_default("b", "6000000");
4281 opt_default("maxrate", "9000000");
4282 opt_default("minrate", "0"); // 1500000;
4283 opt_default("bufsize", "1835008"); // 224*1024*8;
4285 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4286 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4288 opt_default("b:a", "448000");
4289 parse_option(o, "ar", "48000", options);
4291 } else if (!strncmp(arg, "dv", 2)) {
4293 parse_option(o, "f", "dv", options);
4295 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4296 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4297 norm == PAL ? "yuv420p" : "yuv411p", options);
4298 parse_option(o, "r", frame_rates[norm], options);
4300 parse_option(o, "ar", "48000", options);
4301 parse_option(o, "ac", "2", options);
4304 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4305 return AVERROR(EINVAL);
4310 static int opt_vstats_file(const char *opt, const char *arg)
4312 av_free (vstats_filename);
4313 vstats_filename = av_strdup (arg);
4317 static int opt_vstats(const char *opt, const char *arg)
4320 time_t today2 = time(NULL);
4321 struct tm *today = localtime(&today2);
4323 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4325 return opt_vstats_file(opt, filename);
4328 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4330 return parse_option(o, "frames:v", arg, options);
4333 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4335 return parse_option(o, "frames:a", arg, options);
4338 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4340 return parse_option(o, "frames:d", arg, options);
4343 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4345 return parse_option(o, "tag:v", arg, options);
4348 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4350 return parse_option(o, "tag:a", arg, options);
4353 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4355 return parse_option(o, "tag:s", arg, options);
4358 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4360 return parse_option(o, "filter:v", arg, options);
4363 static int opt_vsync(const char *opt, const char *arg)
4365 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
4366 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
4367 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4369 if (video_sync_method == VSYNC_AUTO)
4370 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4374 static int opt_deinterlace(const char *opt, const char *arg)
4376 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
4381 #define OFFSET(x) offsetof(OptionsContext, x)
4382 static const OptionDef options[] = {
4384 #include "cmdutils_common_opts.h"
4385 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4386 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4387 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4388 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4389 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4390 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4391 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4392 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4393 "outfile[,metadata]:infile[,metadata]" },
4394 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4395 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4396 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4397 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4398 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4399 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4400 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4401 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4402 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4403 "add timings for benchmarking" },
4404 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4405 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4406 "dump each input packet" },
4407 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4408 "when dumping packets, also dump the payload" },
4409 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4410 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4411 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4412 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4413 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4414 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4415 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4416 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4417 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4418 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4419 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4420 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4421 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4422 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4423 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4425 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4427 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4428 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4429 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4432 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4433 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4434 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4435 { "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" },
4436 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4437 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4438 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4439 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4440 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4441 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4442 "use same quantizer as source (implies VBR)" },
4443 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4444 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
4445 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
4446 "this option is deprecated, use the yadif filter instead" },
4447 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4448 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4450 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4452 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4453 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4454 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4455 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4456 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4457 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4458 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4459 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4460 { "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" },
4463 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4464 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4465 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4466 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4467 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4468 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4469 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4470 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4471 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4473 /* subtitle options */
4474 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4475 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4476 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4479 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4482 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4483 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4485 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4487 /* data codec support */
4488 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4490 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4494 int main(int argc, char **argv)
4496 OptionsContext o = { 0 };
4501 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4502 parse_loglevel(argc, argv, options);
4504 avcodec_register_all();
4506 avdevice_register_all();
4509 avfilter_register_all();
4512 avformat_network_init();
4517 parse_options(&o, argc, argv, options, opt_output_file);
4519 if (nb_output_files <= 0 && nb_input_files == 0) {
4521 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4525 /* file converter / grab */
4526 if (nb_output_files <= 0) {
4527 fprintf(stderr, "At least one output file must be specified\n");
4531 if (nb_input_files == 0) {
4532 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4537 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4539 ti = getutime() - ti;
4541 int maxrss = getmaxrss() / 1024;
4542 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);