3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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"
50 #include "libavformat/ffm.h" // not public API
53 # include "libavfilter/avcodec.h"
54 # include "libavfilter/avfilter.h"
55 # include "libavfilter/avfiltergraph.h"
56 # include "libavfilter/buffersink.h"
57 # include "libavfilter/buffersrc.h"
58 # include "libavfilter/vsrc_buffer.h"
61 #if HAVE_SYS_RESOURCE_H
62 #include <sys/types.h>
64 #include <sys/resource.h>
65 #elif HAVE_GETPROCESSTIMES
68 #if HAVE_GETPROCESSMEMORYINFO
74 #include <sys/select.h>
79 #include <sys/ioctl.h>
89 #include "libavutil/avassert.h"
92 #define VSYNC_PASSTHROUGH 0
96 const char program_name[] = "avconv";
97 const int program_birth_year = 2000;
99 /* select an input stream for an output stream */
100 typedef struct StreamMap {
101 int disabled; /** 1 is this mapping is disabled by a negative map */
105 int sync_stream_index;
109 * select an input file for an output file
111 typedef struct MetadataMap {
112 int file; ///< file index
113 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
114 int index; ///< stream/chapter/program number
117 static const OptionDef options[];
119 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
121 static int frame_bits_per_raw_sample = 0;
122 static int video_discard = 0;
123 static int same_quant = 0;
124 static int do_deinterlace = 0;
125 static int intra_dc_precision = 8;
126 static int qp_hist = 0;
128 static int file_overwrite = 0;
129 static int no_file_overwrite = 0;
130 static int do_benchmark = 0;
131 static int do_hex_dump = 0;
132 static int do_pkt_dump = 0;
133 static int do_pass = 0;
134 static const char *pass_logfilename_prefix;
135 static int video_sync_method = VSYNC_AUTO;
136 static int audio_sync_method = 0;
137 static float audio_drift_threshold = 0.1;
138 static int copy_ts = 0;
139 static int copy_tb = 1;
140 static int opt_shortest = 0;
141 static char *vstats_filename;
142 static FILE *vstats_file;
144 static int audio_volume = 256;
146 static int exit_on_error = 0;
147 static int using_stdin = 0;
148 static int run_as_daemon = 0;
149 static int q_pressed = 0;
150 static int64_t video_size = 0;
151 static int64_t audio_size = 0;
152 static int64_t extra_size = 0;
153 static int nb_frames_dup = 0;
154 static int nb_frames_drop = 0;
155 static int input_sync;
157 static float dts_delta_threshold = 10;
159 static int print_stats = 1;
161 static uint8_t *audio_buf;
162 static unsigned int allocated_audio_buf_size;
164 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
166 typedef struct FrameBuffer {
172 enum PixelFormat pix_fmt;
175 struct InputStream *ist;
176 struct FrameBuffer *next;
179 typedef struct InputStream {
182 int discard; /* true if stream data should be discarded */
183 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
185 AVFrame *decoded_frame;
186 AVFrame *filtered_frame;
188 int64_t start; /* time when read started */
189 int64_t next_pts; /* synthetic pts for cases where pkt.pts
191 int64_t pts; /* current pts */
193 int is_start; /* is 1 at the start and after a discontinuity */
194 int showed_multi_packet_warning;
197 /* a pool of free buffers for decoded data */
198 FrameBuffer *buffer_pool;
201 typedef struct InputFile {
202 AVFormatContext *ctx;
203 int eof_reached; /* true if eof reached */
204 int ist_index; /* index of first stream in ist_table */
205 int buffer_size; /* current total buffer size */
207 int nb_streams; /* number of stream that avconv is aware of; may be different
208 from ctx.nb_streams if new streams appear during av_read_frame() */
212 typedef struct OutputStream {
213 int file_index; /* file index */
214 int index; /* stream index in the output file */
215 int source_index; /* InputStream index */
216 AVStream *st; /* stream in the output file */
217 int encoding_needed; /* true if encoding needed for this stream */
219 /* input pts and corresponding output pts
221 // double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
222 struct InputStream *sync_ist; /* input stream to sync against */
223 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
224 AVBitStreamFilterContext *bitstream_filters;
227 AVFrame *output_frame;
231 AVFrame resample_frame; /* temporary frame for image resampling */
232 struct SwsContext *img_resample_ctx; /* for image resampling */
235 int resample_pix_fmt;
236 AVRational frame_rate;
240 float frame_aspect_ratio;
242 /* forced key frames */
243 int64_t *forced_kf_pts;
249 ReSampleContext *resample; /* for audio resampling */
250 int resample_sample_fmt;
251 int resample_channels;
252 int resample_sample_rate;
254 AVAudioConvert *reformat_ctx;
255 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
259 AVFilterContext *output_video_filter;
260 AVFilterContext *input_video_filter;
261 AVFilterBufferRef *picref;
263 AVFilterGraph *graph;
268 int is_past_recording_time;
270 const char *attachment_filename;
271 int copy_initial_nonkeyframes;
276 /* init terminal so that we can grab keys */
277 static struct termios oldtty;
280 typedef struct OutputFile {
281 AVFormatContext *ctx;
283 int ost_index; /* index of the first stream in output_streams */
284 int64_t recording_time; /* desired length of the resulting file in microseconds */
285 int64_t start_time; /* start time in microseconds */
286 uint64_t limit_filesize;
289 static InputStream *input_streams = NULL;
290 static int nb_input_streams = 0;
291 static InputFile *input_files = NULL;
292 static int nb_input_files = 0;
294 static OutputStream *output_streams = NULL;
295 static int nb_output_streams = 0;
296 static OutputFile *output_files = NULL;
297 static int nb_output_files = 0;
299 typedef struct OptionsContext {
300 /* input/output options */
304 SpecifierOpt *codec_names;
306 SpecifierOpt *audio_channels;
307 int nb_audio_channels;
308 SpecifierOpt *audio_sample_rate;
309 int nb_audio_sample_rate;
310 SpecifierOpt *frame_rates;
312 SpecifierOpt *frame_sizes;
314 SpecifierOpt *frame_pix_fmts;
315 int nb_frame_pix_fmts;
318 int64_t input_ts_offset;
321 SpecifierOpt *ts_scale;
323 SpecifierOpt *dump_attachment;
324 int nb_dump_attachment;
327 StreamMap *stream_maps;
329 /* first item specifies output metadata, second is input */
330 MetadataMap (*meta_data_maps)[2];
331 int nb_meta_data_maps;
332 int metadata_global_manual;
333 int metadata_streams_manual;
334 int metadata_chapters_manual;
335 const char **attachments;
338 int chapters_input_file;
340 int64_t recording_time;
341 uint64_t limit_filesize;
347 int subtitle_disable;
350 /* indexed by output file stream index */
354 SpecifierOpt *metadata;
356 SpecifierOpt *max_frames;
358 SpecifierOpt *bitstream_filters;
359 int nb_bitstream_filters;
360 SpecifierOpt *codec_tags;
362 SpecifierOpt *sample_fmts;
364 SpecifierOpt *qscale;
366 SpecifierOpt *forced_key_frames;
367 int nb_forced_key_frames;
368 SpecifierOpt *force_fps;
370 SpecifierOpt *frame_aspect_ratios;
371 int nb_frame_aspect_ratios;
372 SpecifierOpt *rc_overrides;
374 SpecifierOpt *intra_matrices;
375 int nb_intra_matrices;
376 SpecifierOpt *inter_matrices;
377 int nb_inter_matrices;
378 SpecifierOpt *top_field_first;
379 int nb_top_field_first;
380 SpecifierOpt *metadata_map;
382 SpecifierOpt *presets;
384 SpecifierOpt *copy_initial_nonkeyframes;
385 int nb_copy_initial_nonkeyframes;
387 SpecifierOpt *filters;
392 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
395 for (i = 0; i < o->nb_ ## name; i++) {\
396 char *spec = o->name[i].specifier;\
397 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
398 outvar = o->name[i].u.type;\
404 static void reset_options(OptionsContext *o)
406 const OptionDef *po = options;
408 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
410 void *dst = (uint8_t*)o + po->u.off;
412 if (po->flags & OPT_SPEC) {
413 SpecifierOpt **so = dst;
414 int i, *count = (int*)(so + 1);
415 for (i = 0; i < *count; i++) {
416 av_freep(&(*so)[i].specifier);
417 if (po->flags & OPT_STRING)
418 av_freep(&(*so)[i].u.str);
422 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
427 av_freep(&o->stream_maps);
428 av_freep(&o->meta_data_maps);
429 av_freep(&o->streamid_map);
431 memset(o, 0, sizeof(*o));
433 o->mux_max_delay = 0.7;
434 o->recording_time = INT64_MAX;
435 o->limit_filesize = UINT64_MAX;
436 o->chapters_input_file = INT_MAX;
442 static int alloc_buffer(InputStream *ist, FrameBuffer **pbuf)
444 AVCodecContext *s = ist->st->codec;
445 FrameBuffer *buf = av_mallocz(sizeof(*buf));
447 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
448 int h_chroma_shift, v_chroma_shift;
449 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
450 int w = s->width, h = s->height;
453 return AVERROR(ENOMEM);
455 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
460 avcodec_align_dimensions(s, &w, &h);
461 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
462 s->pix_fmt, 32)) < 0) {
466 /* XXX this shouldn't be needed, but some tests break without this line
467 * those decoders are buggy and need to be fixed.
468 * the following tests fail:
469 * bethsoft-vid, cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
471 memset(buf->base[0], 128, ret);
473 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
474 for (int i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
475 const int h_shift = i==0 ? 0 : h_chroma_shift;
476 const int v_shift = i==0 ? 0 : v_chroma_shift;
477 if (s->flags & CODEC_FLAG_EMU_EDGE)
478 buf->data[i] = buf->base[i];
480 buf->data[i] = buf->base[i] +
481 FFALIGN((buf->linesize[i]*edge >> v_shift) +
482 (pixel_size*edge >> h_shift), 32);
486 buf->pix_fmt = s->pix_fmt;
493 static void free_buffer_pool(InputStream *ist)
495 FrameBuffer *buf = ist->buffer_pool;
497 ist->buffer_pool = buf->next;
498 av_freep(&buf->base[0]);
500 buf = ist->buffer_pool;
504 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
506 av_assert0(buf->refcount);
508 if (!buf->refcount) {
509 buf->next = ist->buffer_pool;
510 ist->buffer_pool = buf;
514 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
516 InputStream *ist = s->opaque;
520 if (!ist->buffer_pool && (ret = alloc_buffer(ist, &ist->buffer_pool)) < 0)
523 buf = ist->buffer_pool;
524 ist->buffer_pool = buf->next;
526 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
527 av_freep(&buf->base[0]);
529 if ((ret = alloc_buffer(ist, &buf)) < 0)
535 frame->type = FF_BUFFER_TYPE_USER;
536 frame->extended_data = frame->data;
537 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
539 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
540 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
541 frame->data[i] = buf->data[i];
542 frame->linesize[i] = buf->linesize[i];
548 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
550 InputStream *ist = s->opaque;
551 FrameBuffer *buf = frame->opaque;
554 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
555 frame->data[i] = NULL;
557 unref_buffer(ist, buf);
560 static void filter_release_buffer(AVFilterBuffer *fb)
562 FrameBuffer *buf = fb->priv;
564 unref_buffer(buf->ist, buf);
569 static int configure_video_filters(InputStream *ist, OutputStream *ost)
571 AVFilterContext *last_filter, *filter;
572 /** filter graph containing all filters including input & output */
573 AVCodecContext *codec = ost->st->codec;
574 AVCodecContext *icodec = ist->st->codec;
575 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
576 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
577 AVRational sample_aspect_ratio;
581 ost->graph = avfilter_graph_alloc();
583 if (ist->st->sample_aspect_ratio.num) {
584 sample_aspect_ratio = ist->st->sample_aspect_ratio;
586 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
588 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
589 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
590 sample_aspect_ratio.num, sample_aspect_ratio.den);
592 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
593 "src", args, NULL, ost->graph);
596 #if FF_API_OLD_VSINK_API
597 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
598 "out", NULL, pix_fmts, ost->graph);
600 buffersink_params->pixel_fmts = pix_fmts;
601 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
602 "out", NULL, buffersink_params, ost->graph);
604 av_freep(&buffersink_params);
607 last_filter = ost->input_video_filter;
609 if (codec->width != icodec->width || codec->height != icodec->height) {
610 snprintf(args, 255, "%d:%d:flags=0x%X",
613 (unsigned)ost->sws_flags);
614 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
615 NULL, args, NULL, ost->graph)) < 0)
617 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
619 last_filter = filter;
622 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
623 ost->graph->scale_sws_opts = av_strdup(args);
626 AVFilterInOut *outputs = avfilter_inout_alloc();
627 AVFilterInOut *inputs = avfilter_inout_alloc();
629 outputs->name = av_strdup("in");
630 outputs->filter_ctx = last_filter;
631 outputs->pad_idx = 0;
632 outputs->next = NULL;
634 inputs->name = av_strdup("out");
635 inputs->filter_ctx = ost->output_video_filter;
639 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
642 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
646 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
649 codec->width = ost->output_video_filter->inputs[0]->w;
650 codec->height = ost->output_video_filter->inputs[0]->h;
651 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
652 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
653 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
654 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
658 #endif /* CONFIG_AVFILTER */
660 static void term_exit(void)
662 av_log(NULL, AV_LOG_QUIET, "%s", "");
665 tcsetattr (0, TCSANOW, &oldtty);
669 static volatile int received_sigterm = 0;
672 sigterm_handler(int sig)
674 received_sigterm = sig;
679 static void term_init(void)
689 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
690 |INLCR|IGNCR|ICRNL|IXON);
691 tty.c_oflag |= OPOST;
692 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
693 tty.c_cflag &= ~(CSIZE|PARENB);
698 tcsetattr (0, TCSANOW, &tty);
699 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
703 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
704 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
706 signal(SIGXCPU, sigterm_handler);
710 /* read a key without blocking */
711 static int read_key(void)
726 n = select(1, &rfds, NULL, NULL, &tv);
741 static int decode_interrupt_cb(void *ctx)
743 q_pressed += read_key() == 'q';
744 return q_pressed > 1;
747 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
749 void exit_program(int ret)
754 for (i = 0; i < nb_output_files; i++) {
755 AVFormatContext *s = output_files[i].ctx;
756 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
758 avformat_free_context(s);
759 av_dict_free(&output_files[i].opts);
761 for (i = 0; i < nb_output_streams; i++) {
762 AVBitStreamFilterContext *bsfc = output_streams[i].bitstream_filters;
764 AVBitStreamFilterContext *next = bsfc->next;
765 av_bitstream_filter_close(bsfc);
768 output_streams[i].bitstream_filters = NULL;
770 if (output_streams[i].output_frame) {
771 AVFrame *frame = output_streams[i].output_frame;
772 if (frame->extended_data != frame->data)
773 av_freep(&frame->extended_data);
778 av_freep(&output_streams[i].avfilter);
781 for (i = 0; i < nb_input_files; i++) {
782 avformat_close_input(&input_files[i].ctx);
784 for (i = 0; i < nb_input_streams; i++) {
785 av_freep(&input_streams[i].decoded_frame);
786 av_freep(&input_streams[i].filtered_frame);
787 av_dict_free(&input_streams[i].opts);
788 free_buffer_pool(&input_streams[i]);
793 av_free(vstats_filename);
795 av_freep(&input_streams);
796 av_freep(&input_files);
797 av_freep(&output_streams);
798 av_freep(&output_files);
802 allocated_audio_buf_size = 0;
807 avformat_network_deinit();
809 if (received_sigterm) {
810 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
811 (int) received_sigterm);
818 static void assert_avoptions(AVDictionary *m)
820 AVDictionaryEntry *t;
821 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
822 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
827 static void assert_codec_experimental(AVCodecContext *c, int encoder)
829 const char *codec_string = encoder ? "encoder" : "decoder";
831 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
832 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
833 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
834 "results.\nAdd '-strict experimental' if you want to use it.\n",
835 codec_string, c->codec->name);
836 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
837 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
838 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
839 codec_string, codec->name);
844 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
846 if (codec && codec->sample_fmts) {
847 const enum AVSampleFormat *p = codec->sample_fmts;
848 for (; *p != -1; p++) {
849 if (*p == st->codec->sample_fmt)
853 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
854 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
855 if(av_get_sample_fmt_name(st->codec->sample_fmt))
856 av_log(NULL, AV_LOG_WARNING,
857 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
858 av_get_sample_fmt_name(st->codec->sample_fmt),
860 av_get_sample_fmt_name(codec->sample_fmts[0]));
861 st->codec->sample_fmt = codec->sample_fmts[0];
866 static void choose_sample_rate(AVStream *st, AVCodec *codec)
868 if (codec && codec->supported_samplerates) {
869 const int *p = codec->supported_samplerates;
871 int best_dist = INT_MAX;
873 int dist = abs(st->codec->sample_rate - *p);
874 if (dist < best_dist) {
880 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
882 st->codec->sample_rate = best;
886 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
888 if (codec && codec->pix_fmts) {
889 const enum PixelFormat *p = codec->pix_fmts;
890 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
891 if (st->codec->codec_id == CODEC_ID_MJPEG) {
892 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
893 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
894 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
895 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
898 for (; *p != PIX_FMT_NONE; p++) {
899 if (*p == st->codec->pix_fmt)
902 if (*p == PIX_FMT_NONE) {
903 if (st->codec->pix_fmt != PIX_FMT_NONE)
904 av_log(NULL, AV_LOG_WARNING,
905 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
906 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
908 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
909 st->codec->pix_fmt = codec->pix_fmts[0];
915 get_sync_ipts(const OutputStream *ost)
917 const InputStream *ist = ost->sync_ist;
918 OutputFile *of = &output_files[ost->file_index];
919 return (double)(ist->pts - of->start_time) / AV_TIME_BASE;
922 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
924 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
925 AVCodecContext *avctx = ost->st->codec;
929 * Audio encoders may split the packets -- #frames in != #packets out.
930 * But there is no reordering, so we can limit the number of output packets
931 * by simply dropping them here.
932 * Counting encoded video frames needs to be done separately because of
933 * reordering, see do_video_out()
935 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
936 if (ost->frame_number >= ost->max_frames)
942 AVPacket new_pkt = *pkt;
943 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
944 &new_pkt.data, &new_pkt.size,
945 pkt->data, pkt->size,
946 pkt->flags & AV_PKT_FLAG_KEY);
949 new_pkt.destruct = av_destruct_packet;
951 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
952 bsfc->filter->name, pkt->stream_index,
953 avctx->codec ? avctx->codec->name : "copy");
963 ret = av_interleaved_write_frame(s, pkt);
965 print_error("av_interleaved_write_frame()", ret);
970 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
972 int fill_char = 0x00;
973 if (sample_fmt == AV_SAMPLE_FMT_U8)
975 memset(buf, fill_char, size);
978 static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,
979 const uint8_t *buf, int buf_size)
981 AVCodecContext *enc = ost->st->codec;
982 AVFrame *frame = NULL;
986 av_init_packet(&pkt);
991 if (!ost->output_frame) {
992 ost->output_frame = avcodec_alloc_frame();
993 if (!ost->output_frame) {
994 av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");
998 frame = ost->output_frame;
999 if (frame->extended_data != frame->data)
1000 av_freep(&frame->extended_data);
1001 avcodec_get_frame_defaults(frame);
1003 frame->nb_samples = buf_size /
1004 (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
1005 if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,
1006 buf, buf_size, 1)) < 0) {
1007 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1013 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1014 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1019 pkt.stream_index = ost->index;
1020 if (pkt.pts != AV_NOPTS_VALUE)
1021 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1022 if (pkt.duration > 0)
1023 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1025 write_frame(s, &pkt, ost);
1027 audio_size += pkt.size;
1031 ost->sync_opts += frame->nb_samples;
1036 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1037 InputStream *ist, AVFrame *decoded_frame)
1040 int64_t audio_buf_size;
1042 int size_out, frame_bytes, resample_changed;
1043 AVCodecContext *enc = ost->st->codec;
1044 AVCodecContext *dec = ist->st->codec;
1045 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1046 int isize = av_get_bytes_per_sample(dec->sample_fmt);
1047 uint8_t *buf = decoded_frame->data[0];
1048 int size = decoded_frame->nb_samples * dec->channels * isize;
1049 int64_t allocated_for_size = size;
1052 audio_buf_size = (allocated_for_size + isize * dec->channels - 1) / (isize * dec->channels);
1053 audio_buf_size = (audio_buf_size * enc->sample_rate + dec->sample_rate) / dec->sample_rate;
1054 audio_buf_size = audio_buf_size * 2 + 10000; // safety factors for the deprecated resampling API
1055 audio_buf_size = FFMAX(audio_buf_size, enc->frame_size);
1056 audio_buf_size *= osize * enc->channels;
1058 if (audio_buf_size > INT_MAX) {
1059 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
1063 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
1065 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1069 if (enc->channels != dec->channels)
1070 ost->audio_resample = 1;
1072 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1073 ost->resample_channels != dec->channels ||
1074 ost->resample_sample_rate != dec->sample_rate;
1076 if ((ost->audio_resample && !ost->resample) || resample_changed) {
1077 if (resample_changed) {
1078 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",
1079 ist->file_index, ist->st->index,
1080 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
1081 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
1082 ost->resample_sample_fmt = dec->sample_fmt;
1083 ost->resample_channels = dec->channels;
1084 ost->resample_sample_rate = dec->sample_rate;
1086 audio_resample_close(ost->resample);
1088 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1089 if (audio_sync_method <= 1 &&
1090 ost->resample_sample_fmt == enc->sample_fmt &&
1091 ost->resample_channels == enc->channels &&
1092 ost->resample_sample_rate == enc->sample_rate) {
1093 ost->resample = NULL;
1094 ost->audio_resample = 0;
1096 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
1097 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
1098 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
1099 enc->sample_rate, dec->sample_rate,
1100 enc->sample_fmt, dec->sample_fmt,
1102 if (!ost->resample) {
1103 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1104 dec->channels, dec->sample_rate,
1105 enc->channels, enc->sample_rate);
1111 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
1112 if (!ost->audio_resample && dec->sample_fmt != enc->sample_fmt &&
1113 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt) != ost->reformat_pair) {
1114 if (ost->reformat_ctx)
1115 av_audio_convert_free(ost->reformat_ctx);
1116 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
1117 dec->sample_fmt, 1, NULL, 0);
1118 if (!ost->reformat_ctx) {
1119 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
1120 av_get_sample_fmt_name(dec->sample_fmt),
1121 av_get_sample_fmt_name(enc->sample_fmt));
1124 ost->reformat_pair = MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
1127 if (audio_sync_method) {
1128 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts -
1129 av_fifo_size(ost->fifo) / (enc->channels * osize);
1130 int idelta = delta * dec->sample_rate / enc->sample_rate;
1131 int byte_delta = idelta * isize * dec->channels;
1133 // FIXME resample delay
1134 if (fabs(delta) > 50) {
1135 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1136 if (byte_delta < 0) {
1137 byte_delta = FFMAX(byte_delta, -size);
1140 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1141 -byte_delta / (isize * dec->channels));
1146 static uint8_t *input_tmp = NULL;
1147 input_tmp = av_realloc(input_tmp, byte_delta + size);
1149 if (byte_delta > allocated_for_size - size) {
1150 allocated_for_size = byte_delta + (int64_t)size;
1155 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
1156 memcpy(input_tmp + byte_delta, buf, size);
1159 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1161 } else if (audio_sync_method > 1) {
1162 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1163 av_assert0(ost->audio_resample);
1164 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1165 delta, comp, enc->sample_rate);
1166 // 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));
1167 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
1171 ost->sync_opts = lrintf(get_sync_ipts(ost) * enc->sample_rate) -
1172 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1174 if (ost->audio_resample) {
1176 size_out = audio_resample(ost->resample,
1177 (short *)buftmp, (short *)buf,
1178 size / (dec->channels * isize));
1179 size_out = size_out * enc->channels * osize;
1185 if (!ost->audio_resample && dec->sample_fmt != enc->sample_fmt) {
1186 const void *ibuf[6] = { buftmp };
1187 void *obuf[6] = { audio_buf };
1188 int istride[6] = { isize };
1189 int ostride[6] = { osize };
1190 int len = size_out / istride[0];
1191 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len) < 0) {
1192 printf("av_audio_convert() failed\n");
1198 size_out = len * osize;
1201 /* now encode as many frames as possible */
1202 if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1203 /* output resampled raw samples */
1204 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1205 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1208 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1210 frame_bytes = enc->frame_size * osize * enc->channels;
1212 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1213 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1214 encode_audio_frame(s, ost, audio_buf, frame_bytes);
1217 encode_audio_frame(s, ost, buftmp, size_out);
1221 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1223 AVCodecContext *dec;
1224 AVPicture *picture2;
1225 AVPicture picture_tmp;
1228 dec = ist->st->codec;
1230 /* deinterlace : must be done before any resize */
1231 if (do_deinterlace) {
1234 /* create temporary picture */
1235 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1236 buf = av_malloc(size);
1240 picture2 = &picture_tmp;
1241 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1243 if (avpicture_deinterlace(picture2, picture,
1244 dec->pix_fmt, dec->width, dec->height) < 0) {
1245 /* if error, do not deinterlace */
1246 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1255 if (picture != picture2)
1256 *picture = *picture2;
1260 static void do_subtitle_out(AVFormatContext *s,
1266 static uint8_t *subtitle_out = NULL;
1267 int subtitle_out_max_size = 1024 * 1024;
1268 int subtitle_out_size, nb, i;
1269 AVCodecContext *enc;
1272 if (pts == AV_NOPTS_VALUE) {
1273 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1279 enc = ost->st->codec;
1281 if (!subtitle_out) {
1282 subtitle_out = av_malloc(subtitle_out_max_size);
1285 /* Note: DVB subtitle need one packet to draw them and one other
1286 packet to clear them */
1287 /* XXX: signal it in the codec context ? */
1288 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1293 for (i = 0; i < nb; i++) {
1294 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1295 // start_display_time is required to be 0
1296 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1297 sub->end_display_time -= sub->start_display_time;
1298 sub->start_display_time = 0;
1299 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1300 subtitle_out_max_size, sub);
1301 if (subtitle_out_size < 0) {
1302 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1306 av_init_packet(&pkt);
1307 pkt.stream_index = ost->index;
1308 pkt.data = subtitle_out;
1309 pkt.size = subtitle_out_size;
1310 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1311 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1312 /* XXX: the pts correction is handled here. Maybe handling
1313 it in the codec would be better */
1315 pkt.pts += 90 * sub->start_display_time;
1317 pkt.pts += 90 * sub->end_display_time;
1319 write_frame(s, &pkt, ost);
1323 static int bit_buffer_size = 1024 * 256;
1324 static uint8_t *bit_buffer = NULL;
1326 #if !CONFIG_AVFILTER
1327 static void do_video_resample(OutputStream *ost,
1329 AVFrame *in_picture,
1330 AVFrame **out_picture)
1332 int resample_changed = 0;
1333 AVCodecContext *dec = ist->st->codec;
1334 AVCodecContext *enc = ost->st->codec;
1335 *out_picture = in_picture;
1337 resample_changed = ost->resample_width != in_picture->width ||
1338 ost->resample_height != in_picture->height ||
1339 ost->resample_pix_fmt != in_picture->format;
1341 if (resample_changed) {
1342 av_log(NULL, AV_LOG_INFO,
1343 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s / frm size:%dx%d fmt:%s\n",
1344 ist->file_index, ist->st->index,
1345 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1346 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt),
1347 in_picture->width, in_picture->height, av_get_pix_fmt_name(in_picture->format));
1348 ost->resample_width = in_picture->width;
1349 ost->resample_height = in_picture->height;
1350 ost->resample_pix_fmt = in_picture->format;
1353 ost->video_resample = dec->width != enc->width ||
1354 dec->height != enc->height ||
1355 dec->pix_fmt != enc->pix_fmt;
1358 if (ost->video_resample) {
1359 *out_picture = &ost->resample_frame;
1360 if (!ost->img_resample_ctx || resample_changed) {
1361 /* initialize the destination picture */
1362 if (!ost->resample_frame.data[0]) {
1363 avcodec_get_frame_defaults(&ost->resample_frame);
1364 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1365 enc->width, enc->height)) {
1366 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1370 /* initialize a new scaler context */
1371 sws_freeContext(ost->img_resample_ctx);
1372 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1373 enc->width, enc->height, enc->pix_fmt,
1374 ost->sws_flags, NULL, NULL, NULL);
1375 if (ost->img_resample_ctx == NULL) {
1376 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1380 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1381 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1383 if (resample_changed) {
1384 ost->resample_width = in_picture->width;
1385 ost->resample_height = in_picture->height;
1386 ost->resample_pix_fmt = in_picture->format;
1392 static void do_video_out(AVFormatContext *s,
1395 AVFrame *in_picture,
1396 int *frame_size, float quality)
1398 int nb_frames, i, ret, format_video_sync;
1399 AVFrame *final_picture;
1400 AVCodecContext *enc;
1403 enc = ost->st->codec;
1405 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1407 /* by default, we output a single frame */
1412 format_video_sync = video_sync_method;
1413 if (format_video_sync == VSYNC_AUTO)
1414 format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
1415 (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
1417 if (format_video_sync != VSYNC_PASSTHROUGH) {
1418 double vdelta = sync_ipts - ost->sync_opts;
1419 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1422 else if (format_video_sync == VSYNC_VFR) {
1423 if (vdelta <= -0.6) {
1425 } else if (vdelta > 0.6)
1426 ost->sync_opts = lrintf(sync_ipts);
1427 } else if (vdelta > 1.1)
1428 nb_frames = lrintf(vdelta);
1429 //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);
1430 if (nb_frames == 0) {
1432 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1433 } else if (nb_frames > 1) {
1434 nb_frames_dup += nb_frames - 1;
1435 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1438 ost->sync_opts = lrintf(sync_ipts);
1440 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1444 #if !CONFIG_AVFILTER
1445 do_video_resample(ost, ist, in_picture, &final_picture);
1447 final_picture = in_picture;
1450 /* duplicates frame if needed */
1451 for (i = 0; i < nb_frames; i++) {
1453 av_init_packet(&pkt);
1454 pkt.stream_index = ost->index;
1456 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1457 enc->codec->id == CODEC_ID_RAWVIDEO) {
1458 /* raw pictures are written as AVPicture structure to
1459 avoid any copies. We support temporarily the older
1461 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1462 enc->coded_frame->top_field_first = in_picture->top_field_first;
1463 pkt.data = (uint8_t *)final_picture;
1464 pkt.size = sizeof(AVPicture);
1465 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1466 pkt.flags |= AV_PKT_FLAG_KEY;
1468 write_frame(s, &pkt, ost);
1470 AVFrame big_picture;
1472 big_picture = *final_picture;
1473 /* better than nothing: use input picture interlaced
1475 big_picture.interlaced_frame = in_picture->interlaced_frame;
1476 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1477 if (ost->top_field_first == -1)
1478 big_picture.top_field_first = in_picture->top_field_first;
1480 big_picture.top_field_first = !!ost->top_field_first;
1483 /* handles same_quant here. This is not correct because it may
1484 not be a global option */
1485 big_picture.quality = quality;
1486 if (!enc->me_threshold)
1487 big_picture.pict_type = 0;
1488 // big_picture.pts = AV_NOPTS_VALUE;
1489 big_picture.pts = ost->sync_opts;
1490 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1491 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1492 if (ost->forced_kf_index < ost->forced_kf_count &&
1493 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1494 big_picture.pict_type = AV_PICTURE_TYPE_I;
1495 ost->forced_kf_index++;
1497 ret = avcodec_encode_video(enc,
1498 bit_buffer, bit_buffer_size,
1501 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1506 pkt.data = bit_buffer;
1508 if (enc->coded_frame->pts != AV_NOPTS_VALUE)
1509 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1510 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1511 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1512 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1514 if (enc->coded_frame->key_frame)
1515 pkt.flags |= AV_PKT_FLAG_KEY;
1516 write_frame(s, &pkt, ost);
1519 // fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1520 // enc->frame_number-1, ret, enc->pict_type);
1521 /* if two pass, output log */
1522 if (ost->logfile && enc->stats_out) {
1523 fprintf(ost->logfile, "%s", enc->stats_out);
1529 * For video, number of frames in == number of packets out.
1530 * But there may be reordering, so we can't throw away frames on encoder
1531 * flush, we need to limit them here, before they go into encoder.
1533 ost->frame_number++;
1537 static double psnr(double d)
1539 return -10.0 * log(d) / log(10.0);
1542 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1545 AVCodecContext *enc;
1547 double ti1, bitrate, avg_bitrate;
1549 /* this is executed just the first time do_video_stats is called */
1551 vstats_file = fopen(vstats_filename, "w");
1558 enc = ost->st->codec;
1559 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1560 frame_number = ost->frame_number;
1561 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1562 if (enc->flags&CODEC_FLAG_PSNR)
1563 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1565 fprintf(vstats_file,"f_size= %6d ", frame_size);
1566 /* compute pts value */
1567 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1571 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1572 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1573 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1574 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1575 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1579 static void print_report(OutputFile *output_files,
1580 OutputStream *ost_table, int nb_ostreams,
1581 int is_last_report, int64_t timer_start)
1585 AVFormatContext *oc;
1587 AVCodecContext *enc;
1588 int frame_number, vid, i;
1590 int64_t pts = INT64_MAX;
1591 static int64_t last_time = -1;
1592 static int qp_histogram[52];
1593 int hours, mins, secs, us;
1595 if (!print_stats && !is_last_report)
1598 if (!is_last_report) {
1600 /* display the report every 0.5 seconds */
1601 cur_time = av_gettime();
1602 if (last_time == -1) {
1603 last_time = cur_time;
1606 if ((cur_time - last_time) < 500000)
1608 last_time = cur_time;
1612 oc = output_files[0].ctx;
1614 total_size = avio_size(oc->pb);
1615 if (total_size < 0) // FIXME improve avio_size() so it works with non seekable output too
1616 total_size = avio_tell(oc->pb);
1620 for (i = 0; i < nb_ostreams; i++) {
1622 ost = &ost_table[i];
1623 enc = ost->st->codec;
1624 if (!ost->stream_copy && enc->coded_frame)
1625 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1626 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1627 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1629 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1630 float t = (av_gettime() - timer_start) / 1000000.0;
1632 frame_number = ost->frame_number;
1633 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1634 frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1636 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1640 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1642 for (j = 0; j < 32; j++)
1643 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1645 if (enc->flags&CODEC_FLAG_PSNR) {
1647 double error, error_sum = 0;
1648 double scale, scale_sum = 0;
1649 char type[3] = { 'Y','U','V' };
1650 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1651 for (j = 0; j < 3; j++) {
1652 if (is_last_report) {
1653 error = enc->error[j];
1654 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1656 error = enc->coded_frame->error[j];
1657 scale = enc->width * enc->height * 255.0 * 255.0;
1663 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1665 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1669 /* compute min output value */
1670 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1671 ost->st->time_base, AV_TIME_BASE_Q));
1674 secs = pts / AV_TIME_BASE;
1675 us = pts % AV_TIME_BASE;
1681 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1683 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1684 "size=%8.0fkB time=", total_size / 1024.0);
1685 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1686 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1687 (100 * us) / AV_TIME_BASE);
1688 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1689 "bitrate=%6.1fkbits/s", bitrate);
1691 if (nb_frames_dup || nb_frames_drop)
1692 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1693 nb_frames_dup, nb_frames_drop);
1695 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1699 if (is_last_report) {
1700 int64_t raw= audio_size + video_size + extra_size;
1701 av_log(NULL, AV_LOG_INFO, "\n");
1702 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1703 video_size / 1024.0,
1704 audio_size / 1024.0,
1705 extra_size / 1024.0,
1706 100.0 * (total_size - raw) / raw
1711 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1715 for (i = 0; i < nb_ostreams; i++) {
1716 OutputStream *ost = &ost_table[i];
1717 AVCodecContext *enc = ost->st->codec;
1718 AVFormatContext *os = output_files[ost->file_index].ctx;
1719 int stop_encoding = 0;
1721 if (!ost->encoding_needed)
1724 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1726 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1732 av_init_packet(&pkt);
1736 switch (ost->st->codec->codec_type) {
1737 case AVMEDIA_TYPE_AUDIO:
1738 fifo_bytes = av_fifo_size(ost->fifo);
1739 if (fifo_bytes > 0) {
1740 /* encode any samples remaining in fifo */
1741 int frame_bytes = fifo_bytes;
1743 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1745 /* pad last frame with silence if needed */
1746 if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
1747 frame_bytes = enc->frame_size * enc->channels *
1748 av_get_bytes_per_sample(enc->sample_fmt);
1749 if (allocated_audio_buf_size < frame_bytes)
1751 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1753 encode_audio_frame(os, ost, audio_buf, frame_bytes);
1755 /* flush encoder with NULL frames until it is done
1756 returning packets */
1757 if (encode_audio_frame(os, ost, NULL, 0) == 0) {
1763 case AVMEDIA_TYPE_VIDEO:
1764 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1766 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1770 if (enc->coded_frame && enc->coded_frame->key_frame)
1771 pkt.flags |= AV_PKT_FLAG_KEY;
1772 if (ost->logfile && enc->stats_out) {
1773 fprintf(ost->logfile, "%s", enc->stats_out);
1779 pkt.stream_index = ost->index;
1780 pkt.data = bit_buffer;
1782 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1783 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1784 write_frame(os, &pkt, ost);
1796 * Check whether a packet from ist should be written into ost at this time
1798 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1800 OutputFile *of = &output_files[ost->file_index];
1801 int ist_index = ist - input_streams;
1803 if (ost->source_index != ist_index)
1806 if (of->start_time && ist->pts < of->start_time)
1809 if (of->recording_time != INT64_MAX &&
1810 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1811 (AVRational){ 1, 1000000 }) >= 0) {
1812 ost->is_past_recording_time = 1;
1819 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1821 OutputFile *of = &output_files[ost->file_index];
1822 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1826 av_init_packet(&opkt);
1828 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1829 !ost->copy_initial_nonkeyframes)
1832 /* force the input stream PTS */
1833 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1834 audio_size += pkt->size;
1835 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1836 video_size += pkt->size;
1840 opkt.stream_index = ost->index;
1841 if (pkt->pts != AV_NOPTS_VALUE)
1842 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1844 opkt.pts = AV_NOPTS_VALUE;
1846 if (pkt->dts == AV_NOPTS_VALUE)
1847 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1849 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1850 opkt.dts -= ost_tb_start_time;
1852 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1853 opkt.flags = pkt->flags;
1855 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1856 if ( ost->st->codec->codec_id != CODEC_ID_H264
1857 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1858 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1860 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1861 opkt.destruct = av_destruct_packet;
1863 opkt.data = pkt->data;
1864 opkt.size = pkt->size;
1866 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1867 /* store AVPicture in AVPacket, as expected by the output format */
1868 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1869 opkt.data = (uint8_t *)&pict;
1870 opkt.size = sizeof(AVPicture);
1871 opkt.flags |= AV_PKT_FLAG_KEY;
1874 write_frame(of->ctx, &opkt, ost);
1875 ost->st->codec->frame_number++;
1876 av_free_packet(&opkt);
1879 static void rate_emu_sleep(InputStream *ist)
1881 if (input_files[ist->file_index].rate_emu) {
1882 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1883 int64_t now = av_gettime() - ist->start;
1889 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1891 AVFrame *decoded_frame;
1892 AVCodecContext *avctx = ist->st->codec;
1893 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1896 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1897 return AVERROR(ENOMEM);
1899 avcodec_get_frame_defaults(ist->decoded_frame);
1900 decoded_frame = ist->decoded_frame;
1902 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1908 /* no audio frame */
1912 /* if the decoder provides a pts, use it instead of the last packet pts.
1913 the decoder could be delaying output by a packet or more. */
1914 if (decoded_frame->pts != AV_NOPTS_VALUE)
1915 ist->next_pts = decoded_frame->pts;
1917 /* increment next_pts to use for the case where the input stream does not
1918 have timestamps or there are multiple frames in the packet */
1919 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1922 // preprocess audio (volume)
1923 if (audio_volume != 256) {
1924 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1925 void *samples = decoded_frame->data[0];
1926 switch (avctx->sample_fmt) {
1927 case AV_SAMPLE_FMT_U8:
1929 uint8_t *volp = samples;
1930 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1931 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1932 *volp++ = av_clip_uint8(v);
1936 case AV_SAMPLE_FMT_S16:
1938 int16_t *volp = samples;
1939 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1940 int v = ((*volp) * audio_volume + 128) >> 8;
1941 *volp++ = av_clip_int16(v);
1945 case AV_SAMPLE_FMT_S32:
1947 int32_t *volp = samples;
1948 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1949 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1950 *volp++ = av_clipl_int32(v);
1954 case AV_SAMPLE_FMT_FLT:
1956 float *volp = samples;
1957 float scale = audio_volume / 256.f;
1958 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1963 case AV_SAMPLE_FMT_DBL:
1965 double *volp = samples;
1966 double scale = audio_volume / 256.;
1967 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1973 av_log(NULL, AV_LOG_FATAL,
1974 "Audio volume adjustment on sample format %s is not supported.\n",
1975 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1980 rate_emu_sleep(ist);
1982 for (i = 0; i < nb_output_streams; i++) {
1983 OutputStream *ost = &output_streams[i];
1985 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1987 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
1993 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
1995 AVFrame *decoded_frame, *filtered_frame = NULL;
1996 void *buffer_to_free = NULL;
2000 int frame_available = 1;
2003 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2004 return AVERROR(ENOMEM);
2006 avcodec_get_frame_defaults(ist->decoded_frame);
2007 decoded_frame = ist->decoded_frame;
2008 pkt->pts = *pkt_pts;
2009 pkt->dts = ist->pts;
2010 *pkt_pts = AV_NOPTS_VALUE;
2012 ret = avcodec_decode_video2(ist->st->codec,
2013 decoded_frame, got_output, pkt);
2017 quality = same_quant ? decoded_frame->quality : 0;
2019 /* no picture yet */
2022 ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
2024 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2025 else if (ist->st->codec->time_base.num != 0) {
2026 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
2027 ist->st->codec->ticks_per_frame;
2028 ist->next_pts += ((int64_t)AV_TIME_BASE *
2029 ist->st->codec->time_base.num * ticks) /
2030 ist->st->codec->time_base.den;
2033 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2035 rate_emu_sleep(ist);
2037 for (i = 0; i < nb_output_streams; i++) {
2038 OutputStream *ost = &output_streams[i];
2039 int frame_size, resample_changed;
2041 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2045 resample_changed = ost->resample_width != decoded_frame->width ||
2046 ost->resample_height != decoded_frame->height ||
2047 ost->resample_pix_fmt != decoded_frame->format;
2048 if (resample_changed) {
2049 av_log(NULL, AV_LOG_INFO,
2050 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2051 ist->file_index, ist->st->index,
2052 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
2053 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2055 avfilter_graph_free(&ost->graph);
2056 if (configure_video_filters(ist, ost)) {
2057 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2061 ost->resample_width = decoded_frame->width;
2062 ost->resample_height = decoded_frame->height;
2063 ost->resample_pix_fmt = decoded_frame->format;
2066 if (!decoded_frame->sample_aspect_ratio.num)
2067 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2068 decoded_frame->pts = ist->pts;
2069 if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
2070 FrameBuffer *buf = decoded_frame->opaque;
2071 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2072 decoded_frame->data, decoded_frame->linesize,
2073 AV_PERM_READ | AV_PERM_PRESERVE,
2074 ist->st->codec->width, ist->st->codec->height,
2075 ist->st->codec->pix_fmt);
2077 avfilter_copy_frame_props(fb, decoded_frame);
2079 fb->buf->priv = buf;
2080 fb->buf->free = filter_release_buffer;
2083 av_buffersrc_buffer(ost->input_video_filter, fb);
2085 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
2087 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2088 av_free(buffer_to_free);
2089 return AVERROR(ENOMEM);
2091 avcodec_get_frame_defaults(ist->filtered_frame);
2092 filtered_frame = ist->filtered_frame;
2094 frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2095 while (frame_available) {
2096 if (ost->output_video_filter) {
2097 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
2098 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
2101 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
2102 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2105 if (ost->picref->video && !ost->frame_aspect_ratio)
2106 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
2108 filtered_frame = decoded_frame;
2111 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
2112 same_quant ? quality : ost->st->codec->global_quality);
2113 if (vstats_filename && frame_size)
2114 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
2117 frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2119 avfilter_unref_buffer(ost->picref);
2124 av_free(buffer_to_free);
2128 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2130 AVSubtitle subtitle;
2131 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2132 &subtitle, got_output, pkt);
2138 rate_emu_sleep(ist);
2140 for (i = 0; i < nb_output_streams; i++) {
2141 OutputStream *ost = &output_streams[i];
2143 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2146 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2149 avsubtitle_free(&subtitle);
2153 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2154 static int output_packet(InputStream *ist,
2155 OutputStream *ost_table, int nb_ostreams,
2156 const AVPacket *pkt)
2160 int64_t pkt_pts = AV_NOPTS_VALUE;
2163 if (ist->next_pts == AV_NOPTS_VALUE)
2164 ist->next_pts = ist->pts;
2168 av_init_packet(&avpkt);
2176 if (pkt->dts != AV_NOPTS_VALUE)
2177 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2178 if (pkt->pts != AV_NOPTS_VALUE)
2179 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2181 // while we have more to decode or while the decoder did output something on EOF
2182 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2186 ist->pts = ist->next_pts;
2188 if (avpkt.size && avpkt.size != pkt->size) {
2189 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2190 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2191 ist->showed_multi_packet_warning = 1;
2194 switch (ist->st->codec->codec_type) {
2195 case AVMEDIA_TYPE_AUDIO:
2196 ret = transcode_audio (ist, &avpkt, &got_output);
2198 case AVMEDIA_TYPE_VIDEO:
2199 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
2201 case AVMEDIA_TYPE_SUBTITLE:
2202 ret = transcode_subtitles(ist, &avpkt, &got_output);
2210 // touch data and size only if not EOF
2220 /* handle stream copy */
2221 if (!ist->decoding_needed) {
2222 rate_emu_sleep(ist);
2223 ist->pts = ist->next_pts;
2224 switch (ist->st->codec->codec_type) {
2225 case AVMEDIA_TYPE_AUDIO:
2226 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2227 ist->st->codec->sample_rate;
2229 case AVMEDIA_TYPE_VIDEO:
2230 if (ist->st->codec->time_base.num != 0) {
2231 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2232 ist->next_pts += ((int64_t)AV_TIME_BASE *
2233 ist->st->codec->time_base.num * ticks) /
2234 ist->st->codec->time_base.den;
2239 for (i = 0; pkt && i < nb_ostreams; i++) {
2240 OutputStream *ost = &ost_table[i];
2242 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2245 do_streamcopy(ist, ost, pkt);
2251 static void print_sdp(OutputFile *output_files, int n)
2255 AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2259 for (i = 0; i < n; i++)
2260 avc[i] = output_files[i].ctx;
2262 av_sdp_create(avc, n, sdp, sizeof(sdp));
2263 printf("SDP:\n%s\n", sdp);
2268 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2269 char *error, int error_len)
2272 InputStream *ist = &input_streams[ist_index];
2273 if (ist->decoding_needed) {
2274 AVCodec *codec = ist->dec;
2276 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
2277 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2278 return AVERROR(EINVAL);
2281 if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
2282 ist->st->codec->get_buffer = codec_get_buffer;
2283 ist->st->codec->release_buffer = codec_release_buffer;
2284 ist->st->codec->opaque = ist;
2287 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2288 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2289 ist->file_index, ist->st->index);
2290 return AVERROR(EINVAL);
2292 assert_codec_experimental(ist->st->codec, 0);
2293 assert_avoptions(ist->opts);
2296 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;
2297 ist->next_pts = AV_NOPTS_VALUE;
2303 static int transcode_init(OutputFile *output_files,
2304 int nb_output_files,
2305 InputFile *input_files,
2308 int ret = 0, i, j, k;
2309 AVFormatContext *oc;
2310 AVCodecContext *codec, *icodec;
2316 /* init framerate emulation */
2317 for (i = 0; i < nb_input_files; i++) {
2318 InputFile *ifile = &input_files[i];
2319 if (ifile->rate_emu)
2320 for (j = 0; j < ifile->nb_streams; j++)
2321 input_streams[j + ifile->ist_index].start = av_gettime();
2324 /* output stream init */
2325 for (i = 0; i < nb_output_files; i++) {
2326 oc = output_files[i].ctx;
2327 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2328 av_dump_format(oc, i, oc->filename, 1);
2329 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2330 return AVERROR(EINVAL);
2334 /* for each output stream, we compute the right encoding parameters */
2335 for (i = 0; i < nb_output_streams; i++) {
2336 ost = &output_streams[i];
2337 oc = output_files[ost->file_index].ctx;
2338 ist = &input_streams[ost->source_index];
2340 if (ost->attachment_filename)
2343 codec = ost->st->codec;
2344 icodec = ist->st->codec;
2346 ost->st->disposition = ist->st->disposition;
2347 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2348 codec->chroma_sample_location = icodec->chroma_sample_location;
2350 if (ost->stream_copy) {
2351 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2353 if (extra_size > INT_MAX) {
2354 return AVERROR(EINVAL);
2357 /* if stream_copy is selected, no need to decode or encode */
2358 codec->codec_id = icodec->codec_id;
2359 codec->codec_type = icodec->codec_type;
2361 if (!codec->codec_tag) {
2362 if (!oc->oformat->codec_tag ||
2363 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2364 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2365 codec->codec_tag = icodec->codec_tag;
2368 codec->bit_rate = icodec->bit_rate;
2369 codec->rc_max_rate = icodec->rc_max_rate;
2370 codec->rc_buffer_size = icodec->rc_buffer_size;
2371 codec->field_order = icodec->field_order;
2372 codec->extradata = av_mallocz(extra_size);
2373 if (!codec->extradata) {
2374 return AVERROR(ENOMEM);
2376 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2378 codec->extradata_size = icodec->extradata_size;
2380 codec->time_base = icodec->time_base;
2381 codec->time_base.num *= icodec->ticks_per_frame;
2382 av_reduce(&codec->time_base.num, &codec->time_base.den,
2383 codec->time_base.num, codec->time_base.den, INT_MAX);
2385 codec->time_base = ist->st->time_base;
2387 switch (codec->codec_type) {
2388 case AVMEDIA_TYPE_AUDIO:
2389 if (audio_volume != 256) {
2390 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2393 codec->channel_layout = icodec->channel_layout;
2394 codec->sample_rate = icodec->sample_rate;
2395 codec->channels = icodec->channels;
2396 codec->frame_size = icodec->frame_size;
2397 codec->audio_service_type = icodec->audio_service_type;
2398 codec->block_align = icodec->block_align;
2400 case AVMEDIA_TYPE_VIDEO:
2401 codec->pix_fmt = icodec->pix_fmt;
2402 codec->width = icodec->width;
2403 codec->height = icodec->height;
2404 codec->has_b_frames = icodec->has_b_frames;
2405 if (!codec->sample_aspect_ratio.num) {
2406 codec->sample_aspect_ratio =
2407 ost->st->sample_aspect_ratio =
2408 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2409 ist->st->codec->sample_aspect_ratio.num ?
2410 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2413 case AVMEDIA_TYPE_SUBTITLE:
2414 codec->width = icodec->width;
2415 codec->height = icodec->height;
2417 case AVMEDIA_TYPE_DATA:
2418 case AVMEDIA_TYPE_ATTACHMENT:
2425 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2427 ist->decoding_needed = 1;
2428 ost->encoding_needed = 1;
2430 switch (codec->codec_type) {
2431 case AVMEDIA_TYPE_AUDIO:
2432 ost->fifo = av_fifo_alloc(1024);
2434 return AVERROR(ENOMEM);
2436 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2438 if (!codec->sample_rate)
2439 codec->sample_rate = icodec->sample_rate;
2440 choose_sample_rate(ost->st, ost->enc);
2441 codec->time_base = (AVRational){ 1, codec->sample_rate };
2443 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2444 codec->sample_fmt = icodec->sample_fmt;
2445 choose_sample_fmt(ost->st, ost->enc);
2447 if (!codec->channels) {
2448 codec->channels = icodec->channels;
2449 codec->channel_layout = icodec->channel_layout;
2451 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2452 codec->channel_layout = 0;
2454 ost->audio_resample = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2455 icodec->request_channels = codec-> channels;
2456 ost->resample_sample_fmt = icodec->sample_fmt;
2457 ost->resample_sample_rate = icodec->sample_rate;
2458 ost->resample_channels = icodec->channels;
2460 case AVMEDIA_TYPE_VIDEO:
2461 if (codec->pix_fmt == PIX_FMT_NONE)
2462 codec->pix_fmt = icodec->pix_fmt;
2463 choose_pixel_fmt(ost->st, ost->enc);
2465 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2466 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2470 if (!codec->width || !codec->height) {
2471 codec->width = icodec->width;
2472 codec->height = icodec->height;
2475 ost->video_resample = codec->width != icodec->width ||
2476 codec->height != icodec->height ||
2477 codec->pix_fmt != icodec->pix_fmt;
2478 if (ost->video_resample) {
2479 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2482 ost->resample_height = icodec->height;
2483 ost->resample_width = icodec->width;
2484 ost->resample_pix_fmt = icodec->pix_fmt;
2486 if (!ost->frame_rate.num)
2487 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2488 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2489 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2490 ost->frame_rate = ost->enc->supported_framerates[idx];
2492 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2493 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2494 && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2495 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2496 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2500 if (configure_video_filters(ist, ost)) {
2501 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2506 case AVMEDIA_TYPE_SUBTITLE:
2513 if (codec->codec_id != CODEC_ID_H264 &&
2514 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2515 char logfilename[1024];
2518 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2519 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2521 if (codec->flags & CODEC_FLAG_PASS1) {
2522 f = fopen(logfilename, "wb");
2524 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2525 logfilename, strerror(errno));
2531 size_t logbuffer_size;
2532 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2533 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2537 codec->stats_in = logbuffer;
2541 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2542 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2543 int size = codec->width * codec->height;
2544 bit_buffer_size = FFMAX(bit_buffer_size, 6 * size + 1664);
2549 bit_buffer = av_malloc(bit_buffer_size);
2551 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2553 return AVERROR(ENOMEM);
2556 /* open each encoder */
2557 for (i = 0; i < nb_output_streams; i++) {
2558 ost = &output_streams[i];
2559 if (ost->encoding_needed) {
2560 AVCodec *codec = ost->enc;
2561 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2563 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2564 ost->st->codec->codec_id, ost->file_index, ost->index);
2565 ret = AVERROR(EINVAL);
2568 if (dec->subtitle_header) {
2569 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2570 if (!ost->st->codec->subtitle_header) {
2571 ret = AVERROR(ENOMEM);
2574 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2575 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2577 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2578 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2579 ost->file_index, ost->index);
2580 ret = AVERROR(EINVAL);
2583 assert_codec_experimental(ost->st->codec, 1);
2584 assert_avoptions(ost->opts);
2585 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2586 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2587 "It takes bits/s as argument, not kbits/s\n");
2588 extra_size += ost->st->codec->extradata_size;
2590 if (ost->st->codec->me_threshold)
2591 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2595 /* init input streams */
2596 for (i = 0; i < nb_input_streams; i++)
2597 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2600 /* discard unused programs */
2601 for (i = 0; i < nb_input_files; i++) {
2602 InputFile *ifile = &input_files[i];
2603 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2604 AVProgram *p = ifile->ctx->programs[j];
2605 int discard = AVDISCARD_ALL;
2607 for (k = 0; k < p->nb_stream_indexes; k++)
2608 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2609 discard = AVDISCARD_DEFAULT;
2612 p->discard = discard;
2616 /* open files and write file headers */
2617 for (i = 0; i < nb_output_files; i++) {
2618 oc = output_files[i].ctx;
2619 oc->interrupt_callback = int_cb;
2620 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2621 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2622 ret = AVERROR(EINVAL);
2625 // assert_avoptions(output_files[i].opts);
2626 if (strcmp(oc->oformat->name, "rtp")) {
2632 /* dump the file output parameters - cannot be done before in case
2634 for (i = 0; i < nb_output_files; i++) {
2635 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2638 /* dump the stream mapping */
2639 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2640 for (i = 0; i < nb_output_streams; i++) {
2641 ost = &output_streams[i];
2643 if (ost->attachment_filename) {
2644 /* an attached file */
2645 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2646 ost->attachment_filename, ost->file_index, ost->index);
2649 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2650 input_streams[ost->source_index].file_index,
2651 input_streams[ost->source_index].st->index,
2654 if (ost->sync_ist != &input_streams[ost->source_index])
2655 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2656 ost->sync_ist->file_index,
2657 ost->sync_ist->st->index);
2658 if (ost->stream_copy)
2659 av_log(NULL, AV_LOG_INFO, " (copy)");
2661 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2662 input_streams[ost->source_index].dec->name : "?",
2663 ost->enc ? ost->enc->name : "?");
2664 av_log(NULL, AV_LOG_INFO, "\n");
2668 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2673 print_sdp(output_files, nb_output_files);
2680 * The following code is the main loop of the file converter
2682 static int transcode(OutputFile *output_files,
2683 int nb_output_files,
2684 InputFile *input_files,
2688 AVFormatContext *is, *os;
2692 int no_packet_count = 0;
2693 int64_t timer_start;
2696 if (!(no_packet = av_mallocz(nb_input_files)))
2699 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2704 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2705 avio_set_interrupt_cb(decode_interrupt_cb);
2709 timer_start = av_gettime();
2711 for (; received_sigterm == 0;) {
2712 int file_index, ist_index;
2717 ipts_min = INT64_MAX;
2719 /* if 'q' pressed, exits */
2723 /* read_key() returns 0 on EOF */
2727 if (key == '+') av_log_set_level(av_log_get_level()+10);
2728 if (key == '-') av_log_set_level(av_log_get_level()-10);
2729 if (key == 's') qp_hist ^= 1;
2732 do_hex_dump = do_pkt_dump = 0;
2733 } else if(do_pkt_dump){
2737 av_log_set_level(AV_LOG_DEBUG);
2739 if (key == 'd' || key == 'D'){
2742 debug = input_streams[0].st->codec->debug<<1;
2743 if(!debug) debug = 1;
2744 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2747 scanf("%d", &debug);
2748 for(i=0;i<nb_input_streams;i++) {
2749 input_streams[i].st->codec->debug = debug;
2751 for(i=0;i<nb_output_streams;i++) {
2752 ost = &output_streams[i];
2753 ost->st->codec->debug = debug;
2755 if(debug) av_log_set_level(AV_LOG_DEBUG);
2756 fprintf(stderr,"debug=%d\n", debug);
2759 fprintf(stderr, "key function\n"
2760 "? show this help\n"
2761 "+ increase verbosity\n"
2762 "- decrease verbosity\n"
2763 "D cycle through available debug modes\n"
2764 "h dump packets/hex press to cycle through the 3 states\n"
2766 "s Show QP histogram\n"
2771 /* select the stream that we must read now by looking at the
2772 smallest output pts */
2774 for (i = 0; i < nb_output_streams; i++) {
2778 ost = &output_streams[i];
2779 of = &output_files[ost->file_index];
2780 os = output_files[ost->file_index].ctx;
2781 ist = &input_streams[ost->source_index];
2782 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2783 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2785 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2787 if (!input_files[ist->file_index].eof_reached) {
2788 if (ipts < ipts_min) {
2791 file_index = ist->file_index;
2793 if (opts < opts_min) {
2795 if (!input_sync) file_index = ist->file_index;
2798 if (ost->frame_number >= ost->max_frames) {
2800 for (j = 0; j < of->ctx->nb_streams; j++)
2801 output_streams[of->ost_index + j].is_past_recording_time = 1;
2805 /* if none, if is finished */
2806 if (file_index < 0) {
2807 if (no_packet_count) {
2808 no_packet_count = 0;
2809 memset(no_packet, 0, nb_input_files);
2816 /* read a frame from it and output it in the fifo */
2817 is = input_files[file_index].ctx;
2818 ret = av_read_frame(is, &pkt);
2819 if (ret == AVERROR(EAGAIN)) {
2820 no_packet[file_index] = 1;
2825 input_files[file_index].eof_reached = 1;
2832 no_packet_count = 0;
2833 memset(no_packet, 0, nb_input_files);
2836 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2837 is->streams[pkt.stream_index]);
2839 /* the following test is needed in case new streams appear
2840 dynamically in stream : we ignore them */
2841 if (pkt.stream_index >= input_files[file_index].nb_streams)
2842 goto discard_packet;
2843 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2844 ist = &input_streams[ist_index];
2846 goto discard_packet;
2848 if (pkt.dts != AV_NOPTS_VALUE)
2849 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2850 if (pkt.pts != AV_NOPTS_VALUE)
2851 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2853 if (pkt.pts != AV_NOPTS_VALUE)
2854 pkt.pts *= ist->ts_scale;
2855 if (pkt.dts != AV_NOPTS_VALUE)
2856 pkt.dts *= ist->ts_scale;
2858 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
2860 // pkt.dts, input_files[ist->file_index].ts_offset,
2861 // ist->st->codec->codec_type);
2862 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2863 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2864 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2865 int64_t delta = pkt_dts - ist->next_pts;
2866 if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->pts) && !copy_ts) {
2867 input_files[ist->file_index].ts_offset -= delta;
2868 av_log(NULL, AV_LOG_DEBUG,
2869 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2870 delta, input_files[ist->file_index].ts_offset);
2871 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2872 if (pkt.pts != AV_NOPTS_VALUE)
2873 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2877 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2878 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2880 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2881 ist->file_index, ist->st->index);
2884 av_free_packet(&pkt);
2889 av_free_packet(&pkt);
2891 /* dump report by using the output first video and audio streams */
2892 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2895 /* at the end of stream, we must flush the decoder buffers */
2896 for (i = 0; i < nb_input_streams; i++) {
2897 ist = &input_streams[i];
2898 if (ist->decoding_needed) {
2899 output_packet(ist, output_streams, nb_output_streams, NULL);
2902 flush_encoders(output_streams, nb_output_streams);
2906 /* write the trailer if needed and close file */
2907 for (i = 0; i < nb_output_files; i++) {
2908 os = output_files[i].ctx;
2909 av_write_trailer(os);
2912 /* dump report by using the first video and audio streams */
2913 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2915 /* close each encoder */
2916 for (i = 0; i < nb_output_streams; i++) {
2917 ost = &output_streams[i];
2918 if (ost->encoding_needed) {
2919 av_freep(&ost->st->codec->stats_in);
2920 avcodec_close(ost->st->codec);
2923 avfilter_graph_free(&ost->graph);
2927 /* close each decoder */
2928 for (i = 0; i < nb_input_streams; i++) {
2929 ist = &input_streams[i];
2930 if (ist->decoding_needed) {
2931 avcodec_close(ist->st->codec);
2939 av_freep(&bit_buffer);
2940 av_freep(&no_packet);
2942 if (output_streams) {
2943 for (i = 0; i < nb_output_streams; i++) {
2944 ost = &output_streams[i];
2946 if (ost->stream_copy)
2947 av_freep(&ost->st->codec->extradata);
2949 fclose(ost->logfile);
2950 ost->logfile = NULL;
2952 av_fifo_free(ost->fifo); /* works even if fifo is not
2953 initialized but set to zero */
2954 av_freep(&ost->st->codec->subtitle_header);
2955 av_free(ost->resample_frame.data[0]);
2956 av_free(ost->forced_kf_pts);
2957 if (ost->video_resample)
2958 sws_freeContext(ost->img_resample_ctx);
2960 audio_resample_close(ost->resample);
2961 if (ost->reformat_ctx)
2962 av_audio_convert_free(ost->reformat_ctx);
2963 av_dict_free(&ost->opts);
2970 static double parse_frame_aspect_ratio(const char *arg)
2977 p = strchr(arg, ':');
2979 x = strtol(arg, &end, 10);
2981 y = strtol(end + 1, &end, 10);
2983 ar = (double)x / (double)y;
2985 ar = strtod(arg, NULL);
2988 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2994 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2996 return parse_option(o, "codec:a", arg, options);
2999 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3001 return parse_option(o, "codec:v", arg, options);
3004 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3006 return parse_option(o, "codec:s", arg, options);
3009 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3011 return parse_option(o, "codec:d", arg, options);
3014 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3016 StreamMap *m = NULL;
3017 int i, negative = 0, file_idx;
3018 int sync_file_idx = -1, sync_stream_idx;
3026 map = av_strdup(arg);
3028 /* parse sync stream first, just pick first matching stream */
3029 if (sync = strchr(map, ',')) {
3031 sync_file_idx = strtol(sync + 1, &sync, 0);
3032 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3033 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3038 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
3039 if (check_stream_specifier(input_files[sync_file_idx].ctx,
3040 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
3041 sync_stream_idx = i;
3044 if (i == input_files[sync_file_idx].nb_streams) {
3045 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3046 "match any streams.\n", arg);
3052 file_idx = strtol(map, &p, 0);
3053 if (file_idx >= nb_input_files || file_idx < 0) {
3054 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3058 /* disable some already defined maps */
3059 for (i = 0; i < o->nb_stream_maps; i++) {
3060 m = &o->stream_maps[i];
3061 if (file_idx == m->file_index &&
3062 check_stream_specifier(input_files[m->file_index].ctx,
3063 input_files[m->file_index].ctx->streams[m->stream_index],
3064 *p == ':' ? p + 1 : p) > 0)
3068 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3069 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3070 *p == ':' ? p + 1 : p) <= 0)
3072 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3073 &o->nb_stream_maps, o->nb_stream_maps + 1);
3074 m = &o->stream_maps[o->nb_stream_maps - 1];
3076 m->file_index = file_idx;
3077 m->stream_index = i;
3079 if (sync_file_idx >= 0) {
3080 m->sync_file_index = sync_file_idx;
3081 m->sync_stream_index = sync_stream_idx;
3083 m->sync_file_index = file_idx;
3084 m->sync_stream_index = i;
3089 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3097 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3099 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3100 &o->nb_attachments, o->nb_attachments + 1);
3101 o->attachments[o->nb_attachments - 1] = arg;
3106 * Parse a metadata specifier in arg.
3107 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3108 * @param index for type c/p, chapter/program index is written here
3109 * @param stream_spec for type s, the stream specifier is written here
3111 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3119 if (*(++arg) && *arg != ':') {
3120 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3123 *stream_spec = *arg == ':' ? arg + 1 : "";
3127 if (*(++arg) == ':')
3128 *index = strtol(++arg, NULL, 0);
3131 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3138 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3140 AVDictionary **meta_in = NULL;
3141 AVDictionary **meta_out;
3143 char type_in, type_out;
3144 const char *istream_spec = NULL, *ostream_spec = NULL;
3145 int idx_in = 0, idx_out = 0;
3147 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3148 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3150 if (type_in == 'g' || type_out == 'g')
3151 o->metadata_global_manual = 1;
3152 if (type_in == 's' || type_out == 's')
3153 o->metadata_streams_manual = 1;
3154 if (type_in == 'c' || type_out == 'c')
3155 o->metadata_chapters_manual = 1;
3157 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3158 if ((index) < 0 || (index) >= (nb_elems)) {\
3159 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3164 #define SET_DICT(type, meta, context, index)\
3167 meta = &context->metadata;\
3170 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3171 meta = &context->chapters[index]->metadata;\
3174 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3175 meta = &context->programs[index]->metadata;\
3179 SET_DICT(type_in, meta_in, ic, idx_in);
3180 SET_DICT(type_out, meta_out, oc, idx_out);
3182 /* for input streams choose first matching stream */
3183 if (type_in == 's') {
3184 for (i = 0; i < ic->nb_streams; i++) {
3185 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3186 meta_in = &ic->streams[i]->metadata;
3192 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3197 if (type_out == 's') {
3198 for (i = 0; i < oc->nb_streams; i++) {
3199 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3200 meta_out = &oc->streams[i]->metadata;
3201 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3206 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3211 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3213 const char *codec_string = encoder ? "encoder" : "decoder";
3217 avcodec_find_encoder_by_name(name) :
3218 avcodec_find_decoder_by_name(name);
3220 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3223 if (codec->type != type) {
3224 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3230 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3232 char *codec_name = NULL;
3234 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3236 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3237 st->codec->codec_id = codec->id;
3240 return avcodec_find_decoder(st->codec->codec_id);
3244 * Add all the streams from the given input file to the global
3245 * list of input streams.
3247 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3251 for (i = 0; i < ic->nb_streams; i++) {
3252 AVStream *st = ic->streams[i];
3253 AVCodecContext *dec = st->codec;
3256 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3257 ist = &input_streams[nb_input_streams - 1];
3259 ist->file_index = nb_input_files;
3261 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3263 ist->ts_scale = 1.0;
3264 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3266 ist->dec = choose_decoder(o, ic, st);
3268 switch (dec->codec_type) {
3269 case AVMEDIA_TYPE_AUDIO:
3271 ist->dec = avcodec_find_decoder(dec->codec_id);
3272 if(o->audio_disable)
3273 st->discard = AVDISCARD_ALL;
3275 case AVMEDIA_TYPE_VIDEO:
3277 ist->dec = avcodec_find_decoder(dec->codec_id);
3279 dec->flags |= CODEC_FLAG_EMU_EDGE;
3282 if (o->video_disable)
3283 st->discard = AVDISCARD_ALL;
3284 else if (video_discard)
3285 st->discard = video_discard;
3287 case AVMEDIA_TYPE_DATA:
3289 case AVMEDIA_TYPE_SUBTITLE:
3291 ist->dec = avcodec_find_decoder(dec->codec_id);
3292 if(o->subtitle_disable)
3293 st->discard = AVDISCARD_ALL;
3295 case AVMEDIA_TYPE_ATTACHMENT:
3296 case AVMEDIA_TYPE_UNKNOWN:
3304 static void assert_file_overwrite(const char *filename)
3306 if ((!file_overwrite || no_file_overwrite) &&
3307 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3308 av_strstart(filename, "file:", NULL))) {
3309 if (avio_check(filename, 0) == 0) {
3310 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3311 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3313 if (!read_yesno()) {
3314 fprintf(stderr, "Not overwriting - exiting\n");
3319 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3326 static void dump_attachment(AVStream *st, const char *filename)
3329 AVIOContext *out = NULL;
3330 AVDictionaryEntry *e;
3332 if (!st->codec->extradata_size) {
3333 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3334 nb_input_files - 1, st->index);
3337 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3338 filename = e->value;
3340 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3341 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3345 assert_file_overwrite(filename);
3347 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3348 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3353 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3358 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3360 AVFormatContext *ic;
3361 AVInputFormat *file_iformat = NULL;
3365 AVDictionary **opts;
3366 int orig_nb_streams; // number of streams before avformat_find_stream_info
3369 if (!(file_iformat = av_find_input_format(o->format))) {
3370 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3375 if (!strcmp(filename, "-"))
3378 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3379 !strcmp(filename, "/dev/stdin");
3381 /* get default parameters from command line */
3382 ic = avformat_alloc_context();
3384 print_error(filename, AVERROR(ENOMEM));
3387 if (o->nb_audio_sample_rate) {
3388 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3389 av_dict_set(&format_opts, "sample_rate", buf, 0);
3391 if (o->nb_audio_channels) {
3392 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3393 av_dict_set(&format_opts, "channels", buf, 0);
3395 if (o->nb_frame_rates) {
3396 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3398 if (o->nb_frame_sizes) {
3399 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3401 if (o->nb_frame_pix_fmts)
3402 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3404 ic->flags |= AVFMT_FLAG_NONBLOCK;
3405 ic->interrupt_callback = int_cb;
3407 /* open the input file with generic avformat function */
3408 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3410 print_error(filename, err);
3413 assert_avoptions(format_opts);
3415 /* apply forced codec ids */
3416 for (i = 0; i < ic->nb_streams; i++)
3417 choose_decoder(o, ic, ic->streams[i]);
3419 /* Set AVCodecContext options for avformat_find_stream_info */
3420 opts = setup_find_stream_info_opts(ic, codec_opts);
3421 orig_nb_streams = ic->nb_streams;
3423 /* If not enough info to get the stream parameters, we decode the
3424 first frames to get it. (used in mpeg case for example) */
3425 ret = avformat_find_stream_info(ic, opts);
3427 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3428 avformat_close_input(&ic);
3432 timestamp = o->start_time;
3433 /* add the stream start time */
3434 if (ic->start_time != AV_NOPTS_VALUE)
3435 timestamp += ic->start_time;
3437 /* if seeking requested, we execute it */
3438 if (o->start_time != 0) {
3439 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3441 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3442 filename, (double)timestamp / AV_TIME_BASE);
3446 /* update the current parameters so that they match the one of the input stream */
3447 add_input_streams(o, ic);
3449 /* dump the file content */
3450 av_dump_format(ic, nb_input_files, filename, 0);
3452 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3453 input_files[nb_input_files - 1].ctx = ic;
3454 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3455 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3456 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3457 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3459 for (i = 0; i < o->nb_dump_attachment; i++) {
3462 for (j = 0; j < ic->nb_streams; j++) {
3463 AVStream *st = ic->streams[j];
3465 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3466 dump_attachment(st, o->dump_attachment[i].u.str);
3470 for (i = 0; i < orig_nb_streams; i++)
3471 av_dict_free(&opts[i]);
3478 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3479 AVCodecContext *avctx)
3485 for (p = kf; *p; p++)
3488 ost->forced_kf_count = n;
3489 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3490 if (!ost->forced_kf_pts) {
3491 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3494 for (i = 0; i < n; i++) {
3495 p = i ? strchr(p, ',') + 1 : kf;
3496 t = parse_time_or_die("force_key_frames", p, 1);
3497 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3501 static uint8_t *get_line(AVIOContext *s)
3507 if (avio_open_dyn_buf(&line) < 0) {
3508 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3512 while ((c = avio_r8(s)) && c != '\n')
3515 avio_close_dyn_buf(line, &buf);
3520 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3523 char filename[1000];
3524 const char *base[3] = { getenv("AVCONV_DATADIR"),
3529 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3533 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3534 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3535 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3538 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3539 i != 1 ? "" : "/.avconv", preset_name);
3540 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3546 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3548 char *codec_name = NULL;
3550 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3552 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3553 NULL, ost->st->codec->codec_type);
3554 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3555 } else if (!strcmp(codec_name, "copy"))
3556 ost->stream_copy = 1;
3558 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3559 ost->st->codec->codec_id = ost->enc->id;
3563 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3566 AVStream *st = avformat_new_stream(oc, NULL);
3567 int idx = oc->nb_streams - 1, ret = 0;
3568 char *bsf = NULL, *next, *codec_tag = NULL;
3569 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3571 char *buf = NULL, *arg = NULL, *preset = NULL;
3572 AVIOContext *s = NULL;
3575 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3579 if (oc->nb_streams - 1 < o->nb_streamid_map)
3580 st->id = o->streamid_map[oc->nb_streams - 1];
3582 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3583 nb_output_streams + 1);
3584 ost = &output_streams[nb_output_streams - 1];
3585 ost->file_index = nb_output_files;
3588 st->codec->codec_type = type;
3589 choose_encoder(o, oc, ost);
3591 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3594 avcodec_get_context_defaults3(st->codec, ost->enc);
3595 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3597 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3598 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3601 if (!buf[0] || buf[0] == '#') {
3605 if (!(arg = strchr(buf, '='))) {
3606 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3610 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3612 } while (!s->eof_reached);
3616 av_log(NULL, AV_LOG_FATAL,
3617 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3618 preset, ost->file_index, ost->index);
3622 ost->max_frames = INT64_MAX;
3623 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3625 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3627 if (next = strchr(bsf, ','))
3629 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3630 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3634 bsfc_prev->next = bsfc;
3636 ost->bitstream_filters = bsfc;
3642 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3644 uint32_t tag = strtol(codec_tag, &next, 0);
3646 tag = AV_RL32(codec_tag);
3647 st->codec->codec_tag = tag;
3650 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3651 if (qscale >= 0 || same_quant) {
3652 st->codec->flags |= CODEC_FLAG_QSCALE;
3653 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3656 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3657 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3659 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3663 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3666 const char *p = str;
3673 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3680 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3684 AVCodecContext *video_enc;
3686 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3688 video_enc = st->codec;
3690 if (!ost->stream_copy) {
3691 const char *p = NULL;
3692 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3693 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3694 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3697 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3698 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3699 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3703 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3704 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3705 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3709 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3710 if (frame_aspect_ratio)
3711 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3713 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3714 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3715 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3718 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3720 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3722 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3723 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3726 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3728 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3730 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3731 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3734 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3737 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3738 for (i = 0; p; i++) {
3740 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3742 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3745 video_enc->rc_override =
3746 av_realloc(video_enc->rc_override,
3747 sizeof(RcOverride) * (i + 1));
3748 video_enc->rc_override[i].start_frame = start;
3749 video_enc->rc_override[i].end_frame = end;
3751 video_enc->rc_override[i].qscale = q;
3752 video_enc->rc_override[i].quality_factor = 1.0;
3755 video_enc->rc_override[i].qscale = 0;
3756 video_enc->rc_override[i].quality_factor = -q/100.0;
3761 video_enc->rc_override_count = i;
3762 if (!video_enc->rc_initial_buffer_occupancy)
3763 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
3764 video_enc->intra_dc_precision = intra_dc_precision - 8;
3769 video_enc->flags |= CODEC_FLAG_PASS1;
3771 video_enc->flags |= CODEC_FLAG_PASS2;
3775 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3776 if (forced_key_frames)
3777 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3779 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3781 ost->top_field_first = -1;
3782 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3785 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3787 ost->avfilter = av_strdup(filters);
3790 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3796 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3800 AVCodecContext *audio_enc;
3802 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3805 audio_enc = st->codec;
3806 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3808 if (!ost->stream_copy) {
3809 char *sample_fmt = NULL;
3811 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3813 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3815 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3816 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3820 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3826 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3830 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3831 if (!ost->stream_copy) {
3832 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3839 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3841 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3842 ost->stream_copy = 1;
3846 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3850 AVCodecContext *subtitle_enc;
3852 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3854 subtitle_enc = st->codec;
3856 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3861 /* arg format is "output-stream-index:streamid-value". */
3862 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3868 av_strlcpy(idx_str, arg, sizeof(idx_str));
3869 p = strchr(idx_str, ':');
3871 av_log(NULL, AV_LOG_FATAL,
3872 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3877 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3878 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3879 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3883 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3885 AVFormatContext *is = ifile->ctx;
3886 AVFormatContext *os = ofile->ctx;
3889 for (i = 0; i < is->nb_chapters; i++) {
3890 AVChapter *in_ch = is->chapters[i], *out_ch;
3891 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3892 AV_TIME_BASE_Q, in_ch->time_base);
3893 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3894 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3897 if (in_ch->end < ts_off)
3899 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3902 out_ch = av_mallocz(sizeof(AVChapter));
3904 return AVERROR(ENOMEM);
3906 out_ch->id = in_ch->id;
3907 out_ch->time_base = in_ch->time_base;
3908 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3909 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3912 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3915 os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
3917 return AVERROR(ENOMEM);
3918 os->chapters[os->nb_chapters - 1] = out_ch;
3923 static void opt_output_file(void *optctx, const char *filename)
3925 OptionsContext *o = optctx;
3926 AVFormatContext *oc;
3928 AVOutputFormat *file_oformat;
3932 if (!strcmp(filename, "-"))
3935 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3937 print_error(filename, err);
3941 file_oformat= oc->oformat;
3942 oc->interrupt_callback = int_cb;
3944 if (!o->nb_stream_maps) {
3945 /* pick the "best" stream of each type */
3946 #define NEW_STREAM(type, index)\
3948 ost = new_ ## type ## _stream(o, oc);\
3949 ost->source_index = index;\
3950 ost->sync_ist = &input_streams[index];\
3951 input_streams[index].discard = 0;\
3954 /* video: highest resolution */
3955 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3956 int area = 0, idx = -1;
3957 for (i = 0; i < nb_input_streams; i++) {
3958 ist = &input_streams[i];
3959 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3960 ist->st->codec->width * ist->st->codec->height > area) {
3961 area = ist->st->codec->width * ist->st->codec->height;
3965 NEW_STREAM(video, idx);
3968 /* audio: most channels */
3969 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3970 int channels = 0, idx = -1;
3971 for (i = 0; i < nb_input_streams; i++) {
3972 ist = &input_streams[i];
3973 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3974 ist->st->codec->channels > channels) {
3975 channels = ist->st->codec->channels;
3979 NEW_STREAM(audio, idx);
3982 /* subtitles: pick first */
3983 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3984 for (i = 0; i < nb_input_streams; i++)
3985 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3986 NEW_STREAM(subtitle, i);
3990 /* do something with data? */
3992 for (i = 0; i < o->nb_stream_maps; i++) {
3993 StreamMap *map = &o->stream_maps[i];
3998 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3999 switch (ist->st->codec->codec_type) {
4000 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4001 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4002 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4003 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4004 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4006 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4007 map->file_index, map->stream_index);
4011 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4012 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4013 map->sync_stream_index];
4018 /* handle attached files */
4019 for (i = 0; i < o->nb_attachments; i++) {
4021 uint8_t *attachment;
4025 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4026 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4030 if ((len = avio_size(pb)) <= 0) {
4031 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4035 if (!(attachment = av_malloc(len))) {
4036 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4040 avio_read(pb, attachment, len);
4042 ost = new_attachment_stream(o, oc);
4043 ost->stream_copy = 0;
4044 ost->source_index = -1;
4045 ost->attachment_filename = o->attachments[i];
4046 ost->st->codec->extradata = attachment;
4047 ost->st->codec->extradata_size = len;
4049 p = strrchr(o->attachments[i], '/');
4050 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4054 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4055 output_files[nb_output_files - 1].ctx = oc;
4056 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4057 output_files[nb_output_files - 1].recording_time = o->recording_time;
4058 output_files[nb_output_files - 1].start_time = o->start_time;
4059 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4060 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4062 /* check filename in case of an image number is expected */
4063 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4064 if (!av_filename_number_test(oc->filename)) {
4065 print_error(oc->filename, AVERROR(EINVAL));
4070 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4071 /* test if it already exists to avoid losing precious files */
4072 assert_file_overwrite(filename);
4075 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4076 &oc->interrupt_callback,
4077 &output_files[nb_output_files - 1].opts)) < 0) {
4078 print_error(filename, err);
4083 if (o->mux_preload) {
4085 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4086 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4088 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4091 for (i = 0; i < o->nb_metadata_map; i++) {
4093 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4095 if (in_file_index < 0)
4097 if (in_file_index >= nb_input_files) {
4098 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4101 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4105 if (o->chapters_input_file >= nb_input_files) {
4106 if (o->chapters_input_file == INT_MAX) {
4107 /* copy chapters from the first input file that has them*/
4108 o->chapters_input_file = -1;
4109 for (i = 0; i < nb_input_files; i++)
4110 if (input_files[i].ctx->nb_chapters) {
4111 o->chapters_input_file = i;
4115 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4116 o->chapters_input_file);
4120 if (o->chapters_input_file >= 0)
4121 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4122 !o->metadata_chapters_manual);
4124 /* copy global metadata by default */
4125 if (!o->metadata_global_manual && nb_input_files)
4126 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4127 AV_DICT_DONT_OVERWRITE);
4128 if (!o->metadata_streams_manual)
4129 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4131 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4133 ist = &input_streams[output_streams[i].source_index];
4134 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4137 /* process manually set metadata */
4138 for (i = 0; i < o->nb_metadata; i++) {
4141 const char *stream_spec;
4142 int index = 0, j, ret;
4144 val = strchr(o->metadata[i].u.str, '=');
4146 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4147 o->metadata[i].u.str);
4152 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4154 for (j = 0; j < oc->nb_streams; j++) {
4155 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4156 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4160 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4168 if (index < 0 || index >= oc->nb_chapters) {
4169 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4172 m = &oc->chapters[index]->metadata;
4175 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4178 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4185 /* same option as mencoder */
4186 static int opt_pass(const char *opt, const char *arg)
4188 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4192 static int64_t getutime(void)
4195 struct rusage rusage;
4197 getrusage(RUSAGE_SELF, &rusage);
4198 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4199 #elif HAVE_GETPROCESSTIMES
4201 FILETIME c, e, k, u;
4202 proc = GetCurrentProcess();
4203 GetProcessTimes(proc, &c, &e, &k, &u);
4204 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4206 return av_gettime();
4210 static int64_t getmaxrss(void)
4212 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4213 struct rusage rusage;
4214 getrusage(RUSAGE_SELF, &rusage);
4215 return (int64_t)rusage.ru_maxrss * 1024;
4216 #elif HAVE_GETPROCESSMEMORYINFO
4218 PROCESS_MEMORY_COUNTERS memcounters;
4219 proc = GetCurrentProcess();
4220 memcounters.cb = sizeof(memcounters);
4221 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4222 return memcounters.PeakPagefileUsage;
4228 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4230 return parse_option(o, "q:a", arg, options);
4233 static void show_usage(void)
4235 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
4236 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4237 av_log(NULL, AV_LOG_INFO, "\n");
4240 static int opt_help(const char *opt, const char *arg)
4242 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4243 av_log_set_callback(log_callback_help);
4245 show_help_options(options, "Main options:\n",
4246 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4247 show_help_options(options, "\nAdvanced options:\n",
4248 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4250 show_help_options(options, "\nVideo options:\n",
4251 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4253 show_help_options(options, "\nAdvanced Video options:\n",
4254 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4255 OPT_VIDEO | OPT_EXPERT);
4256 show_help_options(options, "\nAudio options:\n",
4257 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4259 show_help_options(options, "\nAdvanced Audio options:\n",
4260 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4261 OPT_AUDIO | OPT_EXPERT);
4262 show_help_options(options, "\nSubtitle options:\n",
4263 OPT_SUBTITLE | OPT_GRAB,
4265 show_help_options(options, "\nAudio/Video grab options:\n",
4269 show_help_children(avcodec_get_class(), flags);
4270 show_help_children(avformat_get_class(), flags);
4271 show_help_children(sws_get_class(), flags);
4276 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4278 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4279 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4281 if (!strncmp(arg, "pal-", 4)) {
4284 } else if (!strncmp(arg, "ntsc-", 5)) {
4287 } else if (!strncmp(arg, "film-", 5)) {
4291 /* Try to determine PAL/NTSC by peeking in the input files */
4292 if (nb_input_files) {
4294 for (j = 0; j < nb_input_files; j++) {
4295 for (i = 0; i < input_files[j].nb_streams; i++) {
4296 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4297 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4299 fr = c->time_base.den * 1000 / c->time_base.num;
4303 } else if ((fr == 29970) || (fr == 23976)) {
4308 if (norm != UNKNOWN)
4312 if (norm != UNKNOWN)
4313 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4316 if (norm == UNKNOWN) {
4317 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4318 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4319 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4323 if (!strcmp(arg, "vcd")) {
4324 opt_video_codec(o, "c:v", "mpeg1video");
4325 opt_audio_codec(o, "c:a", "mp2");
4326 parse_option(o, "f", "vcd", options);
4328 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4329 parse_option(o, "r", frame_rates[norm], options);
4330 opt_default("g", norm == PAL ? "15" : "18");
4332 opt_default("b", "1150000");
4333 opt_default("maxrate", "1150000");
4334 opt_default("minrate", "1150000");
4335 opt_default("bufsize", "327680"); // 40*1024*8;
4337 opt_default("b:a", "224000");
4338 parse_option(o, "ar", "44100", options);
4339 parse_option(o, "ac", "2", options);
4341 opt_default("packetsize", "2324");
4342 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4344 /* We have to offset the PTS, so that it is consistent with the SCR.
4345 SCR starts at 36000, but the first two packs contain only padding
4346 and the first pack from the other stream, respectively, may also have
4347 been written before.
4348 So the real data starts at SCR 36000+3*1200. */
4349 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4350 } else if (!strcmp(arg, "svcd")) {
4352 opt_video_codec(o, "c:v", "mpeg2video");
4353 opt_audio_codec(o, "c:a", "mp2");
4354 parse_option(o, "f", "svcd", options);
4356 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4357 parse_option(o, "r", frame_rates[norm], options);
4358 opt_default("g", norm == PAL ? "15" : "18");
4360 opt_default("b", "2040000");
4361 opt_default("maxrate", "2516000");
4362 opt_default("minrate", "0"); // 1145000;
4363 opt_default("bufsize", "1835008"); // 224*1024*8;
4364 opt_default("flags", "+scan_offset");
4367 opt_default("b:a", "224000");
4368 parse_option(o, "ar", "44100", options);
4370 opt_default("packetsize", "2324");
4372 } else if (!strcmp(arg, "dvd")) {
4374 opt_video_codec(o, "c:v", "mpeg2video");
4375 opt_audio_codec(o, "c:a", "ac3");
4376 parse_option(o, "f", "dvd", options);
4378 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4379 parse_option(o, "r", frame_rates[norm], options);
4380 opt_default("g", norm == PAL ? "15" : "18");
4382 opt_default("b", "6000000");
4383 opt_default("maxrate", "9000000");
4384 opt_default("minrate", "0"); // 1500000;
4385 opt_default("bufsize", "1835008"); // 224*1024*8;
4387 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4388 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4390 opt_default("b:a", "448000");
4391 parse_option(o, "ar", "48000", options);
4393 } else if (!strncmp(arg, "dv", 2)) {
4395 parse_option(o, "f", "dv", options);
4397 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4398 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4399 norm == PAL ? "yuv420p" : "yuv411p", options);
4400 parse_option(o, "r", frame_rates[norm], options);
4402 parse_option(o, "ar", "48000", options);
4403 parse_option(o, "ac", "2", options);
4406 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4407 return AVERROR(EINVAL);
4412 static int opt_vstats_file(const char *opt, const char *arg)
4414 av_free (vstats_filename);
4415 vstats_filename = av_strdup (arg);
4419 static int opt_vstats(const char *opt, const char *arg)
4422 time_t today2 = time(NULL);
4423 struct tm *today = localtime(&today2);
4425 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4427 return opt_vstats_file(opt, filename);
4430 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4432 return parse_option(o, "frames:v", arg, options);
4435 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4437 return parse_option(o, "frames:a", arg, options);
4440 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4442 return parse_option(o, "frames:d", arg, options);
4445 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4449 static int opt_passlogfile(const char *opt, const char *arg)
4451 pass_logfilename_prefix = arg;
4452 #if CONFIG_LIBX264_ENCODER
4453 return opt_default("passlogfile", arg);
4459 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4461 return parse_option(o, "tag:v", arg, options);
4464 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4466 return parse_option(o, "tag:a", arg, options);
4469 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4471 return parse_option(o, "tag:s", arg, options);
4474 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4476 return parse_option(o, "filter:v", arg, options);
4479 static int opt_vsync(const char *opt, const char *arg)
4481 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
4482 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
4483 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4485 if (video_sync_method == VSYNC_AUTO)
4486 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4490 #define OFFSET(x) offsetof(OptionsContext, x)
4491 static const OptionDef options[] = {
4493 #include "cmdutils_common_opts.h"
4494 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4495 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4496 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4497 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4498 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4499 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4500 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4501 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4502 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4503 "outfile[,metadata]:infile[,metadata]" },
4504 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4505 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4506 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4507 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4508 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4509 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4510 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4511 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4512 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4513 "add timings for benchmarking" },
4514 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4515 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4516 "dump each input packet" },
4517 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4518 "when dumping packets, also dump the payload" },
4519 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4520 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4521 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4522 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4523 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4524 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4525 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4526 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4527 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4528 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4529 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4530 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4531 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4532 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4533 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4535 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4537 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4538 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4539 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4542 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4543 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4544 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4545 { "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" },
4546 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4547 { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4548 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4549 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4550 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4551 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4552 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4553 "use same quantizer as source (implies VBR)" },
4554 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4555 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4556 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4557 "deinterlace pictures" },
4558 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4559 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4561 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4563 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4564 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4565 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4566 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4567 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4568 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4569 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4570 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4571 { "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" },
4574 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4575 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4576 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4577 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4578 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4579 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4580 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4581 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4582 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4584 /* subtitle options */
4585 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4586 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4587 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4590 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4593 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4594 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4596 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4598 /* data codec support */
4599 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4601 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4605 int main(int argc, char **argv)
4607 OptionsContext o = { 0 };
4612 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4613 parse_loglevel(argc, argv, options);
4615 if(argc>1 && !strcmp(argv[1], "-d")){
4617 av_log_set_callback(log_callback_null);
4622 avcodec_register_all();
4624 avdevice_register_all();
4627 avfilter_register_all();
4630 avformat_network_init();
4632 show_banner(argc, argv, options);
4635 parse_options(&o, argc, argv, options, opt_output_file);
4637 if (nb_output_files <= 0 && nb_input_files == 0) {
4639 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4643 /* file converter / grab */
4644 if (nb_output_files <= 0) {
4645 fprintf(stderr, "At least one output file must be specified\n");
4649 if (nb_input_files == 0) {
4650 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4655 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4657 ti = getutime() - ti;
4659 int maxrss = getmaxrss() / 1024;
4660 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);