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 uint8_t *audio_out;
163 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
165 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
167 typedef struct FrameBuffer {
173 enum PixelFormat pix_fmt;
176 struct InputStream *ist;
177 struct FrameBuffer *next;
180 typedef struct InputStream {
183 int discard; /* true if stream data should be discarded */
184 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
186 AVFrame *decoded_frame;
187 AVFrame *filtered_frame;
189 int64_t start; /* time when read started */
190 int64_t next_pts; /* synthetic pts for cases where pkt.pts
192 int64_t pts; /* current pts */
194 int is_start; /* is 1 at the start and after a discontinuity */
195 int showed_multi_packet_warning;
198 /* a pool of free buffers for decoded data */
199 FrameBuffer *buffer_pool;
202 typedef struct InputFile {
203 AVFormatContext *ctx;
204 int eof_reached; /* true if eof reached */
205 int ist_index; /* index of first stream in ist_table */
206 int buffer_size; /* current total buffer size */
208 int nb_streams; /* number of stream that avconv is aware of; may be different
209 from ctx.nb_streams if new streams appear during av_read_frame() */
213 typedef struct OutputStream {
214 int file_index; /* file index */
215 int index; /* stream index in the output file */
216 int source_index; /* InputStream index */
217 AVStream *st; /* stream in the output file */
218 int encoding_needed; /* true if encoding needed for this stream */
220 /* input pts and corresponding output pts
222 // double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
223 struct InputStream *sync_ist; /* input stream to sync against */
224 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
225 AVBitStreamFilterContext *bitstream_filters;
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;
771 av_freep(&output_streams[i].avfilter);
774 for (i = 0; i < nb_input_files; i++) {
775 avformat_close_input(&input_files[i].ctx);
777 for (i = 0; i < nb_input_streams; i++) {
778 av_freep(&input_streams[i].decoded_frame);
779 av_freep(&input_streams[i].filtered_frame);
780 av_dict_free(&input_streams[i].opts);
781 free_buffer_pool(&input_streams[i]);
786 av_free(vstats_filename);
788 av_freep(&input_streams);
789 av_freep(&input_files);
790 av_freep(&output_streams);
791 av_freep(&output_files);
796 allocated_audio_buf_size = allocated_audio_out_size = 0;
801 avformat_network_deinit();
803 if (received_sigterm) {
804 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
805 (int) received_sigterm);
812 static void assert_avoptions(AVDictionary *m)
814 AVDictionaryEntry *t;
815 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
816 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
821 static void assert_codec_experimental(AVCodecContext *c, int encoder)
823 const char *codec_string = encoder ? "encoder" : "decoder";
825 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
826 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
827 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
828 "results.\nAdd '-strict experimental' if you want to use it.\n",
829 codec_string, c->codec->name);
830 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
831 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
832 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
833 codec_string, codec->name);
838 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
840 if (codec && codec->sample_fmts) {
841 const enum AVSampleFormat *p = codec->sample_fmts;
842 for (; *p != -1; p++) {
843 if (*p == st->codec->sample_fmt)
847 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
848 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
849 if(av_get_sample_fmt_name(st->codec->sample_fmt))
850 av_log(NULL, AV_LOG_WARNING,
851 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
852 av_get_sample_fmt_name(st->codec->sample_fmt),
854 av_get_sample_fmt_name(codec->sample_fmts[0]));
855 st->codec->sample_fmt = codec->sample_fmts[0];
860 static void choose_sample_rate(AVStream *st, AVCodec *codec)
862 if (codec && codec->supported_samplerates) {
863 const int *p = codec->supported_samplerates;
865 int best_dist = INT_MAX;
867 int dist = abs(st->codec->sample_rate - *p);
868 if (dist < best_dist) {
874 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
876 st->codec->sample_rate = best;
880 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
882 if (codec && codec->pix_fmts) {
883 const enum PixelFormat *p = codec->pix_fmts;
884 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
885 if (st->codec->codec_id == CODEC_ID_MJPEG) {
886 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
887 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
888 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
889 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
892 for (; *p != PIX_FMT_NONE; p++) {
893 if (*p == st->codec->pix_fmt)
896 if (*p == PIX_FMT_NONE) {
897 if (st->codec->pix_fmt != PIX_FMT_NONE)
898 av_log(NULL, AV_LOG_WARNING,
899 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
900 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
902 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
903 st->codec->pix_fmt = codec->pix_fmts[0];
909 get_sync_ipts(const OutputStream *ost)
911 const InputStream *ist = ost->sync_ist;
912 OutputFile *of = &output_files[ost->file_index];
913 return (double)(ist->pts - of->start_time) / AV_TIME_BASE;
916 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
918 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
919 AVCodecContext *avctx = ost->st->codec;
923 AVPacket new_pkt = *pkt;
924 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
925 &new_pkt.data, &new_pkt.size,
926 pkt->data, pkt->size,
927 pkt->flags & AV_PKT_FLAG_KEY);
930 new_pkt.destruct = av_destruct_packet;
932 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
933 bsfc->filter->name, pkt->stream_index,
934 avctx->codec ? avctx->codec->name : "copy");
944 ret = av_interleaved_write_frame(s, pkt);
946 print_error("av_interleaved_write_frame()", ret);
952 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
954 int fill_char = 0x00;
955 if (sample_fmt == AV_SAMPLE_FMT_U8)
957 memset(buf, fill_char, size);
960 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
961 InputStream *ist, AVFrame *decoded_frame)
964 int64_t audio_out_size, audio_buf_size;
966 int size_out, frame_bytes, ret, resample_changed;
967 AVCodecContext *enc = ost->st->codec;
968 AVCodecContext *dec = ist->st->codec;
969 int osize = av_get_bytes_per_sample(enc->sample_fmt);
970 int isize = av_get_bytes_per_sample(dec->sample_fmt);
971 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
972 uint8_t *buf = decoded_frame->data[0];
973 int size = decoded_frame->nb_samples * dec->channels * isize;
974 int64_t allocated_for_size = size;
977 audio_buf_size = (allocated_for_size + isize * dec->channels - 1) / (isize * dec->channels);
978 audio_buf_size = (audio_buf_size * enc->sample_rate + dec->sample_rate) / dec->sample_rate;
979 audio_buf_size = audio_buf_size * 2 + 10000; // safety factors for the deprecated resampling API
980 audio_buf_size = FFMAX(audio_buf_size, enc->frame_size);
981 audio_buf_size *= osize * enc->channels;
983 audio_out_size = FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
984 if (coded_bps > 8 * osize)
985 audio_out_size = audio_out_size * coded_bps / (8*osize);
986 audio_out_size += FF_MIN_BUFFER_SIZE;
988 if (audio_out_size > INT_MAX || audio_buf_size > INT_MAX) {
989 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
993 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
994 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
995 if (!audio_buf || !audio_out) {
996 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1000 if (enc->channels != dec->channels)
1001 ost->audio_resample = 1;
1003 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1004 ost->resample_channels != dec->channels ||
1005 ost->resample_sample_rate != dec->sample_rate;
1007 if ((ost->audio_resample && !ost->resample) || resample_changed) {
1008 if (resample_changed) {
1009 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",
1010 ist->file_index, ist->st->index,
1011 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
1012 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
1013 ost->resample_sample_fmt = dec->sample_fmt;
1014 ost->resample_channels = dec->channels;
1015 ost->resample_sample_rate = dec->sample_rate;
1017 audio_resample_close(ost->resample);
1019 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1020 if (audio_sync_method <= 1 &&
1021 ost->resample_sample_fmt == enc->sample_fmt &&
1022 ost->resample_channels == enc->channels &&
1023 ost->resample_sample_rate == enc->sample_rate) {
1024 ost->resample = NULL;
1025 ost->audio_resample = 0;
1027 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
1028 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
1029 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
1030 enc->sample_rate, dec->sample_rate,
1031 enc->sample_fmt, dec->sample_fmt,
1033 if (!ost->resample) {
1034 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1035 dec->channels, dec->sample_rate,
1036 enc->channels, enc->sample_rate);
1042 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
1043 if (!ost->audio_resample && dec->sample_fmt != enc->sample_fmt &&
1044 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt) != ost->reformat_pair) {
1045 if (ost->reformat_ctx)
1046 av_audio_convert_free(ost->reformat_ctx);
1047 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
1048 dec->sample_fmt, 1, NULL, 0);
1049 if (!ost->reformat_ctx) {
1050 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
1051 av_get_sample_fmt_name(dec->sample_fmt),
1052 av_get_sample_fmt_name(enc->sample_fmt));
1055 ost->reformat_pair = MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
1058 if (audio_sync_method) {
1059 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts -
1060 av_fifo_size(ost->fifo) / (enc->channels * osize);
1061 int idelta = delta * dec->sample_rate / enc->sample_rate;
1062 int byte_delta = idelta * isize * dec->channels;
1064 // FIXME resample delay
1065 if (fabs(delta) > 50) {
1066 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1067 if (byte_delta < 0) {
1068 byte_delta = FFMAX(byte_delta, -size);
1071 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1072 -byte_delta / (isize * dec->channels));
1077 static uint8_t *input_tmp = NULL;
1078 input_tmp = av_realloc(input_tmp, byte_delta + size);
1080 if (byte_delta > allocated_for_size - size) {
1081 allocated_for_size = byte_delta + (int64_t)size;
1086 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
1087 memcpy(input_tmp + byte_delta, buf, size);
1090 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1092 } else if (audio_sync_method > 1) {
1093 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1094 av_assert0(ost->audio_resample);
1095 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1096 delta, comp, enc->sample_rate);
1097 // 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));
1098 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
1102 ost->sync_opts = lrintf(get_sync_ipts(ost) * enc->sample_rate) -
1103 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1105 if (ost->audio_resample) {
1107 size_out = audio_resample(ost->resample,
1108 (short *)buftmp, (short *)buf,
1109 size / (dec->channels * isize));
1110 size_out = size_out * enc->channels * osize;
1116 if (!ost->audio_resample && dec->sample_fmt != enc->sample_fmt) {
1117 const void *ibuf[6] = { buftmp };
1118 void *obuf[6] = { audio_buf };
1119 int istride[6] = { isize };
1120 int ostride[6] = { osize };
1121 int len = size_out / istride[0];
1122 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len) < 0) {
1123 printf("av_audio_convert() failed\n");
1129 size_out = len * osize;
1132 /* now encode as many frames as possible */
1133 if (enc->frame_size > 1) {
1134 /* output resampled raw samples */
1135 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1136 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1139 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1141 frame_bytes = enc->frame_size * osize * enc->channels;
1143 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1145 av_init_packet(&pkt);
1147 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1149 // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1151 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1152 (short *)audio_buf);
1154 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1158 pkt.stream_index = ost->index;
1159 pkt.data = audio_out;
1161 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1162 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1163 pkt.flags |= AV_PKT_FLAG_KEY;
1164 write_frame(s, &pkt, ost);
1166 ost->sync_opts += enc->frame_size;
1170 av_init_packet(&pkt);
1172 ost->sync_opts += size_out / (osize * enc->channels);
1174 /* output a pcm frame */
1175 /* determine the size of the coded buffer */
1178 size_out = size_out * coded_bps / 8;
1180 if (size_out > audio_out_size) {
1181 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1185 // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1186 ret = avcodec_encode_audio(enc, audio_out, size_out,
1189 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1193 pkt.stream_index = ost->index;
1194 pkt.data = audio_out;
1196 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1197 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1198 pkt.flags |= AV_PKT_FLAG_KEY;
1199 write_frame(s, &pkt, ost);
1203 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1205 AVCodecContext *dec;
1206 AVPicture *picture2;
1207 AVPicture picture_tmp;
1210 dec = ist->st->codec;
1212 /* deinterlace : must be done before any resize */
1213 if (do_deinterlace) {
1216 /* create temporary picture */
1217 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1218 buf = av_malloc(size);
1222 picture2 = &picture_tmp;
1223 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1225 if (avpicture_deinterlace(picture2, picture,
1226 dec->pix_fmt, dec->width, dec->height) < 0) {
1227 /* if error, do not deinterlace */
1228 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1237 if (picture != picture2)
1238 *picture = *picture2;
1242 static void do_subtitle_out(AVFormatContext *s,
1248 static uint8_t *subtitle_out = NULL;
1249 int subtitle_out_max_size = 1024 * 1024;
1250 int subtitle_out_size, nb, i;
1251 AVCodecContext *enc;
1254 if (pts == AV_NOPTS_VALUE) {
1255 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1261 enc = ost->st->codec;
1263 if (!subtitle_out) {
1264 subtitle_out = av_malloc(subtitle_out_max_size);
1267 /* Note: DVB subtitle need one packet to draw them and one other
1268 packet to clear them */
1269 /* XXX: signal it in the codec context ? */
1270 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1275 for (i = 0; i < nb; i++) {
1276 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1277 // start_display_time is required to be 0
1278 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1279 sub->end_display_time -= sub->start_display_time;
1280 sub->start_display_time = 0;
1281 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1282 subtitle_out_max_size, sub);
1283 if (subtitle_out_size < 0) {
1284 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1288 av_init_packet(&pkt);
1289 pkt.stream_index = ost->index;
1290 pkt.data = subtitle_out;
1291 pkt.size = subtitle_out_size;
1292 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1293 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1294 /* XXX: the pts correction is handled here. Maybe handling
1295 it in the codec would be better */
1297 pkt.pts += 90 * sub->start_display_time;
1299 pkt.pts += 90 * sub->end_display_time;
1301 write_frame(s, &pkt, ost);
1305 static int bit_buffer_size = 1024 * 256;
1306 static uint8_t *bit_buffer = NULL;
1308 #if !CONFIG_AVFILTER
1309 static void do_video_resample(OutputStream *ost,
1311 AVFrame *in_picture,
1312 AVFrame **out_picture)
1314 int resample_changed = 0;
1315 AVCodecContext *dec = ist->st->codec;
1316 AVCodecContext *enc = ost->st->codec;
1317 *out_picture = in_picture;
1319 resample_changed = ost->resample_width != in_picture->width ||
1320 ost->resample_height != in_picture->height ||
1321 ost->resample_pix_fmt != in_picture->format;
1323 if (resample_changed) {
1324 av_log(NULL, AV_LOG_INFO,
1325 "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",
1326 ist->file_index, ist->st->index,
1327 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1328 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt),
1329 in_picture->width, in_picture->height, av_get_pix_fmt_name(in_picture->format));
1330 ost->resample_width = in_picture->width;
1331 ost->resample_height = in_picture->height;
1332 ost->resample_pix_fmt = in_picture->format;
1335 ost->video_resample = dec->width != enc->width ||
1336 dec->height != enc->height ||
1337 dec->pix_fmt != enc->pix_fmt;
1340 if (ost->video_resample) {
1341 *out_picture = &ost->resample_frame;
1342 if (!ost->img_resample_ctx || resample_changed) {
1343 /* initialize the destination picture */
1344 if (!ost->resample_frame.data[0]) {
1345 avcodec_get_frame_defaults(&ost->resample_frame);
1346 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1347 enc->width, enc->height)) {
1348 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1352 /* initialize a new scaler context */
1353 sws_freeContext(ost->img_resample_ctx);
1354 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1355 enc->width, enc->height, enc->pix_fmt,
1356 ost->sws_flags, NULL, NULL, NULL);
1357 if (ost->img_resample_ctx == NULL) {
1358 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1362 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1363 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1365 if (resample_changed) {
1366 ost->resample_width = in_picture->width;
1367 ost->resample_height = in_picture->height;
1368 ost->resample_pix_fmt = in_picture->format;
1374 static void do_video_out(AVFormatContext *s,
1377 AVFrame *in_picture,
1378 int *frame_size, float quality)
1380 int nb_frames, i, ret, format_video_sync;
1381 AVFrame *final_picture;
1382 AVCodecContext *enc;
1385 enc = ost->st->codec;
1387 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1389 /* by default, we output a single frame */
1394 format_video_sync = video_sync_method;
1395 if (format_video_sync == VSYNC_AUTO)
1396 format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
1397 (s->oformat->flags & AVFMT_VARIABLE_FPS) ? VSYNC_VFR : VSYNC_CFR;
1399 if (format_video_sync != VSYNC_PASSTHROUGH) {
1400 double vdelta = sync_ipts - ost->sync_opts;
1401 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1404 else if (format_video_sync == VSYNC_VFR) {
1405 if (vdelta <= -0.6) {
1407 } else if (vdelta > 0.6)
1408 ost->sync_opts = lrintf(sync_ipts);
1409 } else if (vdelta > 1.1)
1410 nb_frames = lrintf(vdelta);
1411 //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);
1412 if (nb_frames == 0) {
1414 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1415 } else if (nb_frames > 1) {
1416 nb_frames_dup += nb_frames - 1;
1417 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1420 ost->sync_opts = lrintf(sync_ipts);
1422 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1426 #if !CONFIG_AVFILTER
1427 do_video_resample(ost, ist, in_picture, &final_picture);
1429 final_picture = in_picture;
1432 /* duplicates frame if needed */
1433 for (i = 0; i < nb_frames; i++) {
1435 av_init_packet(&pkt);
1436 pkt.stream_index = ost->index;
1438 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1439 enc->codec->id == CODEC_ID_RAWVIDEO) {
1440 /* raw pictures are written as AVPicture structure to
1441 avoid any copies. We support temporarily the older
1443 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1444 enc->coded_frame->top_field_first = in_picture->top_field_first;
1445 pkt.data = (uint8_t *)final_picture;
1446 pkt.size = sizeof(AVPicture);
1447 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1448 pkt.flags |= AV_PKT_FLAG_KEY;
1450 write_frame(s, &pkt, ost);
1452 AVFrame big_picture;
1454 big_picture = *final_picture;
1455 /* better than nothing: use input picture interlaced
1457 big_picture.interlaced_frame = in_picture->interlaced_frame;
1458 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1459 if (ost->top_field_first == -1)
1460 big_picture.top_field_first = in_picture->top_field_first;
1462 big_picture.top_field_first = !!ost->top_field_first;
1465 /* handles same_quant here. This is not correct because it may
1466 not be a global option */
1467 big_picture.quality = quality;
1468 if (!enc->me_threshold)
1469 big_picture.pict_type = 0;
1470 // big_picture.pts = AV_NOPTS_VALUE;
1471 big_picture.pts = ost->sync_opts;
1472 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1473 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1474 if (ost->forced_kf_index < ost->forced_kf_count &&
1475 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1476 big_picture.pict_type = AV_PICTURE_TYPE_I;
1477 ost->forced_kf_index++;
1479 ret = avcodec_encode_video(enc,
1480 bit_buffer, bit_buffer_size,
1483 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1488 pkt.data = bit_buffer;
1490 if (enc->coded_frame->pts != AV_NOPTS_VALUE)
1491 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1492 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1493 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1494 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1496 if (enc->coded_frame->key_frame)
1497 pkt.flags |= AV_PKT_FLAG_KEY;
1498 write_frame(s, &pkt, ost);
1501 // fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1502 // enc->frame_number-1, ret, enc->pict_type);
1503 /* if two pass, output log */
1504 if (ost->logfile && enc->stats_out) {
1505 fprintf(ost->logfile, "%s", enc->stats_out);
1513 static double psnr(double d)
1515 return -10.0 * log(d) / log(10.0);
1518 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1521 AVCodecContext *enc;
1523 double ti1, bitrate, avg_bitrate;
1525 /* this is executed just the first time do_video_stats is called */
1527 vstats_file = fopen(vstats_filename, "w");
1534 enc = ost->st->codec;
1535 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1536 frame_number = ost->frame_number;
1537 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1538 if (enc->flags&CODEC_FLAG_PSNR)
1539 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1541 fprintf(vstats_file,"f_size= %6d ", frame_size);
1542 /* compute pts value */
1543 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1547 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1548 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1549 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1550 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1551 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1555 static void print_report(OutputFile *output_files,
1556 OutputStream *ost_table, int nb_ostreams,
1557 int is_last_report, int64_t timer_start)
1561 AVFormatContext *oc;
1563 AVCodecContext *enc;
1564 int frame_number, vid, i;
1566 int64_t pts = INT64_MAX;
1567 static int64_t last_time = -1;
1568 static int qp_histogram[52];
1569 int hours, mins, secs, us;
1571 if (!print_stats && !is_last_report)
1574 if (!is_last_report) {
1576 /* display the report every 0.5 seconds */
1577 cur_time = av_gettime();
1578 if (last_time == -1) {
1579 last_time = cur_time;
1582 if ((cur_time - last_time) < 500000)
1584 last_time = cur_time;
1588 oc = output_files[0].ctx;
1590 total_size = avio_size(oc->pb);
1591 if (total_size < 0) // FIXME improve avio_size() so it works with non seekable output too
1592 total_size = avio_tell(oc->pb);
1596 for (i = 0; i < nb_ostreams; i++) {
1598 ost = &ost_table[i];
1599 enc = ost->st->codec;
1600 if (!ost->stream_copy && enc->coded_frame)
1601 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1602 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1603 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1605 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1606 float t = (av_gettime() - timer_start) / 1000000.0;
1608 frame_number = ost->frame_number;
1609 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1610 frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1612 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1616 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1618 for (j = 0; j < 32; j++)
1619 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1621 if (enc->flags&CODEC_FLAG_PSNR) {
1623 double error, error_sum = 0;
1624 double scale, scale_sum = 0;
1625 char type[3] = { 'Y','U','V' };
1626 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1627 for (j = 0; j < 3; j++) {
1628 if (is_last_report) {
1629 error = enc->error[j];
1630 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1632 error = enc->coded_frame->error[j];
1633 scale = enc->width * enc->height * 255.0 * 255.0;
1639 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1641 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1645 /* compute min output value */
1646 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1647 ost->st->time_base, AV_TIME_BASE_Q));
1650 secs = pts / AV_TIME_BASE;
1651 us = pts % AV_TIME_BASE;
1657 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1659 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1660 "size=%8.0fkB time=", total_size / 1024.0);
1661 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1662 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1663 (100 * us) / AV_TIME_BASE);
1664 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1665 "bitrate=%6.1fkbits/s", bitrate);
1667 if (nb_frames_dup || nb_frames_drop)
1668 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1669 nb_frames_dup, nb_frames_drop);
1671 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1675 if (is_last_report) {
1676 int64_t raw= audio_size + video_size + extra_size;
1677 av_log(NULL, AV_LOG_INFO, "\n");
1678 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1679 video_size / 1024.0,
1680 audio_size / 1024.0,
1681 extra_size / 1024.0,
1682 100.0 * (total_size - raw) / raw
1687 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1691 for (i = 0; i < nb_ostreams; i++) {
1692 OutputStream *ost = &ost_table[i];
1693 AVCodecContext *enc = ost->st->codec;
1694 AVFormatContext *os = output_files[ost->file_index].ctx;
1696 if (!ost->encoding_needed)
1699 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1701 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1707 av_init_packet(&pkt);
1708 pkt.stream_index = ost->index;
1710 switch (ost->st->codec->codec_type) {
1711 case AVMEDIA_TYPE_AUDIO:
1712 fifo_bytes = av_fifo_size(ost->fifo);
1714 /* encode any samples remaining in fifo */
1715 if (fifo_bytes > 0) {
1716 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1717 int fs_tmp = enc->frame_size;
1719 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1720 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1721 enc->frame_size = fifo_bytes / (osize * enc->channels);
1723 int frame_bytes = enc->frame_size*osize*enc->channels;
1724 if (allocated_audio_buf_size < frame_bytes)
1726 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1729 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1730 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1731 ost->st->time_base.num, enc->sample_rate);
1732 enc->frame_size = fs_tmp;
1735 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1738 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1742 pkt.flags |= AV_PKT_FLAG_KEY;
1744 case AVMEDIA_TYPE_VIDEO:
1745 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1747 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1751 if (enc->coded_frame && enc->coded_frame->key_frame)
1752 pkt.flags |= AV_PKT_FLAG_KEY;
1753 if (ost->logfile && enc->stats_out) {
1754 fprintf(ost->logfile, "%s", enc->stats_out);
1763 pkt.data = bit_buffer;
1765 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1766 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1767 write_frame(os, &pkt, ost);
1773 * Check whether a packet from ist should be written into ost at this time
1775 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1777 OutputFile *of = &output_files[ost->file_index];
1778 int ist_index = ist - input_streams;
1780 if (ost->source_index != ist_index)
1783 if (of->start_time && ist->pts < of->start_time)
1786 if (of->recording_time != INT64_MAX &&
1787 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1788 (AVRational){ 1, 1000000 }) >= 0) {
1789 ost->is_past_recording_time = 1;
1796 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1798 OutputFile *of = &output_files[ost->file_index];
1799 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1803 av_init_packet(&opkt);
1805 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1806 !ost->copy_initial_nonkeyframes)
1809 /* force the input stream PTS */
1810 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1811 audio_size += pkt->size;
1812 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1813 video_size += pkt->size;
1817 opkt.stream_index = ost->index;
1818 if (pkt->pts != AV_NOPTS_VALUE)
1819 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1821 opkt.pts = AV_NOPTS_VALUE;
1823 if (pkt->dts == AV_NOPTS_VALUE)
1824 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1826 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1827 opkt.dts -= ost_tb_start_time;
1829 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1830 opkt.flags = pkt->flags;
1832 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1833 if ( ost->st->codec->codec_id != CODEC_ID_H264
1834 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1835 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1837 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1838 opkt.destruct = av_destruct_packet;
1840 opkt.data = pkt->data;
1841 opkt.size = pkt->size;
1843 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1844 /* store AVPicture in AVPacket, as expected by the output format */
1845 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1846 opkt.data = (uint8_t *)&pict;
1847 opkt.size = sizeof(AVPicture);
1848 opkt.flags |= AV_PKT_FLAG_KEY;
1851 write_frame(of->ctx, &opkt, ost);
1852 ost->st->codec->frame_number++;
1853 av_free_packet(&opkt);
1856 static void rate_emu_sleep(InputStream *ist)
1858 if (input_files[ist->file_index].rate_emu) {
1859 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1860 int64_t now = av_gettime() - ist->start;
1866 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1868 AVFrame *decoded_frame;
1869 AVCodecContext *avctx = ist->st->codec;
1870 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1873 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1874 return AVERROR(ENOMEM);
1876 avcodec_get_frame_defaults(ist->decoded_frame);
1877 decoded_frame = ist->decoded_frame;
1879 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1885 /* no audio frame */
1889 /* if the decoder provides a pts, use it instead of the last packet pts.
1890 the decoder could be delaying output by a packet or more. */
1891 if (decoded_frame->pts != AV_NOPTS_VALUE)
1892 ist->next_pts = decoded_frame->pts;
1894 /* increment next_pts to use for the case where the input stream does not
1895 have timestamps or there are multiple frames in the packet */
1896 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1899 // preprocess audio (volume)
1900 if (audio_volume != 256) {
1901 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1902 void *samples = decoded_frame->data[0];
1903 switch (avctx->sample_fmt) {
1904 case AV_SAMPLE_FMT_U8:
1906 uint8_t *volp = samples;
1907 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1908 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1909 *volp++ = av_clip_uint8(v);
1913 case AV_SAMPLE_FMT_S16:
1915 int16_t *volp = samples;
1916 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1917 int v = ((*volp) * audio_volume + 128) >> 8;
1918 *volp++ = av_clip_int16(v);
1922 case AV_SAMPLE_FMT_S32:
1924 int32_t *volp = samples;
1925 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1926 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1927 *volp++ = av_clipl_int32(v);
1931 case AV_SAMPLE_FMT_FLT:
1933 float *volp = samples;
1934 float scale = audio_volume / 256.f;
1935 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1940 case AV_SAMPLE_FMT_DBL:
1942 double *volp = samples;
1943 double scale = audio_volume / 256.;
1944 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1950 av_log(NULL, AV_LOG_FATAL,
1951 "Audio volume adjustment on sample format %s is not supported.\n",
1952 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1957 rate_emu_sleep(ist);
1959 for (i = 0; i < nb_output_streams; i++) {
1960 OutputStream *ost = &output_streams[i];
1962 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1964 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
1970 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
1972 AVFrame *decoded_frame, *filtered_frame = NULL;
1973 void *buffer_to_free = NULL;
1977 int frame_available = 1;
1980 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1981 return AVERROR(ENOMEM);
1983 avcodec_get_frame_defaults(ist->decoded_frame);
1984 decoded_frame = ist->decoded_frame;
1985 pkt->pts = *pkt_pts;
1986 pkt->dts = ist->pts;
1987 *pkt_pts = AV_NOPTS_VALUE;
1989 ret = avcodec_decode_video2(ist->st->codec,
1990 decoded_frame, got_output, pkt);
1994 quality = same_quant ? decoded_frame->quality : 0;
1996 /* no picture yet */
1999 ist->next_pts = ist->pts = decoded_frame->best_effort_timestamp;
2001 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2002 else if (ist->st->codec->time_base.num != 0) {
2003 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
2004 ist->st->codec->ticks_per_frame;
2005 ist->next_pts += ((int64_t)AV_TIME_BASE *
2006 ist->st->codec->time_base.num * ticks) /
2007 ist->st->codec->time_base.den;
2010 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2012 rate_emu_sleep(ist);
2014 for (i = 0; i < nb_output_streams; i++) {
2015 OutputStream *ost = &output_streams[i];
2016 int frame_size, resample_changed;
2018 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2022 resample_changed = ost->resample_width != decoded_frame->width ||
2023 ost->resample_height != decoded_frame->height ||
2024 ost->resample_pix_fmt != decoded_frame->format;
2025 if (resample_changed) {
2026 av_log(NULL, AV_LOG_INFO,
2027 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
2028 ist->file_index, ist->st->index,
2029 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
2030 decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
2032 avfilter_graph_free(&ost->graph);
2033 if (configure_video_filters(ist, ost)) {
2034 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
2038 ost->resample_width = decoded_frame->width;
2039 ost->resample_height = decoded_frame->height;
2040 ost->resample_pix_fmt = decoded_frame->format;
2043 if (!decoded_frame->sample_aspect_ratio.num)
2044 decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2045 decoded_frame->pts = ist->pts;
2046 if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1) {
2047 FrameBuffer *buf = decoded_frame->opaque;
2048 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2049 decoded_frame->data, decoded_frame->linesize,
2050 AV_PERM_READ | AV_PERM_PRESERVE,
2051 ist->st->codec->width, ist->st->codec->height,
2052 ist->st->codec->pix_fmt);
2054 avfilter_copy_frame_props(fb, decoded_frame);
2056 fb->buf->priv = buf;
2057 fb->buf->free = filter_release_buffer;
2060 av_buffersrc_buffer(ost->input_video_filter, fb);
2062 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE);
2064 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2065 av_free(buffer_to_free);
2066 return AVERROR(ENOMEM);
2068 avcodec_get_frame_defaults(ist->filtered_frame);
2069 filtered_frame = ist->filtered_frame;
2071 frame_available = avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2072 while (frame_available) {
2073 if (ost->output_video_filter) {
2074 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
2075 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
2078 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
2079 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2082 if (ost->picref->video && !ost->frame_aspect_ratio)
2083 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
2085 filtered_frame = decoded_frame;
2088 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
2089 same_quant ? quality : ost->st->codec->global_quality);
2090 if (vstats_filename && frame_size)
2091 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
2094 frame_available = ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
2096 avfilter_unref_buffer(ost->picref);
2101 av_free(buffer_to_free);
2105 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2107 AVSubtitle subtitle;
2108 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2109 &subtitle, got_output, pkt);
2115 rate_emu_sleep(ist);
2117 for (i = 0; i < nb_output_streams; i++) {
2118 OutputStream *ost = &output_streams[i];
2120 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2123 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2126 avsubtitle_free(&subtitle);
2130 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2131 static int output_packet(InputStream *ist,
2132 OutputStream *ost_table, int nb_ostreams,
2133 const AVPacket *pkt)
2137 int64_t pkt_pts = AV_NOPTS_VALUE;
2140 if (ist->next_pts == AV_NOPTS_VALUE)
2141 ist->next_pts = ist->pts;
2145 av_init_packet(&avpkt);
2153 if (pkt->dts != AV_NOPTS_VALUE)
2154 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2155 if (pkt->pts != AV_NOPTS_VALUE)
2156 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2158 // while we have more to decode or while the decoder did output something on EOF
2159 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2163 ist->pts = ist->next_pts;
2165 if (avpkt.size && avpkt.size != pkt->size) {
2166 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2167 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2168 ist->showed_multi_packet_warning = 1;
2171 switch (ist->st->codec->codec_type) {
2172 case AVMEDIA_TYPE_AUDIO:
2173 ret = transcode_audio (ist, &avpkt, &got_output);
2175 case AVMEDIA_TYPE_VIDEO:
2176 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
2178 case AVMEDIA_TYPE_SUBTITLE:
2179 ret = transcode_subtitles(ist, &avpkt, &got_output);
2187 // touch data and size only if not EOF
2197 /* handle stream copy */
2198 if (!ist->decoding_needed) {
2199 rate_emu_sleep(ist);
2200 ist->pts = ist->next_pts;
2201 switch (ist->st->codec->codec_type) {
2202 case AVMEDIA_TYPE_AUDIO:
2203 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2204 ist->st->codec->sample_rate;
2206 case AVMEDIA_TYPE_VIDEO:
2207 if (ist->st->codec->time_base.num != 0) {
2208 int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2209 ist->next_pts += ((int64_t)AV_TIME_BASE *
2210 ist->st->codec->time_base.num * ticks) /
2211 ist->st->codec->time_base.den;
2216 for (i = 0; pkt && i < nb_ostreams; i++) {
2217 OutputStream *ost = &ost_table[i];
2219 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2222 do_streamcopy(ist, ost, pkt);
2228 static void print_sdp(OutputFile *output_files, int n)
2232 AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2236 for (i = 0; i < n; i++)
2237 avc[i] = output_files[i].ctx;
2239 av_sdp_create(avc, n, sdp, sizeof(sdp));
2240 printf("SDP:\n%s\n", sdp);
2245 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2246 char *error, int error_len)
2249 InputStream *ist = &input_streams[ist_index];
2250 if (ist->decoding_needed) {
2251 AVCodec *codec = ist->dec;
2253 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
2254 ist->st->codec->codec_id, ist->file_index, ist->st->index);
2255 return AVERROR(EINVAL);
2258 if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
2259 ist->st->codec->get_buffer = codec_get_buffer;
2260 ist->st->codec->release_buffer = codec_release_buffer;
2261 ist->st->codec->opaque = ist;
2264 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2265 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2266 ist->file_index, ist->st->index);
2267 return AVERROR(EINVAL);
2269 assert_codec_experimental(ist->st->codec, 0);
2270 assert_avoptions(ist->opts);
2273 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;
2274 ist->next_pts = AV_NOPTS_VALUE;
2280 static int transcode_init(OutputFile *output_files,
2281 int nb_output_files,
2282 InputFile *input_files,
2285 int ret = 0, i, j, k;
2286 AVFormatContext *oc;
2287 AVCodecContext *codec, *icodec;
2293 /* init framerate emulation */
2294 for (i = 0; i < nb_input_files; i++) {
2295 InputFile *ifile = &input_files[i];
2296 if (ifile->rate_emu)
2297 for (j = 0; j < ifile->nb_streams; j++)
2298 input_streams[j + ifile->ist_index].start = av_gettime();
2301 /* output stream init */
2302 for (i = 0; i < nb_output_files; i++) {
2303 oc = output_files[i].ctx;
2304 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2305 av_dump_format(oc, i, oc->filename, 1);
2306 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2307 return AVERROR(EINVAL);
2311 /* for each output stream, we compute the right encoding parameters */
2312 for (i = 0; i < nb_output_streams; i++) {
2313 ost = &output_streams[i];
2314 oc = output_files[ost->file_index].ctx;
2315 ist = &input_streams[ost->source_index];
2317 if (ost->attachment_filename)
2320 codec = ost->st->codec;
2321 icodec = ist->st->codec;
2323 ost->st->disposition = ist->st->disposition;
2324 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2325 codec->chroma_sample_location = icodec->chroma_sample_location;
2327 if (ost->stream_copy) {
2328 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2330 if (extra_size > INT_MAX) {
2331 return AVERROR(EINVAL);
2334 /* if stream_copy is selected, no need to decode or encode */
2335 codec->codec_id = icodec->codec_id;
2336 codec->codec_type = icodec->codec_type;
2338 if (!codec->codec_tag) {
2339 if (!oc->oformat->codec_tag ||
2340 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2341 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2342 codec->codec_tag = icodec->codec_tag;
2345 codec->bit_rate = icodec->bit_rate;
2346 codec->rc_max_rate = icodec->rc_max_rate;
2347 codec->rc_buffer_size = icodec->rc_buffer_size;
2348 codec->field_order = icodec->field_order;
2349 codec->extradata = av_mallocz(extra_size);
2350 if (!codec->extradata) {
2351 return AVERROR(ENOMEM);
2353 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2355 codec->extradata_size = icodec->extradata_size;
2357 codec->time_base = icodec->time_base;
2358 codec->time_base.num *= icodec->ticks_per_frame;
2359 av_reduce(&codec->time_base.num, &codec->time_base.den,
2360 codec->time_base.num, codec->time_base.den, INT_MAX);
2362 codec->time_base = ist->st->time_base;
2364 switch (codec->codec_type) {
2365 case AVMEDIA_TYPE_AUDIO:
2366 if (audio_volume != 256) {
2367 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2370 codec->channel_layout = icodec->channel_layout;
2371 codec->sample_rate = icodec->sample_rate;
2372 codec->channels = icodec->channels;
2373 codec->frame_size = icodec->frame_size;
2374 codec->audio_service_type = icodec->audio_service_type;
2375 codec->block_align = icodec->block_align;
2377 case AVMEDIA_TYPE_VIDEO:
2378 codec->pix_fmt = icodec->pix_fmt;
2379 codec->width = icodec->width;
2380 codec->height = icodec->height;
2381 codec->has_b_frames = icodec->has_b_frames;
2382 if (!codec->sample_aspect_ratio.num) {
2383 codec->sample_aspect_ratio =
2384 ost->st->sample_aspect_ratio =
2385 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2386 ist->st->codec->sample_aspect_ratio.num ?
2387 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2390 case AVMEDIA_TYPE_SUBTITLE:
2391 codec->width = icodec->width;
2392 codec->height = icodec->height;
2394 case AVMEDIA_TYPE_DATA:
2395 case AVMEDIA_TYPE_ATTACHMENT:
2402 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2404 ist->decoding_needed = 1;
2405 ost->encoding_needed = 1;
2407 switch (codec->codec_type) {
2408 case AVMEDIA_TYPE_AUDIO:
2409 ost->fifo = av_fifo_alloc(1024);
2411 return AVERROR(ENOMEM);
2413 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2415 if (!codec->sample_rate)
2416 codec->sample_rate = icodec->sample_rate;
2417 choose_sample_rate(ost->st, ost->enc);
2418 codec->time_base = (AVRational){ 1, codec->sample_rate };
2420 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2421 codec->sample_fmt = icodec->sample_fmt;
2422 choose_sample_fmt(ost->st, ost->enc);
2424 if (!codec->channels) {
2425 codec->channels = icodec->channels;
2426 codec->channel_layout = icodec->channel_layout;
2428 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2429 codec->channel_layout = 0;
2431 ost->audio_resample = codec-> sample_rate != icodec->sample_rate || audio_sync_method > 1;
2432 icodec->request_channels = codec-> channels;
2433 ost->resample_sample_fmt = icodec->sample_fmt;
2434 ost->resample_sample_rate = icodec->sample_rate;
2435 ost->resample_channels = icodec->channels;
2437 case AVMEDIA_TYPE_VIDEO:
2438 if (codec->pix_fmt == PIX_FMT_NONE)
2439 codec->pix_fmt = icodec->pix_fmt;
2440 choose_pixel_fmt(ost->st, ost->enc);
2442 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2443 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2447 if (!codec->width || !codec->height) {
2448 codec->width = icodec->width;
2449 codec->height = icodec->height;
2452 ost->video_resample = codec->width != icodec->width ||
2453 codec->height != icodec->height ||
2454 codec->pix_fmt != icodec->pix_fmt;
2455 if (ost->video_resample) {
2456 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2459 ost->resample_height = icodec->height;
2460 ost->resample_width = icodec->width;
2461 ost->resample_pix_fmt = icodec->pix_fmt;
2463 if (!ost->frame_rate.num)
2464 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2465 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2466 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2467 ost->frame_rate = ost->enc->supported_framerates[idx];
2469 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2470 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2471 && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2472 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2473 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2477 if (configure_video_filters(ist, ost)) {
2478 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2483 case AVMEDIA_TYPE_SUBTITLE:
2490 if (codec->codec_id != CODEC_ID_H264 &&
2491 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2492 char logfilename[1024];
2495 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2496 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2498 if (codec->flags & CODEC_FLAG_PASS1) {
2499 f = fopen(logfilename, "wb");
2501 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2502 logfilename, strerror(errno));
2508 size_t logbuffer_size;
2509 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2510 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2514 codec->stats_in = logbuffer;
2518 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2519 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2520 int size = codec->width * codec->height;
2521 bit_buffer_size = FFMAX(bit_buffer_size, 6 * size + 1664);
2526 bit_buffer = av_malloc(bit_buffer_size);
2528 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2530 return AVERROR(ENOMEM);
2533 /* open each encoder */
2534 for (i = 0; i < nb_output_streams; i++) {
2535 ost = &output_streams[i];
2536 if (ost->encoding_needed) {
2537 AVCodec *codec = ost->enc;
2538 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2540 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d:%d",
2541 ost->st->codec->codec_id, ost->file_index, ost->index);
2542 ret = AVERROR(EINVAL);
2545 if (dec->subtitle_header) {
2546 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2547 if (!ost->st->codec->subtitle_header) {
2548 ret = AVERROR(ENOMEM);
2551 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2552 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2554 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2555 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2556 ost->file_index, ost->index);
2557 ret = AVERROR(EINVAL);
2560 assert_codec_experimental(ost->st->codec, 1);
2561 assert_avoptions(ost->opts);
2562 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2563 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2564 "It takes bits/s as argument, not kbits/s\n");
2565 extra_size += ost->st->codec->extradata_size;
2567 if (ost->st->codec->me_threshold)
2568 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2572 /* init input streams */
2573 for (i = 0; i < nb_input_streams; i++)
2574 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2577 /* discard unused programs */
2578 for (i = 0; i < nb_input_files; i++) {
2579 InputFile *ifile = &input_files[i];
2580 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2581 AVProgram *p = ifile->ctx->programs[j];
2582 int discard = AVDISCARD_ALL;
2584 for (k = 0; k < p->nb_stream_indexes; k++)
2585 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2586 discard = AVDISCARD_DEFAULT;
2589 p->discard = discard;
2593 /* open files and write file headers */
2594 for (i = 0; i < nb_output_files; i++) {
2595 oc = output_files[i].ctx;
2596 oc->interrupt_callback = int_cb;
2597 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2598 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2599 ret = AVERROR(EINVAL);
2602 // assert_avoptions(output_files[i].opts);
2603 if (strcmp(oc->oformat->name, "rtp")) {
2609 /* dump the file output parameters - cannot be done before in case
2611 for (i = 0; i < nb_output_files; i++) {
2612 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2615 /* dump the stream mapping */
2616 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2617 for (i = 0; i < nb_output_streams; i++) {
2618 ost = &output_streams[i];
2620 if (ost->attachment_filename) {
2621 /* an attached file */
2622 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2623 ost->attachment_filename, ost->file_index, ost->index);
2626 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2627 input_streams[ost->source_index].file_index,
2628 input_streams[ost->source_index].st->index,
2631 if (ost->sync_ist != &input_streams[ost->source_index])
2632 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2633 ost->sync_ist->file_index,
2634 ost->sync_ist->st->index);
2635 if (ost->stream_copy)
2636 av_log(NULL, AV_LOG_INFO, " (copy)");
2638 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2639 input_streams[ost->source_index].dec->name : "?",
2640 ost->enc ? ost->enc->name : "?");
2641 av_log(NULL, AV_LOG_INFO, "\n");
2645 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2650 print_sdp(output_files, nb_output_files);
2657 * The following code is the main loop of the file converter
2659 static int transcode(OutputFile *output_files,
2660 int nb_output_files,
2661 InputFile *input_files,
2665 AVFormatContext *is, *os;
2669 int no_packet_count = 0;
2670 int64_t timer_start;
2673 if (!(no_packet = av_mallocz(nb_input_files)))
2676 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2681 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2682 avio_set_interrupt_cb(decode_interrupt_cb);
2686 timer_start = av_gettime();
2688 for (; received_sigterm == 0;) {
2689 int file_index, ist_index;
2694 ipts_min = INT64_MAX;
2696 /* if 'q' pressed, exits */
2700 /* read_key() returns 0 on EOF */
2704 if (key == '+') av_log_set_level(av_log_get_level()+10);
2705 if (key == '-') av_log_set_level(av_log_get_level()-10);
2706 if (key == 's') qp_hist ^= 1;
2709 do_hex_dump = do_pkt_dump = 0;
2710 } else if(do_pkt_dump){
2714 av_log_set_level(AV_LOG_DEBUG);
2716 if (key == 'd' || key == 'D'){
2719 debug = input_streams[0].st->codec->debug<<1;
2720 if(!debug) debug = 1;
2721 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2724 scanf("%d", &debug);
2725 for(i=0;i<nb_input_streams;i++) {
2726 input_streams[i].st->codec->debug = debug;
2728 for(i=0;i<nb_output_streams;i++) {
2729 ost = &output_streams[i];
2730 ost->st->codec->debug = debug;
2732 if(debug) av_log_set_level(AV_LOG_DEBUG);
2733 fprintf(stderr,"debug=%d\n", debug);
2736 fprintf(stderr, "key function\n"
2737 "? show this help\n"
2738 "+ increase verbosity\n"
2739 "- decrease verbosity\n"
2740 "D cycle through available debug modes\n"
2741 "h dump packets/hex press to cycle through the 3 states\n"
2743 "s Show QP histogram\n"
2748 /* select the stream that we must read now by looking at the
2749 smallest output pts */
2751 for (i = 0; i < nb_output_streams; i++) {
2755 ost = &output_streams[i];
2756 of = &output_files[ost->file_index];
2757 os = output_files[ost->file_index].ctx;
2758 ist = &input_streams[ost->source_index];
2759 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2760 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2762 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2764 if (!input_files[ist->file_index].eof_reached) {
2765 if (ipts < ipts_min) {
2768 file_index = ist->file_index;
2770 if (opts < opts_min) {
2772 if (!input_sync) file_index = ist->file_index;
2775 if (ost->frame_number >= ost->max_frames) {
2777 for (j = 0; j < of->ctx->nb_streams; j++)
2778 output_streams[of->ost_index + j].is_past_recording_time = 1;
2782 /* if none, if is finished */
2783 if (file_index < 0) {
2784 if (no_packet_count) {
2785 no_packet_count = 0;
2786 memset(no_packet, 0, nb_input_files);
2793 /* read a frame from it and output it in the fifo */
2794 is = input_files[file_index].ctx;
2795 ret = av_read_frame(is, &pkt);
2796 if (ret == AVERROR(EAGAIN)) {
2797 no_packet[file_index] = 1;
2802 input_files[file_index].eof_reached = 1;
2809 no_packet_count = 0;
2810 memset(no_packet, 0, nb_input_files);
2813 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2814 is->streams[pkt.stream_index]);
2816 /* the following test is needed in case new streams appear
2817 dynamically in stream : we ignore them */
2818 if (pkt.stream_index >= input_files[file_index].nb_streams)
2819 goto discard_packet;
2820 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2821 ist = &input_streams[ist_index];
2823 goto discard_packet;
2825 if (pkt.dts != AV_NOPTS_VALUE)
2826 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2827 if (pkt.pts != AV_NOPTS_VALUE)
2828 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2830 if (pkt.pts != AV_NOPTS_VALUE)
2831 pkt.pts *= ist->ts_scale;
2832 if (pkt.dts != AV_NOPTS_VALUE)
2833 pkt.dts *= ist->ts_scale;
2835 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
2837 // pkt.dts, input_files[ist->file_index].ts_offset,
2838 // ist->st->codec->codec_type);
2839 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2840 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2841 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2842 int64_t delta = pkt_dts - ist->next_pts;
2843 if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->pts) && !copy_ts) {
2844 input_files[ist->file_index].ts_offset -= delta;
2845 av_log(NULL, AV_LOG_DEBUG,
2846 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2847 delta, input_files[ist->file_index].ts_offset);
2848 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2849 if (pkt.pts != AV_NOPTS_VALUE)
2850 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2854 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2855 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2857 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2858 ist->file_index, ist->st->index);
2861 av_free_packet(&pkt);
2866 av_free_packet(&pkt);
2868 /* dump report by using the output first video and audio streams */
2869 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2872 /* at the end of stream, we must flush the decoder buffers */
2873 for (i = 0; i < nb_input_streams; i++) {
2874 ist = &input_streams[i];
2875 if (ist->decoding_needed) {
2876 output_packet(ist, output_streams, nb_output_streams, NULL);
2879 flush_encoders(output_streams, nb_output_streams);
2883 /* write the trailer if needed and close file */
2884 for (i = 0; i < nb_output_files; i++) {
2885 os = output_files[i].ctx;
2886 av_write_trailer(os);
2889 /* dump report by using the first video and audio streams */
2890 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2892 /* close each encoder */
2893 for (i = 0; i < nb_output_streams; i++) {
2894 ost = &output_streams[i];
2895 if (ost->encoding_needed) {
2896 av_freep(&ost->st->codec->stats_in);
2897 avcodec_close(ost->st->codec);
2900 avfilter_graph_free(&ost->graph);
2904 /* close each decoder */
2905 for (i = 0; i < nb_input_streams; i++) {
2906 ist = &input_streams[i];
2907 if (ist->decoding_needed) {
2908 avcodec_close(ist->st->codec);
2916 av_freep(&bit_buffer);
2917 av_freep(&no_packet);
2919 if (output_streams) {
2920 for (i = 0; i < nb_output_streams; i++) {
2921 ost = &output_streams[i];
2923 if (ost->stream_copy)
2924 av_freep(&ost->st->codec->extradata);
2926 fclose(ost->logfile);
2927 ost->logfile = NULL;
2929 av_fifo_free(ost->fifo); /* works even if fifo is not
2930 initialized but set to zero */
2931 av_freep(&ost->st->codec->subtitle_header);
2932 av_free(ost->resample_frame.data[0]);
2933 av_free(ost->forced_kf_pts);
2934 if (ost->video_resample)
2935 sws_freeContext(ost->img_resample_ctx);
2937 audio_resample_close(ost->resample);
2938 if (ost->reformat_ctx)
2939 av_audio_convert_free(ost->reformat_ctx);
2940 av_dict_free(&ost->opts);
2947 static double parse_frame_aspect_ratio(const char *arg)
2954 p = strchr(arg, ':');
2956 x = strtol(arg, &end, 10);
2958 y = strtol(end + 1, &end, 10);
2960 ar = (double)x / (double)y;
2962 ar = strtod(arg, NULL);
2965 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2971 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2973 return parse_option(o, "codec:a", arg, options);
2976 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2978 return parse_option(o, "codec:v", arg, options);
2981 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2983 return parse_option(o, "codec:s", arg, options);
2986 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2988 return parse_option(o, "codec:d", arg, options);
2991 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2993 StreamMap *m = NULL;
2994 int i, negative = 0, file_idx;
2995 int sync_file_idx = -1, sync_stream_idx;
3003 map = av_strdup(arg);
3005 /* parse sync stream first, just pick first matching stream */
3006 if (sync = strchr(map, ',')) {
3008 sync_file_idx = strtol(sync + 1, &sync, 0);
3009 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3010 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3015 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
3016 if (check_stream_specifier(input_files[sync_file_idx].ctx,
3017 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
3018 sync_stream_idx = i;
3021 if (i == input_files[sync_file_idx].nb_streams) {
3022 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3023 "match any streams.\n", arg);
3029 file_idx = strtol(map, &p, 0);
3030 if (file_idx >= nb_input_files || file_idx < 0) {
3031 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3035 /* disable some already defined maps */
3036 for (i = 0; i < o->nb_stream_maps; i++) {
3037 m = &o->stream_maps[i];
3038 if (file_idx == m->file_index &&
3039 check_stream_specifier(input_files[m->file_index].ctx,
3040 input_files[m->file_index].ctx->streams[m->stream_index],
3041 *p == ':' ? p + 1 : p) > 0)
3045 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3046 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3047 *p == ':' ? p + 1 : p) <= 0)
3049 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3050 &o->nb_stream_maps, o->nb_stream_maps + 1);
3051 m = &o->stream_maps[o->nb_stream_maps - 1];
3053 m->file_index = file_idx;
3054 m->stream_index = i;
3056 if (sync_file_idx >= 0) {
3057 m->sync_file_index = sync_file_idx;
3058 m->sync_stream_index = sync_stream_idx;
3060 m->sync_file_index = file_idx;
3061 m->sync_stream_index = i;
3066 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3074 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3076 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3077 &o->nb_attachments, o->nb_attachments + 1);
3078 o->attachments[o->nb_attachments - 1] = arg;
3083 * Parse a metadata specifier in arg.
3084 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3085 * @param index for type c/p, chapter/program index is written here
3086 * @param stream_spec for type s, the stream specifier is written here
3088 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3096 if (*(++arg) && *arg != ':') {
3097 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3100 *stream_spec = *arg == ':' ? arg + 1 : "";
3104 if (*(++arg) == ':')
3105 *index = strtol(++arg, NULL, 0);
3108 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3115 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3117 AVDictionary **meta_in = NULL;
3118 AVDictionary **meta_out;
3120 char type_in, type_out;
3121 const char *istream_spec = NULL, *ostream_spec = NULL;
3122 int idx_in = 0, idx_out = 0;
3124 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3125 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3127 if (type_in == 'g' || type_out == 'g')
3128 o->metadata_global_manual = 1;
3129 if (type_in == 's' || type_out == 's')
3130 o->metadata_streams_manual = 1;
3131 if (type_in == 'c' || type_out == 'c')
3132 o->metadata_chapters_manual = 1;
3134 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3135 if ((index) < 0 || (index) >= (nb_elems)) {\
3136 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3141 #define SET_DICT(type, meta, context, index)\
3144 meta = &context->metadata;\
3147 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3148 meta = &context->chapters[index]->metadata;\
3151 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3152 meta = &context->programs[index]->metadata;\
3156 SET_DICT(type_in, meta_in, ic, idx_in);
3157 SET_DICT(type_out, meta_out, oc, idx_out);
3159 /* for input streams choose first matching stream */
3160 if (type_in == 's') {
3161 for (i = 0; i < ic->nb_streams; i++) {
3162 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3163 meta_in = &ic->streams[i]->metadata;
3169 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3174 if (type_out == 's') {
3175 for (i = 0; i < oc->nb_streams; i++) {
3176 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3177 meta_out = &oc->streams[i]->metadata;
3178 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3183 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3188 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3190 const char *codec_string = encoder ? "encoder" : "decoder";
3194 avcodec_find_encoder_by_name(name) :
3195 avcodec_find_decoder_by_name(name);
3197 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3200 if (codec->type != type) {
3201 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3207 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3209 char *codec_name = NULL;
3211 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3213 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3214 st->codec->codec_id = codec->id;
3217 return avcodec_find_decoder(st->codec->codec_id);
3221 * Add all the streams from the given input file to the global
3222 * list of input streams.
3224 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3228 for (i = 0; i < ic->nb_streams; i++) {
3229 AVStream *st = ic->streams[i];
3230 AVCodecContext *dec = st->codec;
3233 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3234 ist = &input_streams[nb_input_streams - 1];
3236 ist->file_index = nb_input_files;
3238 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3240 ist->ts_scale = 1.0;
3241 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3243 ist->dec = choose_decoder(o, ic, st);
3245 switch (dec->codec_type) {
3246 case AVMEDIA_TYPE_AUDIO:
3248 ist->dec = avcodec_find_decoder(dec->codec_id);
3249 if(o->audio_disable)
3250 st->discard = AVDISCARD_ALL;
3252 case AVMEDIA_TYPE_VIDEO:
3254 ist->dec = avcodec_find_decoder(dec->codec_id);
3256 dec->flags |= CODEC_FLAG_EMU_EDGE;
3259 if (o->video_disable)
3260 st->discard = AVDISCARD_ALL;
3261 else if (video_discard)
3262 st->discard = video_discard;
3264 case AVMEDIA_TYPE_DATA:
3266 case AVMEDIA_TYPE_SUBTITLE:
3268 ist->dec = avcodec_find_decoder(dec->codec_id);
3269 if(o->subtitle_disable)
3270 st->discard = AVDISCARD_ALL;
3272 case AVMEDIA_TYPE_ATTACHMENT:
3273 case AVMEDIA_TYPE_UNKNOWN:
3281 static void assert_file_overwrite(const char *filename)
3283 if ((!file_overwrite || no_file_overwrite) &&
3284 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3285 av_strstart(filename, "file:", NULL))) {
3286 if (avio_check(filename, 0) == 0) {
3287 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3288 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3290 if (!read_yesno()) {
3291 fprintf(stderr, "Not overwriting - exiting\n");
3296 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3303 static void dump_attachment(AVStream *st, const char *filename)
3306 AVIOContext *out = NULL;
3307 AVDictionaryEntry *e;
3309 if (!st->codec->extradata_size) {
3310 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3311 nb_input_files - 1, st->index);
3314 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3315 filename = e->value;
3317 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3318 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3322 assert_file_overwrite(filename);
3324 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3325 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3330 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3335 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3337 AVFormatContext *ic;
3338 AVInputFormat *file_iformat = NULL;
3342 AVDictionary **opts;
3343 int orig_nb_streams; // number of streams before avformat_find_stream_info
3346 if (!(file_iformat = av_find_input_format(o->format))) {
3347 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3352 if (!strcmp(filename, "-"))
3355 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3356 !strcmp(filename, "/dev/stdin");
3358 /* get default parameters from command line */
3359 ic = avformat_alloc_context();
3361 print_error(filename, AVERROR(ENOMEM));
3364 if (o->nb_audio_sample_rate) {
3365 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3366 av_dict_set(&format_opts, "sample_rate", buf, 0);
3368 if (o->nb_audio_channels) {
3369 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3370 av_dict_set(&format_opts, "channels", buf, 0);
3372 if (o->nb_frame_rates) {
3373 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3375 if (o->nb_frame_sizes) {
3376 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3378 if (o->nb_frame_pix_fmts)
3379 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3381 ic->flags |= AVFMT_FLAG_NONBLOCK;
3382 ic->interrupt_callback = int_cb;
3384 /* open the input file with generic avformat function */
3385 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3387 print_error(filename, err);
3390 assert_avoptions(format_opts);
3392 /* apply forced codec ids */
3393 for (i = 0; i < ic->nb_streams; i++)
3394 choose_decoder(o, ic, ic->streams[i]);
3396 /* Set AVCodecContext options for avformat_find_stream_info */
3397 opts = setup_find_stream_info_opts(ic, codec_opts);
3398 orig_nb_streams = ic->nb_streams;
3400 /* If not enough info to get the stream parameters, we decode the
3401 first frames to get it. (used in mpeg case for example) */
3402 ret = avformat_find_stream_info(ic, opts);
3404 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3405 avformat_close_input(&ic);
3409 timestamp = o->start_time;
3410 /* add the stream start time */
3411 if (ic->start_time != AV_NOPTS_VALUE)
3412 timestamp += ic->start_time;
3414 /* if seeking requested, we execute it */
3415 if (o->start_time != 0) {
3416 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3418 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3419 filename, (double)timestamp / AV_TIME_BASE);
3423 /* update the current parameters so that they match the one of the input stream */
3424 add_input_streams(o, ic);
3426 /* dump the file content */
3427 av_dump_format(ic, nb_input_files, filename, 0);
3429 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3430 input_files[nb_input_files - 1].ctx = ic;
3431 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3432 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3433 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3434 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3436 for (i = 0; i < o->nb_dump_attachment; i++) {
3439 for (j = 0; j < ic->nb_streams; j++) {
3440 AVStream *st = ic->streams[j];
3442 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3443 dump_attachment(st, o->dump_attachment[i].u.str);
3447 for (i = 0; i < orig_nb_streams; i++)
3448 av_dict_free(&opts[i]);
3455 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3456 AVCodecContext *avctx)
3462 for (p = kf; *p; p++)
3465 ost->forced_kf_count = n;
3466 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3467 if (!ost->forced_kf_pts) {
3468 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3471 for (i = 0; i < n; i++) {
3472 p = i ? strchr(p, ',') + 1 : kf;
3473 t = parse_time_or_die("force_key_frames", p, 1);
3474 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3478 static uint8_t *get_line(AVIOContext *s)
3484 if (avio_open_dyn_buf(&line) < 0) {
3485 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3489 while ((c = avio_r8(s)) && c != '\n')
3492 avio_close_dyn_buf(line, &buf);
3497 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3500 char filename[1000];
3501 const char *base[3] = { getenv("AVCONV_DATADIR"),
3506 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3510 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3511 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3512 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3515 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3516 i != 1 ? "" : "/.avconv", preset_name);
3517 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3523 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3525 char *codec_name = NULL;
3527 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3529 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3530 NULL, ost->st->codec->codec_type);
3531 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3532 } else if (!strcmp(codec_name, "copy"))
3533 ost->stream_copy = 1;
3535 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3536 ost->st->codec->codec_id = ost->enc->id;
3540 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3543 AVStream *st = avformat_new_stream(oc, NULL);
3544 int idx = oc->nb_streams - 1, ret = 0;
3545 char *bsf = NULL, *next, *codec_tag = NULL;
3546 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3548 char *buf = NULL, *arg = NULL, *preset = NULL;
3549 AVIOContext *s = NULL;
3552 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3556 if (oc->nb_streams - 1 < o->nb_streamid_map)
3557 st->id = o->streamid_map[oc->nb_streams - 1];
3559 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3560 nb_output_streams + 1);
3561 ost = &output_streams[nb_output_streams - 1];
3562 ost->file_index = nb_output_files;
3565 st->codec->codec_type = type;
3566 choose_encoder(o, oc, ost);
3568 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3571 avcodec_get_context_defaults3(st->codec, ost->enc);
3572 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3574 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3575 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3578 if (!buf[0] || buf[0] == '#') {
3582 if (!(arg = strchr(buf, '='))) {
3583 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3587 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3589 } while (!s->eof_reached);
3593 av_log(NULL, AV_LOG_FATAL,
3594 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3595 preset, ost->file_index, ost->index);
3599 ost->max_frames = INT64_MAX;
3600 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3602 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3604 if (next = strchr(bsf, ','))
3606 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3607 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3611 bsfc_prev->next = bsfc;
3613 ost->bitstream_filters = bsfc;
3619 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3621 uint32_t tag = strtol(codec_tag, &next, 0);
3623 tag = AV_RL32(codec_tag);
3624 st->codec->codec_tag = tag;
3627 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3628 if (qscale >= 0 || same_quant) {
3629 st->codec->flags |= CODEC_FLAG_QSCALE;
3630 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3633 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3634 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3636 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3640 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3643 const char *p = str;
3650 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3657 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3661 AVCodecContext *video_enc;
3663 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3665 video_enc = st->codec;
3667 if (!ost->stream_copy) {
3668 const char *p = NULL;
3669 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3670 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3671 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3674 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3675 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3676 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3680 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3681 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3682 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3686 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3687 if (frame_aspect_ratio)
3688 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3690 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3691 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3692 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3695 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3697 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3699 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3700 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3703 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3705 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3707 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3708 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3711 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3714 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3715 for (i = 0; p; i++) {
3717 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3719 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3722 video_enc->rc_override =
3723 av_realloc(video_enc->rc_override,
3724 sizeof(RcOverride) * (i + 1));
3725 video_enc->rc_override[i].start_frame = start;
3726 video_enc->rc_override[i].end_frame = end;
3728 video_enc->rc_override[i].qscale = q;
3729 video_enc->rc_override[i].quality_factor = 1.0;
3732 video_enc->rc_override[i].qscale = 0;
3733 video_enc->rc_override[i].quality_factor = -q/100.0;
3738 video_enc->rc_override_count = i;
3739 if (!video_enc->rc_initial_buffer_occupancy)
3740 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
3741 video_enc->intra_dc_precision = intra_dc_precision - 8;
3746 video_enc->flags |= CODEC_FLAG_PASS1;
3748 video_enc->flags |= CODEC_FLAG_PASS2;
3752 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3753 if (forced_key_frames)
3754 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3756 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
3758 ost->top_field_first = -1;
3759 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
3762 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3764 ost->avfilter = av_strdup(filters);
3767 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
3773 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3777 AVCodecContext *audio_enc;
3779 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3782 audio_enc = st->codec;
3783 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3785 if (!ost->stream_copy) {
3786 char *sample_fmt = NULL;
3788 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3790 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3792 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3793 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3797 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3803 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3807 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3808 if (!ost->stream_copy) {
3809 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3816 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3818 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3819 ost->stream_copy = 1;
3823 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3827 AVCodecContext *subtitle_enc;
3829 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3831 subtitle_enc = st->codec;
3833 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3838 /* arg format is "output-stream-index:streamid-value". */
3839 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3845 av_strlcpy(idx_str, arg, sizeof(idx_str));
3846 p = strchr(idx_str, ':');
3848 av_log(NULL, AV_LOG_FATAL,
3849 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3854 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3855 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3856 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3860 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3862 AVFormatContext *is = ifile->ctx;
3863 AVFormatContext *os = ofile->ctx;
3866 for (i = 0; i < is->nb_chapters; i++) {
3867 AVChapter *in_ch = is->chapters[i], *out_ch;
3868 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3869 AV_TIME_BASE_Q, in_ch->time_base);
3870 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3871 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3874 if (in_ch->end < ts_off)
3876 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3879 out_ch = av_mallocz(sizeof(AVChapter));
3881 return AVERROR(ENOMEM);
3883 out_ch->id = in_ch->id;
3884 out_ch->time_base = in_ch->time_base;
3885 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3886 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3889 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3892 os->chapters = av_realloc(os->chapters, sizeof(AVChapter) * os->nb_chapters);
3894 return AVERROR(ENOMEM);
3895 os->chapters[os->nb_chapters - 1] = out_ch;
3900 static void opt_output_file(void *optctx, const char *filename)
3902 OptionsContext *o = optctx;
3903 AVFormatContext *oc;
3905 AVOutputFormat *file_oformat;
3909 if (!strcmp(filename, "-"))
3912 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
3914 print_error(filename, err);
3918 file_oformat= oc->oformat;
3919 oc->interrupt_callback = int_cb;
3921 if (!o->nb_stream_maps) {
3922 /* pick the "best" stream of each type */
3923 #define NEW_STREAM(type, index)\
3925 ost = new_ ## type ## _stream(o, oc);\
3926 ost->source_index = index;\
3927 ost->sync_ist = &input_streams[index];\
3928 input_streams[index].discard = 0;\
3931 /* video: highest resolution */
3932 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3933 int area = 0, idx = -1;
3934 for (i = 0; i < nb_input_streams; i++) {
3935 ist = &input_streams[i];
3936 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3937 ist->st->codec->width * ist->st->codec->height > area) {
3938 area = ist->st->codec->width * ist->st->codec->height;
3942 NEW_STREAM(video, idx);
3945 /* audio: most channels */
3946 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3947 int channels = 0, idx = -1;
3948 for (i = 0; i < nb_input_streams; i++) {
3949 ist = &input_streams[i];
3950 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3951 ist->st->codec->channels > channels) {
3952 channels = ist->st->codec->channels;
3956 NEW_STREAM(audio, idx);
3959 /* subtitles: pick first */
3960 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3961 for (i = 0; i < nb_input_streams; i++)
3962 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3963 NEW_STREAM(subtitle, i);
3967 /* do something with data? */
3969 for (i = 0; i < o->nb_stream_maps; i++) {
3970 StreamMap *map = &o->stream_maps[i];
3975 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3976 switch (ist->st->codec->codec_type) {
3977 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3978 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3979 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3980 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3981 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3983 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
3984 map->file_index, map->stream_index);
3988 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3989 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3990 map->sync_stream_index];
3995 /* handle attached files */
3996 for (i = 0; i < o->nb_attachments; i++) {
3998 uint8_t *attachment;
4002 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4003 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4007 if ((len = avio_size(pb)) <= 0) {
4008 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4012 if (!(attachment = av_malloc(len))) {
4013 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4017 avio_read(pb, attachment, len);
4019 ost = new_attachment_stream(o, oc);
4020 ost->stream_copy = 0;
4021 ost->source_index = -1;
4022 ost->attachment_filename = o->attachments[i];
4023 ost->st->codec->extradata = attachment;
4024 ost->st->codec->extradata_size = len;
4026 p = strrchr(o->attachments[i], '/');
4027 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4031 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4032 output_files[nb_output_files - 1].ctx = oc;
4033 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4034 output_files[nb_output_files - 1].recording_time = o->recording_time;
4035 output_files[nb_output_files - 1].start_time = o->start_time;
4036 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4037 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4039 /* check filename in case of an image number is expected */
4040 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4041 if (!av_filename_number_test(oc->filename)) {
4042 print_error(oc->filename, AVERROR(EINVAL));
4047 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4048 /* test if it already exists to avoid losing precious files */
4049 assert_file_overwrite(filename);
4052 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4053 &oc->interrupt_callback,
4054 &output_files[nb_output_files - 1].opts)) < 0) {
4055 print_error(filename, err);
4060 if (o->mux_preload) {
4062 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4063 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4065 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4068 for (i = 0; i < o->nb_metadata_map; i++) {
4070 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4072 if (in_file_index < 0)
4074 if (in_file_index >= nb_input_files) {
4075 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4078 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4082 if (o->chapters_input_file >= nb_input_files) {
4083 if (o->chapters_input_file == INT_MAX) {
4084 /* copy chapters from the first input file that has them*/
4085 o->chapters_input_file = -1;
4086 for (i = 0; i < nb_input_files; i++)
4087 if (input_files[i].ctx->nb_chapters) {
4088 o->chapters_input_file = i;
4092 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4093 o->chapters_input_file);
4097 if (o->chapters_input_file >= 0)
4098 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4099 !o->metadata_chapters_manual);
4101 /* copy global metadata by default */
4102 if (!o->metadata_global_manual && nb_input_files)
4103 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4104 AV_DICT_DONT_OVERWRITE);
4105 if (!o->metadata_streams_manual)
4106 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4108 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4110 ist = &input_streams[output_streams[i].source_index];
4111 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4114 /* process manually set metadata */
4115 for (i = 0; i < o->nb_metadata; i++) {
4118 const char *stream_spec;
4119 int index = 0, j, ret;
4121 val = strchr(o->metadata[i].u.str, '=');
4123 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4124 o->metadata[i].u.str);
4129 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4131 for (j = 0; j < oc->nb_streams; j++) {
4132 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4133 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4137 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4145 if (index < 0 || index >= oc->nb_chapters) {
4146 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4149 m = &oc->chapters[index]->metadata;
4152 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4155 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4162 /* same option as mencoder */
4163 static int opt_pass(const char *opt, const char *arg)
4165 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
4169 static int64_t getutime(void)
4172 struct rusage rusage;
4174 getrusage(RUSAGE_SELF, &rusage);
4175 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4176 #elif HAVE_GETPROCESSTIMES
4178 FILETIME c, e, k, u;
4179 proc = GetCurrentProcess();
4180 GetProcessTimes(proc, &c, &e, &k, &u);
4181 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4183 return av_gettime();
4187 static int64_t getmaxrss(void)
4189 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4190 struct rusage rusage;
4191 getrusage(RUSAGE_SELF, &rusage);
4192 return (int64_t)rusage.ru_maxrss * 1024;
4193 #elif HAVE_GETPROCESSMEMORYINFO
4195 PROCESS_MEMORY_COUNTERS memcounters;
4196 proc = GetCurrentProcess();
4197 memcounters.cb = sizeof(memcounters);
4198 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4199 return memcounters.PeakPagefileUsage;
4205 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4207 return parse_option(o, "q:a", arg, options);
4210 static void show_usage(void)
4212 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
4213 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4214 av_log(NULL, AV_LOG_INFO, "\n");
4217 static int opt_help(const char *opt, const char *arg)
4219 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4220 av_log_set_callback(log_callback_help);
4222 show_help_options(options, "Main options:\n",
4223 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4224 show_help_options(options, "\nAdvanced options:\n",
4225 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4227 show_help_options(options, "\nVideo options:\n",
4228 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4230 show_help_options(options, "\nAdvanced Video options:\n",
4231 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4232 OPT_VIDEO | OPT_EXPERT);
4233 show_help_options(options, "\nAudio options:\n",
4234 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4236 show_help_options(options, "\nAdvanced Audio options:\n",
4237 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4238 OPT_AUDIO | OPT_EXPERT);
4239 show_help_options(options, "\nSubtitle options:\n",
4240 OPT_SUBTITLE | OPT_GRAB,
4242 show_help_options(options, "\nAudio/Video grab options:\n",
4246 show_help_children(avcodec_get_class(), flags);
4247 show_help_children(avformat_get_class(), flags);
4248 show_help_children(sws_get_class(), flags);
4253 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4255 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4256 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4258 if (!strncmp(arg, "pal-", 4)) {
4261 } else if (!strncmp(arg, "ntsc-", 5)) {
4264 } else if (!strncmp(arg, "film-", 5)) {
4268 /* Try to determine PAL/NTSC by peeking in the input files */
4269 if (nb_input_files) {
4271 for (j = 0; j < nb_input_files; j++) {
4272 for (i = 0; i < input_files[j].nb_streams; i++) {
4273 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4274 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4276 fr = c->time_base.den * 1000 / c->time_base.num;
4280 } else if ((fr == 29970) || (fr == 23976)) {
4285 if (norm != UNKNOWN)
4289 if (norm != UNKNOWN)
4290 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4293 if (norm == UNKNOWN) {
4294 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4295 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4296 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4300 if (!strcmp(arg, "vcd")) {
4301 opt_video_codec(o, "c:v", "mpeg1video");
4302 opt_audio_codec(o, "c:a", "mp2");
4303 parse_option(o, "f", "vcd", options);
4305 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4306 parse_option(o, "r", frame_rates[norm], options);
4307 opt_default("g", norm == PAL ? "15" : "18");
4309 opt_default("b", "1150000");
4310 opt_default("maxrate", "1150000");
4311 opt_default("minrate", "1150000");
4312 opt_default("bufsize", "327680"); // 40*1024*8;
4314 opt_default("b:a", "224000");
4315 parse_option(o, "ar", "44100", options);
4316 parse_option(o, "ac", "2", options);
4318 opt_default("packetsize", "2324");
4319 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4321 /* We have to offset the PTS, so that it is consistent with the SCR.
4322 SCR starts at 36000, but the first two packs contain only padding
4323 and the first pack from the other stream, respectively, may also have
4324 been written before.
4325 So the real data starts at SCR 36000+3*1200. */
4326 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4327 } else if (!strcmp(arg, "svcd")) {
4329 opt_video_codec(o, "c:v", "mpeg2video");
4330 opt_audio_codec(o, "c:a", "mp2");
4331 parse_option(o, "f", "svcd", options);
4333 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4334 parse_option(o, "r", frame_rates[norm], options);
4335 opt_default("g", norm == PAL ? "15" : "18");
4337 opt_default("b", "2040000");
4338 opt_default("maxrate", "2516000");
4339 opt_default("minrate", "0"); // 1145000;
4340 opt_default("bufsize", "1835008"); // 224*1024*8;
4341 opt_default("flags", "+scan_offset");
4344 opt_default("b:a", "224000");
4345 parse_option(o, "ar", "44100", options);
4347 opt_default("packetsize", "2324");
4349 } else if (!strcmp(arg, "dvd")) {
4351 opt_video_codec(o, "c:v", "mpeg2video");
4352 opt_audio_codec(o, "c:a", "ac3");
4353 parse_option(o, "f", "dvd", options);
4355 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4356 parse_option(o, "r", frame_rates[norm], options);
4357 opt_default("g", norm == PAL ? "15" : "18");
4359 opt_default("b", "6000000");
4360 opt_default("maxrate", "9000000");
4361 opt_default("minrate", "0"); // 1500000;
4362 opt_default("bufsize", "1835008"); // 224*1024*8;
4364 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4365 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4367 opt_default("b:a", "448000");
4368 parse_option(o, "ar", "48000", options);
4370 } else if (!strncmp(arg, "dv", 2)) {
4372 parse_option(o, "f", "dv", options);
4374 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4375 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4376 norm == PAL ? "yuv420p" : "yuv411p", options);
4377 parse_option(o, "r", frame_rates[norm], options);
4379 parse_option(o, "ar", "48000", options);
4380 parse_option(o, "ac", "2", options);
4383 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4384 return AVERROR(EINVAL);
4389 static int opt_vstats_file(const char *opt, const char *arg)
4391 av_free (vstats_filename);
4392 vstats_filename = av_strdup (arg);
4396 static int opt_vstats(const char *opt, const char *arg)
4399 time_t today2 = time(NULL);
4400 struct tm *today = localtime(&today2);
4402 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4404 return opt_vstats_file(opt, filename);
4407 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4409 return parse_option(o, "frames:v", arg, options);
4412 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4414 return parse_option(o, "frames:a", arg, options);
4417 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4419 return parse_option(o, "frames:d", arg, options);
4422 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4426 static int opt_passlogfile(const char *opt, const char *arg)
4428 pass_logfilename_prefix = arg;
4429 #if CONFIG_LIBX264_ENCODER
4430 return opt_default("passlogfile", arg);
4436 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
4438 return parse_option(o, "tag:v", arg, options);
4441 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
4443 return parse_option(o, "tag:a", arg, options);
4446 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
4448 return parse_option(o, "tag:s", arg, options);
4451 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4453 return parse_option(o, "filter:v", arg, options);
4456 static int opt_vsync(const char *opt, const char *arg)
4458 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
4459 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
4460 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4462 if (video_sync_method == VSYNC_AUTO)
4463 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4467 #define OFFSET(x) offsetof(OptionsContext, x)
4468 static const OptionDef options[] = {
4470 #include "cmdutils_common_opts.h"
4471 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4472 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4473 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4474 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4475 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4476 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4477 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4478 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4479 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4480 "outfile[,metadata]:infile[,metadata]" },
4481 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4482 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4483 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4484 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4485 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4486 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4487 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4488 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4489 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4490 "add timings for benchmarking" },
4491 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4492 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4493 "dump each input packet" },
4494 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4495 "when dumping packets, also dump the payload" },
4496 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4497 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4498 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4499 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4500 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4501 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4502 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4503 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4504 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4505 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4506 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4507 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4508 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4509 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4510 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4512 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4514 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4515 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4516 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4519 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4520 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4521 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4522 { "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" },
4523 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4524 { "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" },
4525 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4526 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4527 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4528 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4529 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4530 "use same quantizer as source (implies VBR)" },
4531 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4532 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4533 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4534 "deinterlace pictures" },
4535 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4536 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4538 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4540 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4541 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4542 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4543 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4544 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
4545 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4546 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4547 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4548 { "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" },
4551 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4552 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4553 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4554 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4555 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4556 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4557 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
4558 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4559 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4561 /* subtitle options */
4562 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4563 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4564 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4567 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4570 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4571 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
4573 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4575 /* data codec support */
4576 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4578 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4582 int main(int argc, char **argv)
4584 OptionsContext o = { 0 };
4589 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4590 parse_loglevel(argc, argv, options);
4592 if(argc>1 && !strcmp(argv[1], "-d")){
4594 av_log_set_callback(log_callback_null);
4599 avcodec_register_all();
4601 avdevice_register_all();
4604 avfilter_register_all();
4607 avformat_network_init();
4609 show_banner(argc, argv, options);
4612 parse_options(&o, argc, argv, options, opt_output_file);
4614 if (nb_output_files <= 0 && nb_input_files == 0) {
4616 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4620 /* file converter / grab */
4621 if (nb_output_files <= 0) {
4622 fprintf(stderr, "At least one output file must be specified\n");
4626 if (nb_input_files == 0) {
4627 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4632 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4634 ti = getutime() - ti;
4636 int maxrss = getmaxrss() / 1024;
4637 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);