2 * Copyright (c) 2000-2003 Fabrice Bellard
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * multimedia converter based on the FFmpeg libraries
35 #include "libavformat/avformat.h"
36 #include "libavdevice/avdevice.h"
37 #include "libswscale/swscale.h"
38 #include "libavutil/opt.h"
39 #include "libavcodec/audioconvert.h"
40 #include "libavutil/audioconvert.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/samplefmt.h"
43 #include "libavutil/colorspace.h"
44 #include "libavutil/fifo.h"
45 #include "libavutil/intreadwrite.h"
46 #include "libavutil/dict.h"
47 #include "libavutil/mathematics.h"
48 #include "libavutil/pixdesc.h"
49 #include "libavutil/avstring.h"
50 #include "libavutil/libm.h"
51 #include "libavutil/imgutils.h"
52 #include "libavformat/os_support.h"
53 #include "libswresample/swresample.h"
55 #include "libavformat/ffm.h" // not public API
58 # include "libavfilter/avcodec.h"
59 # include "libavfilter/avfilter.h"
60 # include "libavfilter/avfiltergraph.h"
61 # include "libavfilter/buffersink.h"
62 # include "libavfilter/buffersrc.h"
63 # include "libavfilter/vsrc_buffer.h"
66 #if HAVE_SYS_RESOURCE_H
67 #include <sys/types.h>
69 #include <sys/resource.h>
70 #elif HAVE_GETPROCESSTIMES
73 #if HAVE_GETPROCESSMEMORYINFO
79 #include <sys/select.h>
84 #include <sys/ioctl.h>
94 #include "libavutil/avassert.h"
96 const char program_name[] = "ffmpeg";
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 int file_idx, stream_idx, channel_idx; // input
110 int ofile_idx, ostream_idx; // output
114 * select an input file for an output file
116 typedef struct MetadataMap {
117 int file; ///< file index
118 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
119 int index; ///< stream/chapter/program number
122 static const OptionDef options[];
124 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
126 static int frame_bits_per_raw_sample = 0;
127 static int video_discard = 0;
128 static int same_quant = 0;
129 static int do_deinterlace = 0;
130 static int intra_dc_precision = 8;
131 static int loop_input = 0;
132 static int loop_output = AVFMT_NOOUTPUTLOOP;
133 static int qp_hist = 0;
134 static int intra_only = 0;
135 static const char *video_codec_name = NULL;
136 static const char *audio_codec_name = NULL;
137 static const char *subtitle_codec_name = NULL;
139 static int file_overwrite = 0;
140 static int no_file_overwrite = 0;
141 static int do_benchmark = 0;
142 static int do_hex_dump = 0;
143 static int do_pkt_dump = 0;
144 static int do_psnr = 0;
145 static int do_pass = 0;
146 static const char *pass_logfilename_prefix;
147 static int video_sync_method = -1;
148 static int audio_sync_method = 0;
149 static float audio_drift_threshold = 0.1;
150 static int copy_ts = 0;
151 static int copy_tb = -1;
152 static int opt_shortest = 0;
153 static char *vstats_filename;
154 static FILE *vstats_file;
156 static int audio_volume = 256;
158 static int exit_on_error = 0;
159 static int using_stdin = 0;
160 static int run_as_daemon = 0;
161 static volatile int received_nb_signals = 0;
162 static int64_t video_size = 0;
163 static int64_t audio_size = 0;
164 static int64_t extra_size = 0;
165 static int nb_frames_dup = 0;
166 static int nb_frames_drop = 0;
167 static int input_sync;
169 static float dts_delta_threshold = 10;
171 static int print_stats = 1;
173 static uint8_t *audio_buf;
174 static uint8_t *audio_out;
175 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
177 static uint8_t *input_tmp= NULL;
179 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
181 typedef struct FrameBuffer {
187 enum PixelFormat pix_fmt;
190 struct InputStream *ist;
191 struct FrameBuffer *next;
194 typedef struct InputStream {
197 int discard; /* true if stream data should be discarded */
198 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
200 AVFrame *decoded_frame;
201 AVFrame *filtered_frame;
203 int64_t start; /* time when read started */
204 int64_t next_pts; /* synthetic pts for cases where pkt.pts
206 int64_t pts; /* current pts */
208 int is_start; /* is 1 at the start and after a discontinuity */
209 int showed_multi_packet_warning;
212 /* a pool of free buffers for decoded data */
213 FrameBuffer *buffer_pool;
217 typedef struct InputFile {
218 AVFormatContext *ctx;
219 int eof_reached; /* true if eof reached */
220 int ist_index; /* index of first stream in input_streams */
221 int buffer_size; /* current total buffer size */
223 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
224 from ctx.nb_streams if new streams appear during av_read_frame() */
228 typedef struct OutputStream {
229 int file_index; /* file index */
230 int index; /* stream index in the output file */
231 int source_index; /* InputStream index */
232 AVStream *st; /* stream in the output file */
233 int encoding_needed; /* true if encoding needed for this stream */
235 /* input pts and corresponding output pts
237 // double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
238 struct InputStream *sync_ist; /* input stream to sync against */
239 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
240 AVBitStreamFilterContext *bitstream_filters;
246 AVFrame resample_frame; /* temporary frame for image resampling */
247 struct SwsContext *img_resample_ctx; /* for image resampling */
250 int resample_pix_fmt;
251 AVRational frame_rate;
255 float frame_aspect_ratio;
257 /* forced key frames */
258 int64_t *forced_kf_pts;
264 int audio_channels_map[SWR_CH_MAX]; ///< list of the channels id to pick from the source stream
265 int audio_channels_mapped; ///< number of channels in audio_channels_map
266 int resample_sample_fmt;
267 int resample_channels;
268 int resample_sample_rate;
269 float rematrix_volume;
270 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
273 struct SwrContext *swr;
276 AVFilterContext *output_video_filter;
277 AVFilterContext *input_video_filter;
278 AVFilterBufferRef *picref;
280 AVFilterGraph *graph;
285 int is_past_recording_time;
287 const char *attachment_filename;
288 int copy_initial_nonkeyframes;
294 /* init terminal so that we can grab keys */
295 static struct termios oldtty;
298 typedef struct OutputFile {
299 AVFormatContext *ctx;
301 int ost_index; /* index of the first stream in output_streams */
302 int64_t recording_time; /* desired length of the resulting file in microseconds */
303 int64_t start_time; /* start time in microseconds */
304 uint64_t limit_filesize;
307 static InputStream *input_streams = NULL;
308 static int nb_input_streams = 0;
309 static InputFile *input_files = NULL;
310 static int nb_input_files = 0;
312 static OutputStream *output_streams = NULL;
313 static int nb_output_streams = 0;
314 static OutputFile *output_files = NULL;
315 static int nb_output_files = 0;
317 typedef struct OptionsContext {
318 /* input/output options */
322 SpecifierOpt *codec_names;
324 SpecifierOpt *audio_channels;
325 int nb_audio_channels;
326 SpecifierOpt *audio_sample_rate;
327 int nb_audio_sample_rate;
328 SpecifierOpt *rematrix_volume;
329 int nb_rematrix_volume;
330 SpecifierOpt *frame_rates;
332 SpecifierOpt *frame_sizes;
334 SpecifierOpt *frame_pix_fmts;
335 int nb_frame_pix_fmts;
338 int64_t input_ts_offset;
341 SpecifierOpt *ts_scale;
343 SpecifierOpt *dump_attachment;
344 int nb_dump_attachment;
347 StreamMap *stream_maps;
349 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
350 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
351 /* first item specifies output metadata, second is input */
352 MetadataMap (*meta_data_maps)[2];
353 int nb_meta_data_maps;
354 int metadata_global_manual;
355 int metadata_streams_manual;
356 int metadata_chapters_manual;
357 const char **attachments;
360 int chapters_input_file;
362 int64_t recording_time;
363 uint64_t limit_filesize;
369 int subtitle_disable;
372 /* indexed by output file stream index */
376 SpecifierOpt *metadata;
378 SpecifierOpt *max_frames;
380 SpecifierOpt *bitstream_filters;
381 int nb_bitstream_filters;
382 SpecifierOpt *codec_tags;
384 SpecifierOpt *sample_fmts;
386 SpecifierOpt *qscale;
388 SpecifierOpt *forced_key_frames;
389 int nb_forced_key_frames;
390 SpecifierOpt *force_fps;
392 SpecifierOpt *frame_aspect_ratios;
393 int nb_frame_aspect_ratios;
394 SpecifierOpt *rc_overrides;
396 SpecifierOpt *intra_matrices;
397 int nb_intra_matrices;
398 SpecifierOpt *inter_matrices;
399 int nb_inter_matrices;
400 SpecifierOpt *top_field_first;
401 int nb_top_field_first;
402 SpecifierOpt *metadata_map;
404 SpecifierOpt *presets;
406 SpecifierOpt *copy_initial_nonkeyframes;
407 int nb_copy_initial_nonkeyframes;
409 SpecifierOpt *filters;
414 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
417 for (i = 0; i < o->nb_ ## name; i++) {\
418 char *spec = o->name[i].specifier;\
419 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
420 outvar = o->name[i].u.type;\
426 static void reset_options(OptionsContext *o, int is_input)
428 const OptionDef *po = options;
429 OptionsContext bak= *o;
431 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
433 void *dst = (uint8_t*)o + po->u.off;
435 if (po->flags & OPT_SPEC) {
436 SpecifierOpt **so = dst;
437 int i, *count = (int*)(so + 1);
438 for (i = 0; i < *count; i++) {
439 av_freep(&(*so)[i].specifier);
440 if (po->flags & OPT_STRING)
441 av_freep(&(*so)[i].u.str);
445 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
450 av_freep(&o->stream_maps);
451 av_freep(&o->audio_channel_maps);
452 av_freep(&o->meta_data_maps);
453 av_freep(&o->streamid_map);
455 memset(o, 0, sizeof(*o));
457 if(is_input) o->recording_time = bak.recording_time;
458 else o->recording_time = INT64_MAX;
459 o->mux_max_delay = 0.7;
460 o->limit_filesize = UINT64_MAX;
461 o->chapters_input_file = INT_MAX;
467 static int alloc_buffer(InputStream *ist, FrameBuffer **pbuf)
469 AVCodecContext *s = ist->st->codec;
470 FrameBuffer *buf = av_mallocz(sizeof(*buf));
472 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
473 int h_chroma_shift, v_chroma_shift;
474 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
475 int w = s->width, h = s->height;
478 return AVERROR(ENOMEM);
480 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
485 avcodec_align_dimensions(s, &w, &h);
486 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
487 s->pix_fmt, 32)) < 0) {
491 /* XXX this shouldn't be needed, but some tests break without this line
492 * those decoders are buggy and need to be fixed.
493 * the following tests fail:
494 * bethsoft-vid, cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
496 memset(buf->base[0], 128, ret);
498 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
499 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
500 const int h_shift = i==0 ? 0 : h_chroma_shift;
501 const int v_shift = i==0 ? 0 : v_chroma_shift;
502 if (s->flags & CODEC_FLAG_EMU_EDGE)
503 buf->data[i] = buf->base[i];
505 buf->data[i] = buf->base[i] +
506 FFALIGN((buf->linesize[i]*edge >> v_shift) +
507 (pixel_size*edge >> h_shift), 32);
511 buf->pix_fmt = s->pix_fmt;
518 static void free_buffer_pool(InputStream *ist)
520 FrameBuffer *buf = ist->buffer_pool;
522 ist->buffer_pool = buf->next;
523 av_freep(&buf->base[0]);
525 buf = ist->buffer_pool;
529 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
531 av_assert0(buf->refcount);
533 if (!buf->refcount) {
534 buf->next = ist->buffer_pool;
535 ist->buffer_pool = buf;
539 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
541 InputStream *ist = s->opaque;
545 if (!ist->buffer_pool && (ret = alloc_buffer(ist, &ist->buffer_pool)) < 0)
548 buf = ist->buffer_pool;
549 ist->buffer_pool = buf->next;
551 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
552 av_freep(&buf->base[0]);
555 if ((ret = alloc_buffer(ist, &buf)) < 0)
561 frame->type = FF_BUFFER_TYPE_USER;
562 frame->extended_data = frame->data;
563 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
565 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
566 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
567 frame->data[i] = buf->data[i];
568 frame->linesize[i] = buf->linesize[i];
574 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
576 InputStream *ist = s->opaque;
577 FrameBuffer *buf = frame->opaque;
580 if(frame->type!=FF_BUFFER_TYPE_USER)
581 return avcodec_default_release_buffer(s, frame);
583 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
584 frame->data[i] = NULL;
586 unref_buffer(ist, buf);
589 static void filter_release_buffer(AVFilterBuffer *fb)
591 FrameBuffer *buf = fb->priv;
593 unref_buffer(buf->ist, buf);
598 static int configure_video_filters(InputStream *ist, OutputStream *ost)
600 AVFilterContext *last_filter, *filter;
601 /** filter graph containing all filters including input & output */
602 AVCodecContext *codec = ost->st->codec;
603 AVCodecContext *icodec = ist->st->codec;
604 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
605 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
606 AVRational sample_aspect_ratio;
610 ost->graph = avfilter_graph_alloc();
612 if (ist->st->sample_aspect_ratio.num) {
613 sample_aspect_ratio = ist->st->sample_aspect_ratio;
615 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
617 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
618 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
619 sample_aspect_ratio.num, sample_aspect_ratio.den);
621 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
622 "src", args, NULL, ost->graph);
625 #if FF_API_OLD_VSINK_API
626 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
627 "out", NULL, pix_fmts, ost->graph);
629 buffersink_params->pixel_fmts = pix_fmts;
630 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
631 "out", NULL, buffersink_params, ost->graph);
633 av_freep(&buffersink_params);
636 last_filter = ost->input_video_filter;
638 if (codec->width != icodec->width || codec->height != icodec->height) {
639 snprintf(args, 255, "%d:%d:flags=0x%X",
642 (unsigned)ost->sws_flags);
643 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
644 NULL, args, NULL, ost->graph)) < 0)
646 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
648 last_filter = filter;
651 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
652 ost->graph->scale_sws_opts = av_strdup(args);
655 AVFilterInOut *outputs = avfilter_inout_alloc();
656 AVFilterInOut *inputs = avfilter_inout_alloc();
658 outputs->name = av_strdup("in");
659 outputs->filter_ctx = last_filter;
660 outputs->pad_idx = 0;
661 outputs->next = NULL;
663 inputs->name = av_strdup("out");
664 inputs->filter_ctx = ost->output_video_filter;
668 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
670 av_freep(&ost->avfilter);
672 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
676 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
679 codec->width = ost->output_video_filter->inputs[0]->w;
680 codec->height = ost->output_video_filter->inputs[0]->h;
681 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
682 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
683 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
684 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
688 #endif /* CONFIG_AVFILTER */
690 static void term_exit(void)
692 av_log(NULL, AV_LOG_QUIET, "%s", "");
695 tcsetattr (0, TCSANOW, &oldtty);
699 static volatile int received_sigterm = 0;
701 static void sigterm_handler(int sig)
703 received_sigterm = sig;
704 received_nb_signals++;
706 if(received_nb_signals > 3)
710 static void term_init(void)
720 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
721 |INLCR|IGNCR|ICRNL|IXON);
722 tty.c_oflag |= OPOST;
723 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
724 tty.c_cflag &= ~(CSIZE|PARENB);
729 tcsetattr (0, TCSANOW, &tty);
730 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
733 avformat_network_deinit();
735 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
736 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
738 signal(SIGXCPU, sigterm_handler);
742 /* read a key without blocking */
743 static int read_key(void)
755 n = select(1, &rfds, NULL, NULL, &tv);
764 # if HAVE_PEEKNAMEDPIPE
766 static HANDLE input_handle;
769 input_handle = GetStdHandle(STD_INPUT_HANDLE);
770 is_pipe = !GetConsoleMode(input_handle, &dw);
773 if (stdin->_cnt > 0) {
778 /* When running under a GUI, you will end here. */
779 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
796 static int decode_interrupt_cb(void *ctx)
798 return received_nb_signals > 1;
801 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
803 void av_noreturn exit_program(int ret)
808 for (i = 0; i < nb_output_files; i++) {
809 AVFormatContext *s = output_files[i].ctx;
810 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
812 avformat_free_context(s);
813 av_dict_free(&output_files[i].opts);
815 for (i = 0; i < nb_input_files; i++) {
816 avformat_close_input(&input_files[i].ctx);
818 for (i = 0; i < nb_input_streams; i++) {
819 av_freep(&input_streams[i].decoded_frame);
820 av_freep(&input_streams[i].filtered_frame);
821 av_dict_free(&input_streams[i].opts);
822 free_buffer_pool(&input_streams[i]);
827 av_free(vstats_filename);
829 av_freep(&input_streams);
830 av_freep(&input_files);
831 av_freep(&output_streams);
832 av_freep(&output_files);
837 allocated_audio_buf_size = allocated_audio_out_size = 0;
842 avformat_network_deinit();
844 av_freep(&input_tmp);
846 if (received_sigterm) {
847 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
848 (int) received_sigterm);
852 exit(ret); /* not all OS-es handle main() return value */
855 static void assert_avoptions(AVDictionary *m)
857 AVDictionaryEntry *t;
858 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
859 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
864 static void assert_codec_experimental(AVCodecContext *c, int encoder)
866 const char *codec_string = encoder ? "encoder" : "decoder";
868 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
869 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
870 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
871 "results.\nAdd '-strict experimental' if you want to use it.\n",
872 codec_string, c->codec->name);
873 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
874 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
875 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
876 codec_string, codec->name);
881 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
883 if (codec && codec->sample_fmts) {
884 const enum AVSampleFormat *p = codec->sample_fmts;
885 for (; *p != -1; p++) {
886 if (*p == st->codec->sample_fmt)
890 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
891 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
892 if(av_get_sample_fmt_name(st->codec->sample_fmt))
893 av_log(NULL, AV_LOG_WARNING,
894 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
895 av_get_sample_fmt_name(st->codec->sample_fmt),
897 av_get_sample_fmt_name(codec->sample_fmts[0]));
898 st->codec->sample_fmt = codec->sample_fmts[0];
903 static void choose_sample_rate(AVStream *st, AVCodec *codec)
905 if (codec && codec->supported_samplerates) {
906 const int *p = codec->supported_samplerates;
908 int best_dist = INT_MAX;
910 int dist = abs(st->codec->sample_rate - *p);
911 if (dist < best_dist) {
917 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
919 st->codec->sample_rate = best;
923 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
925 if (codec && codec->pix_fmts) {
926 const enum PixelFormat *p = codec->pix_fmts;
927 int has_alpha= av_pix_fmt_descriptors[st->codec->pix_fmt].nb_components % 2 == 0;
928 enum PixelFormat best= PIX_FMT_NONE;
929 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
930 if (st->codec->codec_id == CODEC_ID_MJPEG) {
931 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
932 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
933 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
934 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
937 for (; *p != PIX_FMT_NONE; p++) {
938 best= avcodec_find_best_pix_fmt2(best, *p, st->codec->pix_fmt, has_alpha, NULL);
939 if (*p == st->codec->pix_fmt)
942 if (*p == PIX_FMT_NONE) {
943 if (st->codec->pix_fmt != PIX_FMT_NONE)
944 av_log(NULL, AV_LOG_WARNING,
945 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
946 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
948 av_pix_fmt_descriptors[best].name);
949 st->codec->pix_fmt = best;
954 static double get_sync_ipts(const OutputStream *ost)
956 const InputStream *ist = ost->sync_ist;
957 OutputFile *of = &output_files[ost->file_index];
958 return (double)(ist->pts - of->start_time) / AV_TIME_BASE;
961 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc)
966 AVPacket new_pkt = *pkt;
967 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
968 &new_pkt.data, &new_pkt.size,
969 pkt->data, pkt->size,
970 pkt->flags & AV_PKT_FLAG_KEY);
973 new_pkt.destruct = av_destruct_packet;
975 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
976 bsfc->filter->name, pkt->stream_index,
977 avctx->codec ? avctx->codec->name : "copy");
987 ret = av_interleaved_write_frame(s, pkt);
989 print_error("av_interleaved_write_frame()", ret);
994 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
996 int fill_char = 0x00;
997 if (sample_fmt == AV_SAMPLE_FMT_U8)
999 memset(buf, fill_char, size);
1002 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1003 InputStream *ist, AVFrame *decoded_frame)
1006 int64_t audio_out_size, audio_buf_size;
1008 int size_out, frame_bytes, ret, resample_changed;
1009 AVCodecContext *enc = ost->st->codec;
1010 AVCodecContext *dec = ist->st->codec;
1011 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1012 int isize = av_get_bytes_per_sample(dec->sample_fmt);
1013 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
1014 uint8_t *buf = decoded_frame->data[0];
1015 int size = decoded_frame->nb_samples * dec->channels * isize;
1016 int64_t allocated_for_size = size;
1019 audio_buf_size = (allocated_for_size + isize * dec->channels - 1) / (isize * dec->channels);
1020 audio_buf_size = (audio_buf_size * enc->sample_rate + dec->sample_rate) / dec->sample_rate;
1021 audio_buf_size = audio_buf_size * 2 + 10000; // safety factors for the deprecated resampling API
1022 audio_buf_size = FFMAX(audio_buf_size, enc->frame_size);
1023 audio_buf_size *= osize * enc->channels;
1025 audio_out_size = FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
1026 if (coded_bps > 8 * osize)
1027 audio_out_size = audio_out_size * coded_bps / (8*osize);
1028 audio_out_size += FF_MIN_BUFFER_SIZE;
1030 if (audio_out_size > INT_MAX || audio_buf_size > INT_MAX) {
1031 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
1035 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
1036 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
1037 if (!audio_buf || !audio_out) {
1038 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1042 if (enc->channels != dec->channels
1043 || enc->sample_fmt != dec->sample_fmt
1044 || enc->sample_rate!= dec->sample_rate
1046 ost->audio_resample = 1;
1048 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1049 ost->resample_channels != dec->channels ||
1050 ost->resample_sample_rate != dec->sample_rate;
1052 if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
1053 if (resample_changed) {
1054 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",
1055 ist->file_index, ist->st->index,
1056 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
1057 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
1058 ost->resample_sample_fmt = dec->sample_fmt;
1059 ost->resample_channels = dec->channels;
1060 ost->resample_sample_rate = dec->sample_rate;
1061 swr_free(&ost->swr);
1063 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1064 if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
1065 ost->resample_sample_fmt == enc->sample_fmt &&
1066 ost->resample_channels == enc->channels &&
1067 ost->resample_sample_rate == enc->sample_rate) {
1069 ost->audio_resample = 0;
1071 ost->swr = swr_alloc_set_opts(ost->swr,
1072 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
1073 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
1075 if (ost->audio_channels_mapped)
1076 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
1077 av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
1078 if (ost->audio_channels_mapped) {
1079 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
1080 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
1082 av_opt_set_int(ost->swr, "ich", dec->channels, 0);
1083 av_opt_set_int(ost->swr, "och", enc->channels, 0);
1084 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
1085 if(ost->swr && swr_init(ost->swr) < 0){
1086 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
1087 swr_free(&ost->swr);
1091 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1092 dec->channels, dec->sample_rate,
1093 enc->channels, enc->sample_rate);
1099 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1101 if (audio_sync_method) {
1102 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts -
1103 av_fifo_size(ost->fifo) / (enc->channels * osize);
1104 int idelta = delta * dec->sample_rate / enc->sample_rate;
1105 int byte_delta = idelta * isize * dec->channels;
1107 // FIXME resample delay
1108 if (fabs(delta) > 50) {
1109 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1110 if (byte_delta < 0) {
1111 byte_delta = FFMAX(byte_delta, -size);
1114 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1115 -byte_delta / (isize * dec->channels));
1120 input_tmp = av_realloc(input_tmp, byte_delta + size);
1122 if (byte_delta > allocated_for_size - size) {
1123 allocated_for_size = byte_delta + (int64_t)size;
1128 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
1129 memcpy(input_tmp + byte_delta, buf, size);
1132 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1134 } else if (audio_sync_method > 1) {
1135 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1136 av_assert0(ost->audio_resample);
1137 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1138 delta, comp, enc->sample_rate);
1139 // 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));
1140 swr_compensate(ost->swr, comp, enc->sample_rate);
1144 ost->sync_opts = lrintf(get_sync_ipts(ost) * enc->sample_rate) -
1145 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1147 if (ost->audio_resample) {
1149 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
1150 (const uint8_t*[]){buf }, size / (dec->channels * isize));
1151 size_out = size_out * enc->channels * osize;
1157 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1159 /* now encode as many frames as possible */
1160 if (enc->frame_size > 1) {
1161 /* output resampled raw samples */
1162 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1163 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1166 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1168 frame_bytes = enc->frame_size * osize * enc->channels;
1170 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1172 av_init_packet(&pkt);
1174 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1176 // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1178 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1179 (short *)audio_buf);
1181 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1185 pkt.stream_index = ost->index;
1186 pkt.data = audio_out;
1188 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1189 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1190 pkt.flags |= AV_PKT_FLAG_KEY;
1191 write_frame(s, &pkt, enc, ost->bitstream_filters);
1193 ost->sync_opts += enc->frame_size;
1197 av_init_packet(&pkt);
1199 ost->sync_opts += size_out / (osize * enc->channels);
1201 /* output a pcm frame */
1202 /* determine the size of the coded buffer */
1205 size_out = size_out * coded_bps / 8;
1207 if (size_out > audio_out_size) {
1208 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1212 // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1213 ret = avcodec_encode_audio(enc, audio_out, size_out,
1216 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1220 pkt.stream_index = ost->index;
1221 pkt.data = audio_out;
1223 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1224 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1225 pkt.flags |= AV_PKT_FLAG_KEY;
1226 write_frame(s, &pkt, enc, ost->bitstream_filters);
1230 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1232 AVCodecContext *dec;
1233 AVPicture *picture2;
1234 AVPicture picture_tmp;
1237 dec = ist->st->codec;
1239 /* deinterlace : must be done before any resize */
1240 if (do_deinterlace) {
1243 /* create temporary picture */
1244 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1245 buf = av_malloc(size);
1249 picture2 = &picture_tmp;
1250 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1252 if (avpicture_deinterlace(picture2, picture,
1253 dec->pix_fmt, dec->width, dec->height) < 0) {
1254 /* if error, do not deinterlace */
1255 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1264 if (picture != picture2)
1265 *picture = *picture2;
1269 static void do_subtitle_out(AVFormatContext *s,
1275 static uint8_t *subtitle_out = NULL;
1276 int subtitle_out_max_size = 1024 * 1024;
1277 int subtitle_out_size, nb, i;
1278 AVCodecContext *enc;
1281 if (pts == AV_NOPTS_VALUE) {
1282 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1288 enc = ost->st->codec;
1290 if (!subtitle_out) {
1291 subtitle_out = av_malloc(subtitle_out_max_size);
1294 /* Note: DVB subtitle need one packet to draw them and one other
1295 packet to clear them */
1296 /* XXX: signal it in the codec context ? */
1297 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1302 for (i = 0; i < nb; i++) {
1303 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1304 // start_display_time is required to be 0
1305 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1306 sub->end_display_time -= sub->start_display_time;
1307 sub->start_display_time = 0;
1308 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1309 subtitle_out_max_size, sub);
1310 if (subtitle_out_size < 0) {
1311 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1315 av_init_packet(&pkt);
1316 pkt.stream_index = ost->index;
1317 pkt.data = subtitle_out;
1318 pkt.size = subtitle_out_size;
1319 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1320 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1321 /* XXX: the pts correction is handled here. Maybe handling
1322 it in the codec would be better */
1324 pkt.pts += 90 * sub->start_display_time;
1326 pkt.pts += 90 * sub->end_display_time;
1328 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1332 static int bit_buffer_size = 1024 * 256;
1333 static uint8_t *bit_buffer = NULL;
1335 static void do_video_resample(OutputStream *ost,
1337 AVFrame *in_picture,
1338 AVFrame **out_picture)
1341 *out_picture = in_picture;
1343 AVCodecContext *dec = ist->st->codec;
1344 AVCodecContext *enc = ost->st->codec;
1345 int resample_changed = ost->resample_width != dec->width ||
1346 ost->resample_height != dec->height ||
1347 ost->resample_pix_fmt != dec->pix_fmt;
1349 *out_picture = in_picture;
1350 if (resample_changed) {
1351 av_log(NULL, AV_LOG_INFO,
1352 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1353 ist->file_index, ist->st->index,
1354 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1355 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1356 ost->resample_width = dec->width;
1357 ost->resample_height = dec->height;
1358 ost->resample_pix_fmt = dec->pix_fmt;
1361 ost->video_resample = dec->width != enc->width ||
1362 dec->height != enc->height ||
1363 dec->pix_fmt != enc->pix_fmt;
1365 if (ost->video_resample) {
1366 *out_picture = &ost->resample_frame;
1367 if (!ost->img_resample_ctx || resample_changed) {
1368 /* initialize the destination picture */
1369 if (!ost->resample_frame.data[0]) {
1370 avcodec_get_frame_defaults(&ost->resample_frame);
1371 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1372 enc->width, enc->height)) {
1373 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1377 /* initialize a new scaler context */
1378 sws_freeContext(ost->img_resample_ctx);
1379 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1380 enc->width, enc->height, enc->pix_fmt,
1381 ost->sws_flags, NULL, NULL, NULL);
1382 if (ost->img_resample_ctx == NULL) {
1383 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1387 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1388 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1394 static void do_video_out(AVFormatContext *s,
1397 AVFrame *in_picture,
1398 int *frame_size, float quality)
1400 int nb_frames, i, ret, format_video_sync;
1401 AVFrame *final_picture;
1402 AVCodecContext *enc;
1404 double duration = 0;
1406 enc = ost->st->codec;
1408 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1409 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1410 if(ist->st->avg_frame_rate.num)
1411 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1413 duration /= av_q2d(enc->time_base);
1416 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1418 /* by default, we output a single frame */
1423 format_video_sync = video_sync_method;
1424 if (format_video_sync < 0)
1425 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? 0 : 2) : 1;
1427 if (format_video_sync) {
1428 double vdelta = sync_ipts - ost->sync_opts + duration;
1429 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1432 else if (format_video_sync == 2) {
1433 if (vdelta <= -0.6) {
1435 } else if (vdelta > 0.6)
1436 ost->sync_opts = lrintf(sync_ipts);
1437 } else if (vdelta > 1.1)
1438 nb_frames = lrintf(vdelta);
1439 //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);
1440 if (nb_frames == 0) {
1442 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1443 } else if (nb_frames > 1) {
1444 nb_frames_dup += nb_frames - 1;
1445 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1448 ost->sync_opts = lrintf(sync_ipts);
1450 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1454 do_video_resample(ost, ist, in_picture, &final_picture);
1456 /* duplicates frame if needed */
1457 for (i = 0; i < nb_frames; i++) {
1459 av_init_packet(&pkt);
1460 pkt.stream_index = ost->index;
1462 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1463 enc->codec->id == CODEC_ID_RAWVIDEO) {
1464 /* raw pictures are written as AVPicture structure to
1465 avoid any copies. We support temporarily the older
1467 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1468 enc->coded_frame->top_field_first = in_picture->top_field_first;
1469 pkt.data = (uint8_t *)final_picture;
1470 pkt.size = sizeof(AVPicture);
1471 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1472 pkt.flags |= AV_PKT_FLAG_KEY;
1474 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1476 AVFrame big_picture;
1478 big_picture = *final_picture;
1479 /* better than nothing: use input picture interlaced
1481 big_picture.interlaced_frame = in_picture->interlaced_frame;
1482 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1483 if (ost->top_field_first == -1)
1484 big_picture.top_field_first = in_picture->top_field_first;
1486 big_picture.top_field_first = !!ost->top_field_first;
1489 /* handles same_quant here. This is not correct because it may
1490 not be a global option */
1491 big_picture.quality = quality;
1492 if (!enc->me_threshold)
1493 big_picture.pict_type = 0;
1494 // big_picture.pts = AV_NOPTS_VALUE;
1495 big_picture.pts = ost->sync_opts;
1496 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1497 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1498 if (ost->forced_kf_index < ost->forced_kf_count &&
1499 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1500 big_picture.pict_type = AV_PICTURE_TYPE_I;
1501 ost->forced_kf_index++;
1503 ret = avcodec_encode_video(enc,
1504 bit_buffer, bit_buffer_size,
1507 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1512 pkt.data = bit_buffer;
1514 if (enc->coded_frame->pts != AV_NOPTS_VALUE)
1515 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1516 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1517 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1518 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1520 if (enc->coded_frame->key_frame)
1521 pkt.flags |= AV_PKT_FLAG_KEY;
1522 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1525 // fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1526 // enc->frame_number-1, ret, enc->pict_type);
1527 /* if two pass, output log */
1528 if (ost->logfile && enc->stats_out) {
1529 fprintf(ost->logfile, "%s", enc->stats_out);
1534 ost->frame_number++;
1538 static double psnr(double d)
1540 return -10.0 * log(d) / log(10.0);
1543 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1546 AVCodecContext *enc;
1548 double ti1, bitrate, avg_bitrate;
1550 /* this is executed just the first time do_video_stats is called */
1552 vstats_file = fopen(vstats_filename, "w");
1559 enc = ost->st->codec;
1560 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1561 frame_number = ost->frame_number;
1562 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1563 if (enc->flags&CODEC_FLAG_PSNR)
1564 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1566 fprintf(vstats_file,"f_size= %6d ", frame_size);
1567 /* compute pts value */
1568 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1572 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1573 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1574 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1575 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1576 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1580 static void print_report(OutputFile *output_files,
1581 OutputStream *ost_table, int nb_ostreams,
1582 int is_last_report, int64_t timer_start, int64_t cur_time)
1586 AVFormatContext *oc;
1588 AVCodecContext *enc;
1589 int frame_number, vid, i;
1591 int64_t pts = INT64_MAX;
1592 static int64_t last_time = -1;
1593 static int qp_histogram[52];
1594 int hours, mins, secs, us;
1596 if (!print_stats && !is_last_report)
1599 if (!is_last_report) {
1600 if (last_time == -1) {
1601 last_time = cur_time;
1604 if ((cur_time - last_time) < 500000)
1606 last_time = cur_time;
1610 oc = output_files[0].ctx;
1612 total_size = avio_size(oc->pb);
1613 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
1614 total_size = avio_tell(oc->pb);
1621 for (i = 0; i < nb_ostreams; i++) {
1623 ost = &ost_table[i];
1624 enc = ost->st->codec;
1625 if (!ost->stream_copy && enc->coded_frame)
1626 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1627 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1628 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1630 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1631 float t = (cur_time-timer_start) / 1000000.0;
1633 frame_number = ost->frame_number;
1634 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1635 frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1637 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1641 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1643 for (j = 0; j < 32; j++)
1644 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1646 if (enc->flags&CODEC_FLAG_PSNR) {
1648 double error, error_sum = 0;
1649 double scale, scale_sum = 0;
1650 char type[3] = { 'Y','U','V' };
1651 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1652 for (j = 0; j < 3; j++) {
1653 if (is_last_report) {
1654 error = enc->error[j];
1655 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1657 error = enc->coded_frame->error[j];
1658 scale = enc->width * enc->height * 255.0 * 255.0;
1664 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1666 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1670 /* compute min output value */
1671 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1672 ost->st->time_base, AV_TIME_BASE_Q));
1675 secs = pts / AV_TIME_BASE;
1676 us = pts % AV_TIME_BASE;
1682 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1684 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1685 "size=%8.0fkB time=", total_size / 1024.0);
1686 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1687 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1688 (100 * us) / AV_TIME_BASE);
1689 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1690 "bitrate=%6.1fkbits/s", bitrate);
1692 if (nb_frames_dup || nb_frames_drop)
1693 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1694 nb_frames_dup, nb_frames_drop);
1696 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1700 if (is_last_report) {
1701 int64_t raw= audio_size + video_size + extra_size;
1702 av_log(NULL, AV_LOG_INFO, "\n");
1703 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1704 video_size / 1024.0,
1705 audio_size / 1024.0,
1706 extra_size / 1024.0,
1707 100.0 * (total_size - raw) / raw
1709 if(video_size + audio_size + extra_size == 0){
1710 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1715 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1719 for (i = 0; i < nb_ostreams; i++) {
1720 OutputStream *ost = &ost_table[i];
1721 AVCodecContext *enc = ost->st->codec;
1722 AVFormatContext *os = output_files[ost->file_index].ctx;
1724 if (!ost->encoding_needed)
1727 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1729 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1735 av_init_packet(&pkt);
1736 pkt.stream_index = ost->index;
1738 switch (ost->st->codec->codec_type) {
1739 case AVMEDIA_TYPE_AUDIO:
1740 fifo_bytes = av_fifo_size(ost->fifo);
1742 /* encode any samples remaining in fifo */
1743 if (fifo_bytes > 0) {
1744 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1745 int fs_tmp = enc->frame_size;
1747 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1748 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1749 enc->frame_size = fifo_bytes / (osize * enc->channels);
1751 int frame_bytes = enc->frame_size*osize*enc->channels;
1752 if (allocated_audio_buf_size < frame_bytes)
1754 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1757 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1758 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1759 ost->st->time_base.num, enc->sample_rate);
1760 enc->frame_size = fs_tmp;
1763 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1766 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1770 pkt.flags |= AV_PKT_FLAG_KEY;
1772 case AVMEDIA_TYPE_VIDEO:
1773 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1775 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1779 if (enc->coded_frame && enc->coded_frame->key_frame)
1780 pkt.flags |= AV_PKT_FLAG_KEY;
1781 if (ost->logfile && enc->stats_out) {
1782 fprintf(ost->logfile, "%s", enc->stats_out);
1791 pkt.data = bit_buffer;
1793 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1794 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1795 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1801 * Check whether a packet from ist should be written into ost at this time
1803 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1805 OutputFile *of = &output_files[ost->file_index];
1806 int ist_index = ist - input_streams;
1808 if (ost->source_index != ist_index)
1811 if (of->start_time && ist->pts < of->start_time)
1814 if (of->recording_time != INT64_MAX &&
1815 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1816 (AVRational){ 1, 1000000 }) >= 0) {
1817 ost->is_past_recording_time = 1;
1824 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1826 OutputFile *of = &output_files[ost->file_index];
1827 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1831 av_init_packet(&opkt);
1833 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1834 !ost->copy_initial_nonkeyframes)
1837 /* force the input stream PTS */
1838 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1839 audio_size += pkt->size;
1840 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1841 video_size += pkt->size;
1845 opkt.stream_index = ost->index;
1846 if (pkt->pts != AV_NOPTS_VALUE)
1847 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1849 opkt.pts = AV_NOPTS_VALUE;
1851 if (pkt->dts == AV_NOPTS_VALUE)
1852 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1854 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1855 opkt.dts -= ost_tb_start_time;
1857 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1858 opkt.flags = pkt->flags;
1860 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1861 if ( ost->st->codec->codec_id != CODEC_ID_H264
1862 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1863 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1865 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1866 opkt.destruct = av_destruct_packet;
1868 opkt.data = pkt->data;
1869 opkt.size = pkt->size;
1871 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1872 /* store AVPicture in AVPacket, as expected by the output format */
1873 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1874 opkt.data = (uint8_t *)&pict;
1875 opkt.size = sizeof(AVPicture);
1876 opkt.flags |= AV_PKT_FLAG_KEY;
1879 write_frame(of->ctx, &opkt, ost->st->codec, ost->bitstream_filters);
1880 ost->st->codec->frame_number++;
1881 ost->frame_number++;
1882 av_free_packet(&opkt);
1885 static void rate_emu_sleep(InputStream *ist)
1887 if (input_files[ist->file_index].rate_emu) {
1888 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1889 int64_t now = av_gettime() - ist->start;
1895 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1897 AVFrame *decoded_frame;
1898 AVCodecContext *avctx = ist->st->codec;
1899 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1902 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1903 return AVERROR(ENOMEM);
1905 avcodec_get_frame_defaults(ist->decoded_frame);
1906 decoded_frame = ist->decoded_frame;
1908 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1914 /* no audio frame */
1918 /* if the decoder provides a pts, use it instead of the last packet pts.
1919 the decoder could be delaying output by a packet or more. */
1920 if (decoded_frame->pts != AV_NOPTS_VALUE)
1921 ist->next_pts = decoded_frame->pts;
1923 /* increment next_pts to use for the case where the input stream does not
1924 have timestamps or there are multiple frames in the packet */
1925 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1928 // preprocess audio (volume)
1929 if (audio_volume != 256) {
1930 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1931 void *samples = decoded_frame->data[0];
1932 switch (avctx->sample_fmt) {
1933 case AV_SAMPLE_FMT_U8:
1935 uint8_t *volp = samples;
1936 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1937 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1938 *volp++ = av_clip_uint8(v);
1942 case AV_SAMPLE_FMT_S16:
1944 int16_t *volp = samples;
1945 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1946 int v = ((*volp) * audio_volume + 128) >> 8;
1947 *volp++ = av_clip_int16(v);
1951 case AV_SAMPLE_FMT_S32:
1953 int32_t *volp = samples;
1954 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1955 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1956 *volp++ = av_clipl_int32(v);
1960 case AV_SAMPLE_FMT_FLT:
1962 float *volp = samples;
1963 float scale = audio_volume / 256.f;
1964 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1969 case AV_SAMPLE_FMT_DBL:
1971 double *volp = samples;
1972 double scale = audio_volume / 256.;
1973 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1979 av_log(NULL, AV_LOG_FATAL,
1980 "Audio volume adjustment on sample format %s is not supported.\n",
1981 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
1986 rate_emu_sleep(ist);
1988 for (i = 0; i < nb_output_streams; i++) {
1989 OutputStream *ost = &output_streams[i];
1991 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1993 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
1999 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
2001 AVFrame *decoded_frame, *filtered_frame = NULL;
2002 void *buffer_to_free = NULL;
2006 int frame_available = 1;
2009 int64_t *best_effort_timestamp;
2010 AVRational *frame_sample_aspect;
2012 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2013 return AVERROR(ENOMEM);
2015 avcodec_get_frame_defaults(ist->decoded_frame);
2016 decoded_frame = ist->decoded_frame;
2017 pkt->pts = *pkt_pts;
2018 pkt->dts = *pkt_dts;
2019 *pkt_pts = AV_NOPTS_VALUE;
2021 if (pkt->duration) {
2022 duration = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2023 } else if(ist->st->codec->time_base.num != 0) {
2024 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2025 duration = ((int64_t)AV_TIME_BASE *
2026 ist->st->codec->time_base.num * ticks) /
2027 ist->st->codec->time_base.den;
2030 if(*pkt_dts != AV_NOPTS_VALUE && duration) {
2031 *pkt_dts += duration;
2033 *pkt_dts = AV_NOPTS_VALUE;
2035 ret = avcodec_decode_video2(ist->st->codec,
2036 decoded_frame, got_output, pkt);
2040 quality = same_quant ? decoded_frame->quality : 0;
2042 /* no picture yet */
2046 best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
2047 if(*best_effort_timestamp != AV_NOPTS_VALUE)
2048 ist->next_pts = ist->pts = *best_effort_timestamp;
2050 ist->next_pts += duration;
2053 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2056 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2057 for(i=0;i<nb_output_streams;i++) {
2058 OutputStream *ost = ost = &output_streams[i];
2059 if(check_output_constraints(ist, ost)){
2060 if (!frame_sample_aspect->num)
2061 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2062 decoded_frame->pts = ist->pts;
2063 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER) {
2064 FrameBuffer *buf = decoded_frame->opaque;
2065 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2066 decoded_frame->data, decoded_frame->linesize,
2067 AV_PERM_READ | AV_PERM_PRESERVE,
2068 ist->st->codec->width, ist->st->codec->height,
2069 ist->st->codec->pix_fmt);
2071 avfilter_copy_frame_props(fb, decoded_frame);
2073 fb->buf->priv = buf;
2074 fb->buf->free = filter_release_buffer;
2077 av_buffersrc_buffer(ost->input_video_filter, fb);
2079 if((av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE)) < 0){
2080 av_log(0, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2087 rate_emu_sleep(ist);
2089 for (i = 0; i < nb_output_streams; i++) {
2090 OutputStream *ost = &output_streams[i];
2093 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2097 if (ost->input_video_filter) {
2098 frame_available = av_buffersink_poll_frame(ost->output_video_filter);
2100 while (frame_available) {
2101 if (ost->output_video_filter) {
2102 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
2103 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0){
2104 av_log(0, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");
2107 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2108 av_free(buffer_to_free);
2109 return AVERROR(ENOMEM);
2111 avcodec_get_frame_defaults(ist->filtered_frame);
2112 filtered_frame = ist->filtered_frame;
2113 *filtered_frame= *decoded_frame; //for me_threshold
2115 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
2116 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2119 if (ost->picref->video && !ost->frame_aspect_ratio)
2120 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
2122 filtered_frame = decoded_frame;
2125 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
2126 same_quant ? quality : ost->st->codec->global_quality);
2127 if (vstats_filename && frame_size)
2128 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
2131 frame_available = ost->output_video_filter && av_buffersink_poll_frame(ost->output_video_filter);
2132 avfilter_unref_buffer(ost->picref);
2137 av_free(buffer_to_free);
2141 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2143 AVSubtitle subtitle;
2144 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2145 &subtitle, got_output, pkt);
2151 rate_emu_sleep(ist);
2153 for (i = 0; i < nb_output_streams; i++) {
2154 OutputStream *ost = &output_streams[i];
2156 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2159 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2162 avsubtitle_free(&subtitle);
2166 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2167 static int output_packet(InputStream *ist,
2168 OutputStream *ost_table, int nb_ostreams,
2169 const AVPacket *pkt)
2173 int64_t pkt_dts = AV_NOPTS_VALUE;
2174 int64_t pkt_pts = AV_NOPTS_VALUE;
2178 if (ist->next_pts == AV_NOPTS_VALUE)
2179 ist->next_pts = ist->pts;
2183 av_init_packet(&avpkt);
2191 if (pkt->dts != AV_NOPTS_VALUE) {
2192 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2193 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2194 pkt_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2196 if(pkt->pts != AV_NOPTS_VALUE)
2197 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2199 // while we have more to decode or while the decoder did output something on EOF
2200 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2203 ist->pts = ist->next_pts;
2205 if (avpkt.size && avpkt.size != pkt->size) {
2206 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2207 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2208 ist->showed_multi_packet_warning = 1;
2211 switch (ist->st->codec->codec_type) {
2212 case AVMEDIA_TYPE_AUDIO:
2213 ret = transcode_audio (ist, &avpkt, &got_output);
2215 case AVMEDIA_TYPE_VIDEO:
2216 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
2218 case AVMEDIA_TYPE_SUBTITLE:
2219 ret = transcode_subtitles(ist, &avpkt, &got_output);
2229 avpkt.pts= AV_NOPTS_VALUE;
2231 // touch data and size only if not EOF
2233 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2243 /* handle stream copy */
2244 if (!ist->decoding_needed) {
2245 rate_emu_sleep(ist);
2246 ist->pts = ist->next_pts;
2247 switch (ist->st->codec->codec_type) {
2248 case AVMEDIA_TYPE_AUDIO:
2249 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2250 ist->st->codec->sample_rate;
2252 case AVMEDIA_TYPE_VIDEO:
2253 if (pkt->duration) {
2254 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2255 } else if(ist->st->codec->time_base.num != 0) {
2256 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2257 ist->next_pts += ((int64_t)AV_TIME_BASE *
2258 ist->st->codec->time_base.num * ticks) /
2259 ist->st->codec->time_base.den;
2264 for (i = 0; pkt && i < nb_ostreams; i++) {
2265 OutputStream *ost = &ost_table[i];
2267 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2270 do_streamcopy(ist, ost, pkt);
2276 static void print_sdp(OutputFile *output_files, int n)
2280 AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2284 for (i = 0; i < n; i++)
2285 avc[i] = output_files[i].ctx;
2287 av_sdp_create(avc, n, sdp, sizeof(sdp));
2288 printf("SDP:\n%s\n", sdp);
2293 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2294 char *error, int error_len)
2296 InputStream *ist = &input_streams[ist_index];
2297 if (ist->decoding_needed) {
2298 AVCodec *codec = ist->dec;
2300 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2301 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2302 return AVERROR(EINVAL);
2305 ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
2306 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2307 ist->st->codec->get_buffer = codec_get_buffer;
2308 ist->st->codec->release_buffer = codec_release_buffer;
2309 ist->st->codec->opaque = ist;
2312 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2313 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2314 ist->file_index, ist->st->index);
2315 return AVERROR(EINVAL);
2317 assert_codec_experimental(ist->st->codec, 0);
2318 assert_avoptions(ist->opts);
2321 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;
2322 ist->next_pts = AV_NOPTS_VALUE;
2328 static int transcode_init(OutputFile *output_files, int nb_output_files,
2329 InputFile *input_files, int nb_input_files)
2331 int ret = 0, i, j, k;
2332 AVFormatContext *oc;
2333 AVCodecContext *codec, *icodec;
2339 /* init framerate emulation */
2340 for (i = 0; i < nb_input_files; i++) {
2341 InputFile *ifile = &input_files[i];
2342 if (ifile->rate_emu)
2343 for (j = 0; j < ifile->nb_streams; j++)
2344 input_streams[j + ifile->ist_index].start = av_gettime();
2347 /* output stream init */
2348 for (i = 0; i < nb_output_files; i++) {
2349 oc = output_files[i].ctx;
2350 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2351 av_dump_format(oc, i, oc->filename, 1);
2352 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2353 return AVERROR(EINVAL);
2357 /* for each output stream, we compute the right encoding parameters */
2358 for (i = 0; i < nb_output_streams; i++) {
2359 ost = &output_streams[i];
2360 oc = output_files[ost->file_index].ctx;
2361 ist = &input_streams[ost->source_index];
2363 if (ost->attachment_filename)
2366 codec = ost->st->codec;
2367 icodec = ist->st->codec;
2369 ost->st->disposition = ist->st->disposition;
2370 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2371 codec->chroma_sample_location = icodec->chroma_sample_location;
2373 if (ost->stream_copy) {
2374 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2376 if (extra_size > INT_MAX) {
2377 return AVERROR(EINVAL);
2380 /* if stream_copy is selected, no need to decode or encode */
2381 codec->codec_id = icodec->codec_id;
2382 codec->codec_type = icodec->codec_type;
2384 if (!codec->codec_tag) {
2385 if (!oc->oformat->codec_tag ||
2386 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2387 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2388 codec->codec_tag = icodec->codec_tag;
2391 codec->bit_rate = icodec->bit_rate;
2392 codec->rc_max_rate = icodec->rc_max_rate;
2393 codec->rc_buffer_size = icodec->rc_buffer_size;
2394 codec->field_order = icodec->field_order;
2395 codec->extradata = av_mallocz(extra_size);
2396 if (!codec->extradata) {
2397 return AVERROR(ENOMEM);
2399 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2400 codec->extradata_size= icodec->extradata_size;
2402 codec->time_base = ist->st->time_base;
2403 if(!strcmp(oc->oformat->name, "avi")) {
2404 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2405 && av_q2d(ist->st->time_base) < 1.0/500
2407 codec->time_base = icodec->time_base;
2408 codec->time_base.num *= icodec->ticks_per_frame;
2409 codec->time_base.den *= 2;
2411 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2412 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2413 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2415 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2416 && av_q2d(ist->st->time_base) < 1.0/500
2418 codec->time_base = icodec->time_base;
2419 codec->time_base.num *= icodec->ticks_per_frame;
2422 av_reduce(&codec->time_base.num, &codec->time_base.den,
2423 codec->time_base.num, codec->time_base.den, INT_MAX);
2425 switch (codec->codec_type) {
2426 case AVMEDIA_TYPE_AUDIO:
2427 if (audio_volume != 256) {
2428 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2431 codec->channel_layout = icodec->channel_layout;
2432 codec->sample_rate = icodec->sample_rate;
2433 codec->channels = icodec->channels;
2434 codec->frame_size = icodec->frame_size;
2435 codec->audio_service_type = icodec->audio_service_type;
2436 codec->block_align = icodec->block_align;
2438 case AVMEDIA_TYPE_VIDEO:
2439 codec->pix_fmt = icodec->pix_fmt;
2440 codec->width = icodec->width;
2441 codec->height = icodec->height;
2442 codec->has_b_frames = icodec->has_b_frames;
2443 if (!codec->sample_aspect_ratio.num) {
2444 codec->sample_aspect_ratio =
2445 ost->st->sample_aspect_ratio =
2446 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2447 ist->st->codec->sample_aspect_ratio.num ?
2448 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2450 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2452 case AVMEDIA_TYPE_SUBTITLE:
2453 codec->width = icodec->width;
2454 codec->height = icodec->height;
2456 case AVMEDIA_TYPE_DATA:
2457 case AVMEDIA_TYPE_ATTACHMENT:
2464 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2466 ist->decoding_needed = 1;
2467 ost->encoding_needed = 1;
2469 switch (codec->codec_type) {
2470 case AVMEDIA_TYPE_AUDIO:
2471 ost->fifo = av_fifo_alloc(1024);
2473 return AVERROR(ENOMEM);
2475 if (!codec->sample_rate)
2476 codec->sample_rate = icodec->sample_rate;
2477 choose_sample_rate(ost->st, ost->enc);
2478 codec->time_base = (AVRational){ 1, codec->sample_rate };
2480 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2481 codec->sample_fmt = icodec->sample_fmt;
2482 choose_sample_fmt(ost->st, ost->enc);
2484 if (ost->audio_channels_mapped) {
2485 /* the requested output channel is set to the number of
2486 * -map_channel only if no -ac are specified */
2487 if (!codec->channels) {
2488 codec->channels = ost->audio_channels_mapped;
2489 codec->channel_layout = av_get_default_channel_layout(codec->channels);
2490 if (!codec->channel_layout) {
2491 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2495 /* fill unused channel mapping with -1 (which means a muted
2496 * channel in case the number of output channels is bigger
2497 * than the number of mapped channel) */
2498 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2499 ost->audio_channels_map[j] = -1;
2500 } else if (!codec->channels) {
2501 codec->channels = icodec->channels;
2502 codec->channel_layout = icodec->channel_layout;
2504 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2505 codec->channel_layout = 0;
2507 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2508 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2509 || codec->channel_layout != icodec->channel_layout;
2510 icodec->request_channels = codec->channels;
2511 ost->resample_sample_fmt = icodec->sample_fmt;
2512 ost->resample_sample_rate = icodec->sample_rate;
2513 ost->resample_channels = icodec->channels;
2515 case AVMEDIA_TYPE_VIDEO:
2516 if (codec->pix_fmt == PIX_FMT_NONE)
2517 codec->pix_fmt = icodec->pix_fmt;
2518 choose_pixel_fmt(ost->st, ost->enc);
2520 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2521 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2525 if (!codec->width || !codec->height) {
2526 codec->width = icodec->width;
2527 codec->height = icodec->height;
2530 ost->video_resample = codec->width != icodec->width ||
2531 codec->height != icodec->height ||
2532 codec->pix_fmt != icodec->pix_fmt;
2533 if (ost->video_resample) {
2534 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
2537 ost->resample_height = icodec->height;
2538 ost->resample_width = icodec->width;
2539 ost->resample_pix_fmt = icodec->pix_fmt;
2541 if (!ost->frame_rate.num)
2542 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2543 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2544 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2545 ost->frame_rate = ost->enc->supported_framerates[idx];
2547 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2548 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method
2549 && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2550 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2551 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2553 for (j = 0; j < ost->forced_kf_count; j++)
2554 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2559 if (configure_video_filters(ist, ost)) {
2560 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2565 case AVMEDIA_TYPE_SUBTITLE:
2572 if (codec->codec_id != CODEC_ID_H264 &&
2573 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2574 char logfilename[1024];
2577 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2578 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2580 if (codec->flags & CODEC_FLAG_PASS2) {
2582 size_t logbuffer_size;
2583 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2584 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2588 codec->stats_in = logbuffer;
2590 if (codec->flags & CODEC_FLAG_PASS1) {
2591 f = fopen(logfilename, "wb");
2593 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2594 logfilename, strerror(errno));
2601 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2602 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2603 int size = codec->width * codec->height;
2604 bit_buffer_size = FFMAX(bit_buffer_size, 7*size + 10000);
2609 bit_buffer = av_malloc(bit_buffer_size);
2611 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2613 return AVERROR(ENOMEM);
2616 /* open each encoder */
2617 for (i = 0; i < nb_output_streams; i++) {
2618 ost = &output_streams[i];
2619 if (ost->encoding_needed) {
2620 AVCodec *codec = ost->enc;
2621 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2623 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2624 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2625 ret = AVERROR(EINVAL);
2628 if (dec->subtitle_header) {
2629 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2630 if (!ost->st->codec->subtitle_header) {
2631 ret = AVERROR(ENOMEM);
2634 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2635 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2637 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2638 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2639 ost->file_index, ost->index);
2640 ret = AVERROR(EINVAL);
2643 assert_codec_experimental(ost->st->codec, 1);
2644 assert_avoptions(ost->opts);
2645 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2646 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2647 " It takes bits/s as argument, not kbits/s\n");
2648 extra_size += ost->st->codec->extradata_size;
2650 if (ost->st->codec->me_threshold)
2651 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2655 /* init input streams */
2656 for (i = 0; i < nb_input_streams; i++)
2657 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2660 /* discard unused programs */
2661 for (i = 0; i < nb_input_files; i++) {
2662 InputFile *ifile = &input_files[i];
2663 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2664 AVProgram *p = ifile->ctx->programs[j];
2665 int discard = AVDISCARD_ALL;
2667 for (k = 0; k < p->nb_stream_indexes; k++)
2668 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2669 discard = AVDISCARD_DEFAULT;
2672 p->discard = discard;
2676 /* open files and write file headers */
2677 for (i = 0; i < nb_output_files; i++) {
2678 oc = output_files[i].ctx;
2679 oc->interrupt_callback = int_cb;
2680 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2681 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2682 ret = AVERROR(EINVAL);
2685 // assert_avoptions(output_files[i].opts);
2686 if (strcmp(oc->oformat->name, "rtp")) {
2692 /* dump the file output parameters - cannot be done before in case
2694 for (i = 0; i < nb_output_files; i++) {
2695 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2698 /* dump the stream mapping */
2699 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2700 for (i = 0; i < nb_output_streams; i++) {
2701 ost = &output_streams[i];
2703 if (ost->attachment_filename) {
2704 /* an attached file */
2705 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2706 ost->attachment_filename, ost->file_index, ost->index);
2709 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2710 input_streams[ost->source_index].file_index,
2711 input_streams[ost->source_index].st->index,
2714 if (ost->audio_channels_mapped) {
2715 av_log(NULL, AV_LOG_INFO, " [ch:");
2716 for (j = 0; j < ost->audio_channels_mapped; j++)
2717 if (ost->audio_channels_map[j] == -1)
2718 av_log(NULL, AV_LOG_INFO, " M");
2720 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2721 av_log(NULL, AV_LOG_INFO, "]");
2723 if (ost->sync_ist != &input_streams[ost->source_index])
2724 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2725 ost->sync_ist->file_index,
2726 ost->sync_ist->st->index);
2727 if (ost->stream_copy)
2728 av_log(NULL, AV_LOG_INFO, " (copy)");
2730 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2731 input_streams[ost->source_index].dec->name : "?",
2732 ost->enc ? ost->enc->name : "?");
2733 av_log(NULL, AV_LOG_INFO, "\n");
2737 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2742 print_sdp(output_files, nb_output_files);
2749 * The following code is the main loop of the file converter
2751 static int transcode(OutputFile *output_files, int nb_output_files,
2752 InputFile *input_files, int nb_input_files)
2755 AVFormatContext *is, *os;
2759 int no_packet_count = 0;
2760 int64_t timer_start;
2763 if (!(no_packet = av_mallocz(nb_input_files)))
2766 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2771 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2774 timer_start = av_gettime();
2776 for (; received_sigterm == 0;) {
2777 int file_index, ist_index;
2781 int64_t cur_time= av_gettime();
2783 ipts_min = INT64_MAX;
2785 /* if 'q' pressed, exits */
2787 static int64_t last_time;
2788 if (received_nb_signals)
2790 /* read_key() returns 0 on EOF */
2791 if(cur_time - last_time >= 100000 && !run_as_daemon){
2793 last_time = cur_time;
2798 if (key == '+') av_log_set_level(av_log_get_level()+10);
2799 if (key == '-') av_log_set_level(av_log_get_level()-10);
2800 if (key == 's') qp_hist ^= 1;
2803 do_hex_dump = do_pkt_dump = 0;
2804 } else if(do_pkt_dump){
2808 av_log_set_level(AV_LOG_DEBUG);
2811 if (key == 'c' || key == 'C'){
2812 char buf[4096], target[64], command[256], arg[256] = {0};
2815 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2817 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2822 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2823 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2824 target, time, command, arg);
2825 for (i = 0; i < nb_output_streams; i++) {
2826 ost = &output_streams[i];
2829 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2830 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2831 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2833 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2838 av_log(NULL, AV_LOG_ERROR,
2839 "Parse error, at least 3 arguments were expected, "
2840 "only %d given in string '%s'\n", n, buf);
2844 if (key == 'd' || key == 'D'){
2847 debug = input_streams[0].st->codec->debug<<1;
2848 if(!debug) debug = 1;
2849 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2852 if(scanf("%d", &debug)!=1)
2853 fprintf(stderr,"error parsing debug value\n");
2854 for(i=0;i<nb_input_streams;i++) {
2855 input_streams[i].st->codec->debug = debug;
2857 for(i=0;i<nb_output_streams;i++) {
2858 ost = &output_streams[i];
2859 ost->st->codec->debug = debug;
2861 if(debug) av_log_set_level(AV_LOG_DEBUG);
2862 fprintf(stderr,"debug=%d\n", debug);
2865 fprintf(stderr, "key function\n"
2866 "? show this help\n"
2867 "+ increase verbosity\n"
2868 "- decrease verbosity\n"
2869 "c Send command to filtergraph\n"
2870 "D cycle through available debug modes\n"
2871 "h dump packets/hex press to cycle through the 3 states\n"
2873 "s Show QP histogram\n"
2878 /* select the stream that we must read now by looking at the
2879 smallest output pts */
2881 for (i = 0; i < nb_output_streams; i++) {
2885 ost = &output_streams[i];
2886 of = &output_files[ost->file_index];
2887 os = output_files[ost->file_index].ctx;
2888 ist = &input_streams[ost->source_index];
2889 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2890 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2892 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2894 if (!input_files[ist->file_index].eof_reached) {
2895 if (ipts < ipts_min) {
2898 file_index = ist->file_index;
2900 if (opts < opts_min) {
2902 if (!input_sync) file_index = ist->file_index;
2905 if (ost->frame_number >= ost->max_frames) {
2907 for (j = 0; j < of->ctx->nb_streams; j++)
2908 output_streams[of->ost_index + j].is_past_recording_time = 1;
2912 /* if none, if is finished */
2913 if (file_index < 0) {
2914 if (no_packet_count) {
2915 no_packet_count = 0;
2916 memset(no_packet, 0, nb_input_files);
2923 /* read a frame from it and output it in the fifo */
2924 is = input_files[file_index].ctx;
2925 ret = av_read_frame(is, &pkt);
2926 if (ret == AVERROR(EAGAIN)) {
2927 no_packet[file_index] = 1;
2932 input_files[file_index].eof_reached = 1;
2939 no_packet_count = 0;
2940 memset(no_packet, 0, nb_input_files);
2943 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2944 is->streams[pkt.stream_index]);
2946 /* the following test is needed in case new streams appear
2947 dynamically in stream : we ignore them */
2948 if (pkt.stream_index >= input_files[file_index].nb_streams)
2949 goto discard_packet;
2950 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2951 ist = &input_streams[ist_index];
2953 goto discard_packet;
2955 if (pkt.dts != AV_NOPTS_VALUE)
2956 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2957 if (pkt.pts != AV_NOPTS_VALUE)
2958 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2960 if (pkt.pts != AV_NOPTS_VALUE)
2961 pkt.pts *= ist->ts_scale;
2962 if (pkt.dts != AV_NOPTS_VALUE)
2963 pkt.dts *= ist->ts_scale;
2965 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
2967 // pkt.dts, input_files[ist->file_index].ts_offset,
2968 // ist->st->codec->codec_type);
2969 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2970 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2971 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2972 int64_t delta = pkt_dts - ist->next_pts;
2973 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2974 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2975 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2976 pkt_dts+1<ist->pts)&& !copy_ts){
2977 input_files[ist->file_index].ts_offset -= delta;
2978 av_log(NULL, AV_LOG_DEBUG,
2979 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2980 delta, input_files[ist->file_index].ts_offset);
2981 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2982 if (pkt.pts != AV_NOPTS_VALUE)
2983 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2987 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2988 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
2990 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2991 ist->file_index, ist->st->index);
2994 av_free_packet(&pkt);
2999 av_free_packet(&pkt);
3001 /* dump report by using the output first video and audio streams */
3002 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
3005 /* at the end of stream, we must flush the decoder buffers */
3006 for (i = 0; i < nb_input_streams; i++) {
3007 ist = &input_streams[i];
3008 if (ist->decoding_needed) {
3009 output_packet(ist, output_streams, nb_output_streams, NULL);
3012 flush_encoders(output_streams, nb_output_streams);
3016 /* write the trailer if needed and close file */
3017 for (i = 0; i < nb_output_files; i++) {
3018 os = output_files[i].ctx;
3019 av_write_trailer(os);
3022 /* dump report by using the first video and audio streams */
3023 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
3025 /* close each encoder */
3026 for (i = 0; i < nb_output_streams; i++) {
3027 ost = &output_streams[i];
3028 if (ost->encoding_needed) {
3029 av_freep(&ost->st->codec->stats_in);
3030 avcodec_close(ost->st->codec);
3033 avfilter_graph_free(&ost->graph);
3037 /* close each decoder */
3038 for (i = 0; i < nb_input_streams; i++) {
3039 ist = &input_streams[i];
3040 if (ist->decoding_needed) {
3041 avcodec_close(ist->st->codec);
3049 av_freep(&bit_buffer);
3050 av_freep(&no_packet);
3052 if (output_streams) {
3053 for (i = 0; i < nb_output_streams; i++) {
3054 ost = &output_streams[i];
3056 if (ost->stream_copy)
3057 av_freep(&ost->st->codec->extradata);
3059 fclose(ost->logfile);
3060 ost->logfile = NULL;
3062 av_fifo_free(ost->fifo); /* works even if fifo is not
3063 initialized but set to zero */
3064 av_freep(&ost->st->codec->subtitle_header);
3065 av_free(ost->resample_frame.data[0]);
3066 av_free(ost->forced_kf_pts);
3067 if (ost->video_resample)
3068 sws_freeContext(ost->img_resample_ctx);
3069 swr_free(&ost->swr);
3070 av_dict_free(&ost->opts);
3077 static int opt_frame_crop(const char *opt, const char *arg)
3079 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3080 return AVERROR(EINVAL);
3083 static int opt_pad(const char *opt, const char *arg)
3085 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3089 static double parse_frame_aspect_ratio(const char *arg)
3096 p = strchr(arg, ':');
3098 x = strtol(arg, &end, 10);
3100 y = strtol(end + 1, &end, 10);
3102 ar = (double)x / (double)y;
3104 ar = strtod(arg, NULL);
3107 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
3113 static int opt_video_channel(const char *opt, const char *arg)
3115 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3116 return opt_default("channel", arg);
3119 static int opt_video_standard(const char *opt, const char *arg)
3121 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3122 return opt_default("standard", arg);
3125 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3127 audio_codec_name = arg;
3128 return parse_option(o, "codec:a", arg, options);
3131 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3133 video_codec_name = arg;
3134 return parse_option(o, "codec:v", arg, options);
3137 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3139 subtitle_codec_name = arg;
3140 return parse_option(o, "codec:s", arg, options);
3143 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3145 return parse_option(o, "codec:d", arg, options);
3148 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3150 StreamMap *m = NULL;
3151 int i, negative = 0, file_idx;
3152 int sync_file_idx = -1, sync_stream_idx;
3160 map = av_strdup(arg);
3162 /* parse sync stream first, just pick first matching stream */
3163 if (sync = strchr(map, ',')) {
3165 sync_file_idx = strtol(sync + 1, &sync, 0);
3166 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3167 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3172 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
3173 if (check_stream_specifier(input_files[sync_file_idx].ctx,
3174 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
3175 sync_stream_idx = i;
3178 if (i == input_files[sync_file_idx].nb_streams) {
3179 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3180 "match any streams.\n", arg);
3186 file_idx = strtol(map, &p, 0);
3187 if (file_idx >= nb_input_files || file_idx < 0) {
3188 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3192 /* disable some already defined maps */
3193 for (i = 0; i < o->nb_stream_maps; i++) {
3194 m = &o->stream_maps[i];
3195 if (file_idx == m->file_index &&
3196 check_stream_specifier(input_files[m->file_index].ctx,
3197 input_files[m->file_index].ctx->streams[m->stream_index],
3198 *p == ':' ? p + 1 : p) > 0)
3202 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3203 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3204 *p == ':' ? p + 1 : p) <= 0)
3206 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3207 &o->nb_stream_maps, o->nb_stream_maps + 1);
3208 m = &o->stream_maps[o->nb_stream_maps - 1];
3210 m->file_index = file_idx;
3211 m->stream_index = i;
3213 if (sync_file_idx >= 0) {
3214 m->sync_file_index = sync_file_idx;
3215 m->sync_stream_index = sync_stream_idx;
3217 m->sync_file_index = file_idx;
3218 m->sync_stream_index = i;
3223 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3231 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3233 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3234 &o->nb_attachments, o->nb_attachments + 1);
3235 o->attachments[o->nb_attachments - 1] = arg;
3239 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3245 o->audio_channel_maps =
3246 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3247 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3248 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3250 /* muted channel syntax */
3251 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3252 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3253 m->file_idx = m->stream_idx = -1;
3255 m->ofile_idx = m->ostream_idx = -1;
3260 n = sscanf(arg, "%d.%d.%d:%d.%d",
3261 &m->file_idx, &m->stream_idx, &m->channel_idx,
3262 &m->ofile_idx, &m->ostream_idx);
3264 if (n != 3 && n != 5) {
3265 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3266 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3270 if (n != 5) // only file.stream.channel specified
3271 m->ofile_idx = m->ostream_idx = -1;
3274 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3275 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3279 if (m->stream_idx < 0 ||
3280 m->stream_idx >= input_files[m->file_idx].nb_streams) {
3281 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3282 m->file_idx, m->stream_idx);
3285 st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3286 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3287 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3288 m->file_idx, m->stream_idx);
3291 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3292 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3293 m->file_idx, m->stream_idx, m->channel_idx);
3300 * Parse a metadata specifier in arg.
3301 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3302 * @param index for type c/p, chapter/program index is written here
3303 * @param stream_spec for type s, the stream specifier is written here
3305 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3313 if (*(++arg) && *arg != ':') {
3314 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3317 *stream_spec = *arg == ':' ? arg + 1 : "";
3321 if (*(++arg) == ':')
3322 *index = strtol(++arg, NULL, 0);
3325 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3332 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3334 AVDictionary **meta_in = NULL;
3335 AVDictionary **meta_out;
3337 char type_in, type_out;
3338 const char *istream_spec = NULL, *ostream_spec = NULL;
3339 int idx_in = 0, idx_out = 0;
3341 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3342 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3344 if (type_in == 'g' || type_out == 'g')
3345 o->metadata_global_manual = 1;
3346 if (type_in == 's' || type_out == 's')
3347 o->metadata_streams_manual = 1;
3348 if (type_in == 'c' || type_out == 'c')
3349 o->metadata_chapters_manual = 1;
3351 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3352 if ((index) < 0 || (index) >= (nb_elems)) {\
3353 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3358 #define SET_DICT(type, meta, context, index)\
3361 meta = &context->metadata;\
3364 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3365 meta = &context->chapters[index]->metadata;\
3368 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3369 meta = &context->programs[index]->metadata;\
3373 SET_DICT(type_in, meta_in, ic, idx_in);
3374 SET_DICT(type_out, meta_out, oc, idx_out);
3376 /* for input streams choose first matching stream */
3377 if (type_in == 's') {
3378 for (i = 0; i < ic->nb_streams; i++) {
3379 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3380 meta_in = &ic->streams[i]->metadata;
3386 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3391 if (type_out == 's') {
3392 for (i = 0; i < oc->nb_streams; i++) {
3393 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3394 meta_out = &oc->streams[i]->metadata;
3395 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3400 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3405 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3408 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3409 struct tm time = *gmtime((time_t*)&recording_timestamp);
3410 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3411 parse_option(o, "metadata", buf, options);
3413 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3414 "tag instead.\n", opt);
3418 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3420 const char *codec_string = encoder ? "encoder" : "decoder";
3424 avcodec_find_encoder_by_name(name) :
3425 avcodec_find_decoder_by_name(name);
3427 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3430 if (codec->type != type) {
3431 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3437 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3439 char *codec_name = NULL;
3441 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3443 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3444 st->codec->codec_id = codec->id;
3447 return avcodec_find_decoder(st->codec->codec_id);
3451 * Add all the streams from the given input file to the global
3452 * list of input streams.
3454 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3456 int i, rfps, rfps_base;
3457 char *next, *codec_tag = NULL;
3459 for (i = 0; i < ic->nb_streams; i++) {
3460 AVStream *st = ic->streams[i];
3461 AVCodecContext *dec = st->codec;
3464 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3465 ist = &input_streams[nb_input_streams - 1];
3467 ist->file_index = nb_input_files;
3469 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3471 ist->ts_scale = 1.0;
3472 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3474 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3476 uint32_t tag = strtol(codec_tag, &next, 0);
3478 tag = AV_RL32(codec_tag);
3479 st->codec->codec_tag = tag;
3482 ist->dec = choose_decoder(o, ic, st);
3484 switch (dec->codec_type) {
3485 case AVMEDIA_TYPE_AUDIO:
3487 ist->dec = avcodec_find_decoder(dec->codec_id);
3488 if (o->audio_disable)
3489 st->discard = AVDISCARD_ALL;
3491 case AVMEDIA_TYPE_VIDEO:
3493 ist->dec = avcodec_find_decoder(dec->codec_id);
3494 rfps = ic->streams[i]->r_frame_rate.num;
3495 rfps_base = ic->streams[i]->r_frame_rate.den;
3497 dec->flags |= CODEC_FLAG_EMU_EDGE;
3500 if (dec->time_base.den != rfps * dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3502 av_log(NULL, AV_LOG_INFO,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3503 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3504 (float)rfps / rfps_base, rfps, rfps_base);
3507 if (o->video_disable)
3508 st->discard = AVDISCARD_ALL;
3509 else if (video_discard)
3510 st->discard = video_discard;
3512 case AVMEDIA_TYPE_DATA:
3513 if (o->data_disable)
3514 st->discard= AVDISCARD_ALL;
3516 case AVMEDIA_TYPE_SUBTITLE:
3518 ist->dec = avcodec_find_decoder(dec->codec_id);
3519 if(o->subtitle_disable)
3520 st->discard = AVDISCARD_ALL;
3522 case AVMEDIA_TYPE_ATTACHMENT:
3523 case AVMEDIA_TYPE_UNKNOWN:
3531 static void assert_file_overwrite(const char *filename)
3533 if ((!file_overwrite || no_file_overwrite) &&
3534 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3535 av_strstart(filename, "file:", NULL))) {
3536 if (avio_check(filename, 0) == 0) {
3537 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3538 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3541 signal(SIGINT, SIG_DFL);
3542 if (!read_yesno()) {
3543 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3549 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3556 static void dump_attachment(AVStream *st, const char *filename)
3559 AVIOContext *out = NULL;
3560 AVDictionaryEntry *e;
3562 if (!st->codec->extradata_size) {
3563 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3564 nb_input_files - 1, st->index);
3567 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3568 filename = e->value;
3570 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3571 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3575 assert_file_overwrite(filename);
3577 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3578 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3583 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3588 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3590 AVFormatContext *ic;
3591 AVInputFormat *file_iformat = NULL;
3595 AVDictionary **opts;
3596 int orig_nb_streams; // number of streams before avformat_find_stream_info
3599 if (!(file_iformat = av_find_input_format(o->format))) {
3600 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3605 if (!strcmp(filename, "-"))
3608 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3609 !strcmp(filename, "/dev/stdin");
3611 /* get default parameters from command line */
3612 ic = avformat_alloc_context();
3614 print_error(filename, AVERROR(ENOMEM));
3617 if (o->nb_audio_sample_rate) {
3618 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3619 av_dict_set(&format_opts, "sample_rate", buf, 0);
3621 if (o->nb_audio_channels) {
3622 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3623 av_dict_set(&format_opts, "channels", buf, 0);
3625 if (o->nb_frame_rates) {
3626 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3628 if (o->nb_frame_sizes) {
3629 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3631 if (o->nb_frame_pix_fmts)
3632 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3634 ic->video_codec_id = video_codec_name ?
3635 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3636 ic->audio_codec_id = audio_codec_name ?
3637 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3638 ic->subtitle_codec_id= subtitle_codec_name ?
3639 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3640 ic->flags |= AVFMT_FLAG_NONBLOCK;
3641 ic->interrupt_callback = int_cb;
3644 av_log(NULL, AV_LOG_WARNING,
3645 "-loop_input is deprecated, use -loop 1\n"
3646 "Note, both loop options only work with -f image2\n"
3648 ic->loop_input = loop_input;
3651 /* open the input file with generic avformat function */
3652 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3654 print_error(filename, err);
3657 assert_avoptions(format_opts);
3659 /* apply forced codec ids */
3660 for (i = 0; i < ic->nb_streams; i++)
3661 choose_decoder(o, ic, ic->streams[i]);
3663 /* Set AVCodecContext options for avformat_find_stream_info */
3664 opts = setup_find_stream_info_opts(ic, codec_opts);
3665 orig_nb_streams = ic->nb_streams;
3667 /* If not enough info to get the stream parameters, we decode the
3668 first frames to get it. (used in mpeg case for example) */
3669 ret = avformat_find_stream_info(ic, opts);
3671 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3672 avformat_close_input(&ic);
3676 timestamp = o->start_time;
3677 /* add the stream start time */
3678 if (ic->start_time != AV_NOPTS_VALUE)
3679 timestamp += ic->start_time;
3681 /* if seeking requested, we execute it */
3682 if (o->start_time != 0) {
3683 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3685 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3686 filename, (double)timestamp / AV_TIME_BASE);
3690 /* update the current parameters so that they match the one of the input stream */
3691 add_input_streams(o, ic);
3693 /* dump the file content */
3694 av_dump_format(ic, nb_input_files, filename, 0);
3696 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3697 input_files[nb_input_files - 1].ctx = ic;
3698 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3699 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3700 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3701 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3703 for (i = 0; i < o->nb_dump_attachment; i++) {
3706 for (j = 0; j < ic->nb_streams; j++) {
3707 AVStream *st = ic->streams[j];
3709 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3710 dump_attachment(st, o->dump_attachment[i].u.str);
3714 for (i = 0; i < orig_nb_streams; i++)
3715 av_dict_free(&opts[i]);
3718 reset_options(o, 1);
3722 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3727 for (p = kf; *p; p++)
3730 ost->forced_kf_count = n;
3731 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3732 if (!ost->forced_kf_pts) {
3733 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3736 for (i = 0; i < n; i++) {
3737 p = i ? strchr(p, ',') + 1 : kf;
3738 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3742 static uint8_t *get_line(AVIOContext *s)
3748 if (avio_open_dyn_buf(&line) < 0) {
3749 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3753 while ((c = avio_r8(s)) && c != '\n')
3756 avio_close_dyn_buf(line, &buf);
3761 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3764 char filename[1000];
3765 const char *base[3] = { getenv("AVCONV_DATADIR"),
3770 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3774 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3775 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3776 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3779 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3780 i != 1 ? "" : "/.avconv", preset_name);
3781 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3787 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3789 char *codec_name = NULL;
3791 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3793 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3794 NULL, ost->st->codec->codec_type);
3795 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3796 } else if (!strcmp(codec_name, "copy"))
3797 ost->stream_copy = 1;
3799 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3800 ost->st->codec->codec_id = ost->enc->id;
3804 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3807 AVStream *st = avformat_new_stream(oc, NULL);
3808 int idx = oc->nb_streams - 1, ret = 0;
3809 char *bsf = NULL, *next, *codec_tag = NULL;
3810 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3812 char *buf = NULL, *arg = NULL, *preset = NULL;
3813 AVIOContext *s = NULL;
3816 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3820 if (oc->nb_streams - 1 < o->nb_streamid_map)
3821 st->id = o->streamid_map[oc->nb_streams - 1];
3823 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3824 nb_output_streams + 1);
3825 ost = &output_streams[nb_output_streams - 1];
3826 ost->file_index = nb_output_files;
3829 st->codec->codec_type = type;
3830 choose_encoder(o, oc, ost);
3832 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3835 avcodec_get_context_defaults3(st->codec, ost->enc);
3836 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3838 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3839 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3842 if (!buf[0] || buf[0] == '#') {
3846 if (!(arg = strchr(buf, '='))) {
3847 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3851 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3853 } while (!s->eof_reached);
3857 av_log(NULL, AV_LOG_FATAL,
3858 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3859 preset, ost->file_index, ost->index);
3863 ost->max_frames = INT64_MAX;
3864 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3866 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3868 if (next = strchr(bsf, ','))
3870 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3871 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3875 bsfc_prev->next = bsfc;
3877 ost->bitstream_filters = bsfc;
3883 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3885 uint32_t tag = strtol(codec_tag, &next, 0);
3887 tag = AV_RL32(codec_tag);
3888 st->codec->codec_tag = tag;
3891 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3892 if (qscale >= 0 || same_quant) {
3893 st->codec->flags |= CODEC_FLAG_QSCALE;
3894 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3897 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3898 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3900 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3904 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3907 const char *p = str;
3914 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3921 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3925 AVCodecContext *video_enc;
3927 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3929 video_enc = st->codec;
3931 if (!ost->stream_copy) {
3932 const char *p = NULL;
3933 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3934 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3935 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3938 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3939 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3940 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3944 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3945 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3946 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3950 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3951 if (frame_aspect_ratio)
3952 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3954 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3955 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3956 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3957 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3960 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3963 video_enc->gop_size = 0;
3964 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3966 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3967 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3970 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3972 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3974 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3975 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3978 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3981 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3982 for (i = 0; p; i++) {
3984 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3986 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3989 /* FIXME realloc failure */
3990 video_enc->rc_override =
3991 av_realloc(video_enc->rc_override,
3992 sizeof(RcOverride) * (i + 1));
3993 video_enc->rc_override[i].start_frame = start;
3994 video_enc->rc_override[i].end_frame = end;
3996 video_enc->rc_override[i].qscale = q;
3997 video_enc->rc_override[i].quality_factor = 1.0;
4000 video_enc->rc_override[i].qscale = 0;
4001 video_enc->rc_override[i].quality_factor = -q/100.0;
4006 video_enc->rc_override_count = i;
4007 if (!video_enc->rc_initial_buffer_occupancy)
4008 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4009 video_enc->intra_dc_precision = intra_dc_precision - 8;
4012 video_enc->flags|= CODEC_FLAG_PSNR;
4017 video_enc->flags |= CODEC_FLAG_PASS1;
4020 video_enc->flags |= CODEC_FLAG_PASS2;
4024 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4025 if (forced_key_frames)
4026 parse_forced_key_frames(forced_key_frames, ost);
4028 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4030 ost->top_field_first = -1;
4031 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4033 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4036 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4038 ost->avfilter = av_strdup(filters);
4045 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
4050 AVCodecContext *audio_enc;
4052 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
4055 audio_enc = st->codec;
4056 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4058 if (!ost->stream_copy) {
4059 char *sample_fmt = NULL;
4061 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4063 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4065 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4066 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4070 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4072 ost->rematrix_volume=1.0;
4073 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4076 /* check for channel mapping for this audio stream */
4077 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4078 AudioChannelMap *map = &o->audio_channel_maps[n];
4079 InputStream *ist = &input_streams[ost->source_index];
4080 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4081 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4082 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4083 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4084 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4086 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4087 ost->file_index, ost->st->index);
4094 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
4098 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
4099 if (!ost->stream_copy) {
4100 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4107 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
4109 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
4110 ost->stream_copy = 1;
4114 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
4118 AVCodecContext *subtitle_enc;
4120 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
4122 subtitle_enc = st->codec;
4124 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4129 /* arg format is "output-stream-index:streamid-value". */
4130 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4136 av_strlcpy(idx_str, arg, sizeof(idx_str));
4137 p = strchr(idx_str, ':');
4139 av_log(NULL, AV_LOG_FATAL,
4140 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4145 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4146 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4147 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4151 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4153 AVFormatContext *is = ifile->ctx;
4154 AVFormatContext *os = ofile->ctx;
4157 for (i = 0; i < is->nb_chapters; i++) {
4158 AVChapter *in_ch = is->chapters[i], *out_ch;
4159 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4160 AV_TIME_BASE_Q, in_ch->time_base);
4161 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4162 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4165 if (in_ch->end < ts_off)
4167 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4170 out_ch = av_mallocz(sizeof(AVChapter));
4172 return AVERROR(ENOMEM);
4174 out_ch->id = in_ch->id;
4175 out_ch->time_base = in_ch->time_base;
4176 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4177 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4180 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4183 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4185 return AVERROR(ENOMEM);
4186 os->chapters[os->nb_chapters - 1] = out_ch;
4191 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4194 AVFormatContext *ic = avformat_alloc_context();
4196 ic->interrupt_callback = int_cb;
4197 err = avformat_open_input(&ic, filename, NULL, NULL);
4200 /* copy stream format */
4201 for(i=0;i<ic->nb_streams;i++) {
4205 AVCodecContext *avctx;
4207 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4208 ost = new_output_stream(o, s, codec->type);
4213 // FIXME: a more elegant solution is needed
4214 memcpy(st, ic->streams[i], sizeof(AVStream));
4215 st->info = av_malloc(sizeof(*st->info));
4216 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4218 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4220 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4221 choose_sample_fmt(st, codec);
4222 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4223 choose_pixel_fmt(st, codec);
4226 av_close_input_file(ic);
4230 static void opt_output_file(void *optctx, const char *filename)
4232 OptionsContext *o = optctx;
4233 AVFormatContext *oc;
4235 AVOutputFormat *file_oformat;
4239 if (!strcmp(filename, "-"))
4242 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4244 print_error(filename, err);
4247 file_oformat= oc->oformat;
4248 oc->interrupt_callback = int_cb;
4250 if (!strcmp(file_oformat->name, "ffm") &&
4251 av_strstart(filename, "http:", NULL)) {
4253 /* special case for files sent to ffserver: we get the stream
4254 parameters from ffserver */
4255 int err = read_ffserver_streams(o, oc, filename);
4257 print_error(filename, err);
4260 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4261 ost = &output_streams[j];
4262 for (i = 0; i < nb_input_streams; i++) {
4263 ist = &input_streams[i];
4264 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4266 ost->source_index= i;
4272 av_log(NULL, AV_LOG_FATAL, "Missing %s stream which is required by this ffm\n", av_get_media_type_string(ost->st->codec->codec_type));
4276 } else if (!o->nb_stream_maps) {
4277 /* pick the "best" stream of each type */
4278 #define NEW_STREAM(type, index)\
4280 ost = new_ ## type ## _stream(o, oc);\
4281 ost->source_index = index;\
4282 ost->sync_ist = &input_streams[index];\
4283 input_streams[index].discard = 0;\
4286 /* video: highest resolution */
4287 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4288 int area = 0, idx = -1;
4289 for (i = 0; i < nb_input_streams; i++) {
4290 ist = &input_streams[i];
4291 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4292 ist->st->codec->width * ist->st->codec->height > area) {
4293 area = ist->st->codec->width * ist->st->codec->height;
4297 NEW_STREAM(video, idx);
4300 /* audio: most channels */
4301 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4302 int channels = 0, idx = -1;
4303 for (i = 0; i < nb_input_streams; i++) {
4304 ist = &input_streams[i];
4305 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4306 ist->st->codec->channels > channels) {
4307 channels = ist->st->codec->channels;
4311 NEW_STREAM(audio, idx);
4314 /* subtitles: pick first */
4315 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4316 for (i = 0; i < nb_input_streams; i++)
4317 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4318 NEW_STREAM(subtitle, i);
4322 /* do something with data? */
4324 for (i = 0; i < o->nb_stream_maps; i++) {
4325 StreamMap *map = &o->stream_maps[i];
4330 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4331 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4333 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4335 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4337 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4340 switch (ist->st->codec->codec_type) {
4341 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4342 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4343 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4344 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4345 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4347 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4348 map->file_index, map->stream_index);
4352 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4353 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4354 map->sync_stream_index];
4359 /* handle attached files */
4360 for (i = 0; i < o->nb_attachments; i++) {
4362 uint8_t *attachment;
4366 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4367 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4371 if ((len = avio_size(pb)) <= 0) {
4372 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4376 if (!(attachment = av_malloc(len))) {
4377 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4381 avio_read(pb, attachment, len);
4383 ost = new_attachment_stream(o, oc);
4384 ost->stream_copy = 0;
4385 ost->source_index = -1;
4386 ost->attachment_filename = o->attachments[i];
4387 ost->st->codec->extradata = attachment;
4388 ost->st->codec->extradata_size = len;
4390 p = strrchr(o->attachments[i], '/');
4391 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4395 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4396 output_files[nb_output_files - 1].ctx = oc;
4397 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4398 output_files[nb_output_files - 1].recording_time = o->recording_time;
4399 output_files[nb_output_files - 1].start_time = o->start_time;
4400 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4401 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4403 /* check filename in case of an image number is expected */
4404 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4405 if (!av_filename_number_test(oc->filename)) {
4406 print_error(oc->filename, AVERROR(EINVAL));
4411 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4412 /* test if it already exists to avoid losing precious files */
4413 assert_file_overwrite(filename);
4416 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4417 &oc->interrupt_callback,
4418 &output_files[nb_output_files - 1].opts)) < 0) {
4419 print_error(filename, err);
4424 if (o->mux_preload) {
4426 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4427 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4429 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4431 if (loop_output >= 0) {
4432 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4433 oc->loop_output = loop_output;
4437 for (i = 0; i < o->nb_metadata_map; i++) {
4439 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4441 if (in_file_index < 0)
4443 if (in_file_index >= nb_input_files) {
4444 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4447 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4451 if (o->chapters_input_file >= nb_input_files) {
4452 if (o->chapters_input_file == INT_MAX) {
4453 /* copy chapters from the first input file that has them*/
4454 o->chapters_input_file = -1;
4455 for (i = 0; i < nb_input_files; i++)
4456 if (input_files[i].ctx->nb_chapters) {
4457 o->chapters_input_file = i;
4461 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4462 o->chapters_input_file);
4466 if (o->chapters_input_file >= 0)
4467 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4468 !o->metadata_chapters_manual);
4470 /* copy global metadata by default */
4471 if (!o->metadata_global_manual && nb_input_files){
4472 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4473 AV_DICT_DONT_OVERWRITE);
4474 if(o->recording_time != INT64_MAX)
4475 av_dict_set(&oc->metadata, "duration", NULL, 0);
4477 if (!o->metadata_streams_manual)
4478 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4480 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4482 ist = &input_streams[output_streams[i].source_index];
4483 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4486 /* process manually set metadata */
4487 for (i = 0; i < o->nb_metadata; i++) {
4490 const char *stream_spec;
4491 int index = 0, j, ret;
4493 val = strchr(o->metadata[i].u.str, '=');
4495 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4496 o->metadata[i].u.str);
4501 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4503 for (j = 0; j < oc->nb_streams; j++) {
4504 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4505 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4509 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4517 if (index < 0 || index >= oc->nb_chapters) {
4518 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4521 m = &oc->chapters[index]->metadata;
4524 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4527 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4531 reset_options(o, 0);
4534 /* same option as mencoder */
4535 static int opt_pass(const char *opt, const char *arg)
4537 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4541 static int64_t getutime(void)
4544 struct rusage rusage;
4546 getrusage(RUSAGE_SELF, &rusage);
4547 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4548 #elif HAVE_GETPROCESSTIMES
4550 FILETIME c, e, k, u;
4551 proc = GetCurrentProcess();
4552 GetProcessTimes(proc, &c, &e, &k, &u);
4553 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4555 return av_gettime();
4559 static int64_t getmaxrss(void)
4561 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4562 struct rusage rusage;
4563 getrusage(RUSAGE_SELF, &rusage);
4564 return (int64_t)rusage.ru_maxrss * 1024;
4565 #elif HAVE_GETPROCESSMEMORYINFO
4567 PROCESS_MEMORY_COUNTERS memcounters;
4568 proc = GetCurrentProcess();
4569 memcounters.cb = sizeof(memcounters);
4570 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4571 return memcounters.PeakPagefileUsage;
4577 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4579 return parse_option(o, "q:a", arg, options);
4582 static void show_usage(void)
4584 printf("Hyper fast Audio and Video encoder\n");
4585 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4589 static int opt_help(const char *opt, const char *arg)
4591 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4592 av_log_set_callback(log_callback_help);
4594 show_help_options(options, "Main options:\n",
4595 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4596 show_help_options(options, "\nAdvanced options:\n",
4597 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4599 show_help_options(options, "\nVideo options:\n",
4600 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4602 show_help_options(options, "\nAdvanced Video options:\n",
4603 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4604 OPT_VIDEO | OPT_EXPERT);
4605 show_help_options(options, "\nAudio options:\n",
4606 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4608 show_help_options(options, "\nAdvanced Audio options:\n",
4609 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4610 OPT_AUDIO | OPT_EXPERT);
4611 show_help_options(options, "\nSubtitle options:\n",
4612 OPT_SUBTITLE | OPT_GRAB,
4614 show_help_options(options, "\nAudio/Video grab options:\n",
4618 show_help_children(avcodec_get_class(), flags);
4619 show_help_children(avformat_get_class(), flags);
4620 show_help_children(sws_get_class(), flags);
4625 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4627 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4628 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4630 if (!strncmp(arg, "pal-", 4)) {
4633 } else if (!strncmp(arg, "ntsc-", 5)) {
4636 } else if (!strncmp(arg, "film-", 5)) {
4640 /* Try to determine PAL/NTSC by peeking in the input files */
4641 if (nb_input_files) {
4643 for (j = 0; j < nb_input_files; j++) {
4644 for (i = 0; i < input_files[j].nb_streams; i++) {
4645 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4646 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4648 fr = c->time_base.den * 1000 / c->time_base.num;
4652 } else if ((fr == 29970) || (fr == 23976)) {
4657 if (norm != UNKNOWN)
4661 if (norm != UNKNOWN)
4662 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4665 if (norm == UNKNOWN) {
4666 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4667 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4668 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4672 if (!strcmp(arg, "vcd")) {
4673 opt_video_codec(o, "c:v", "mpeg1video");
4674 opt_audio_codec(o, "c:a", "mp2");
4675 parse_option(o, "f", "vcd", options);
4677 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4678 parse_option(o, "r", frame_rates[norm], options);
4679 opt_default("g", norm == PAL ? "15" : "18");
4681 opt_default("b:v", "1150000");
4682 opt_default("maxrate", "1150000");
4683 opt_default("minrate", "1150000");
4684 opt_default("bufsize", "327680"); // 40*1024*8;
4686 opt_default("b:a", "224000");
4687 parse_option(o, "ar", "44100", options);
4688 parse_option(o, "ac", "2", options);
4690 opt_default("packetsize", "2324");
4691 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4693 /* We have to offset the PTS, so that it is consistent with the SCR.
4694 SCR starts at 36000, but the first two packs contain only padding
4695 and the first pack from the other stream, respectively, may also have
4696 been written before.
4697 So the real data starts at SCR 36000+3*1200. */
4698 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4699 } else if (!strcmp(arg, "svcd")) {
4701 opt_video_codec(o, "c:v", "mpeg2video");
4702 opt_audio_codec(o, "c:a", "mp2");
4703 parse_option(o, "f", "svcd", options);
4705 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4706 parse_option(o, "r", frame_rates[norm], options);
4707 parse_option(o, "pix_fmt", "yuv420p", options);
4708 opt_default("g", norm == PAL ? "15" : "18");
4710 opt_default("b:v", "2040000");
4711 opt_default("maxrate", "2516000");
4712 opt_default("minrate", "0"); // 1145000;
4713 opt_default("bufsize", "1835008"); // 224*1024*8;
4714 opt_default("flags", "+scan_offset");
4717 opt_default("b:a", "224000");
4718 parse_option(o, "ar", "44100", options);
4720 opt_default("packetsize", "2324");
4722 } else if (!strcmp(arg, "dvd")) {
4724 opt_video_codec(o, "c:v", "mpeg2video");
4725 opt_audio_codec(o, "c:a", "ac3");
4726 parse_option(o, "f", "dvd", options);
4728 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4729 parse_option(o, "r", frame_rates[norm], options);
4730 parse_option(o, "pix_fmt", "yuv420p", options);
4731 opt_default("g", norm == PAL ? "15" : "18");
4733 opt_default("b:v", "6000000");
4734 opt_default("maxrate", "9000000");
4735 opt_default("minrate", "0"); // 1500000;
4736 opt_default("bufsize", "1835008"); // 224*1024*8;
4738 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4739 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4741 opt_default("b:a", "448000");
4742 parse_option(o, "ar", "48000", options);
4744 } else if (!strncmp(arg, "dv", 2)) {
4746 parse_option(o, "f", "dv", options);
4748 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4749 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4750 norm == PAL ? "yuv420p" : "yuv411p", options);
4751 parse_option(o, "r", frame_rates[norm], options);
4753 parse_option(o, "ar", "48000", options);
4754 parse_option(o, "ac", "2", options);
4757 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4758 return AVERROR(EINVAL);
4763 static int opt_vstats_file(const char *opt, const char *arg)
4765 av_free (vstats_filename);
4766 vstats_filename = av_strdup (arg);
4770 static int opt_vstats(const char *opt, const char *arg)
4773 time_t today2 = time(NULL);
4774 struct tm *today = localtime(&today2);
4776 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4778 return opt_vstats_file(opt, filename);
4781 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4783 return parse_option(o, "frames:v", arg, options);
4786 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4788 return parse_option(o, "frames:a", arg, options);
4791 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4793 return parse_option(o, "frames:d", arg, options);
4796 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4799 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4800 const char *codec_name = *opt == 'v' ? video_codec_name :
4801 *opt == 'a' ? audio_codec_name :
4802 subtitle_codec_name;
4804 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4805 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4806 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4808 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4813 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4814 if(line[0] == '#' && !e)
4816 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4818 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4821 if(!strcmp(tmp, "acodec")){
4822 opt_audio_codec(o, tmp, tmp2);
4823 }else if(!strcmp(tmp, "vcodec")){
4824 opt_video_codec(o, tmp, tmp2);
4825 }else if(!strcmp(tmp, "scodec")){
4826 opt_subtitle_codec(o, tmp, tmp2);
4827 }else if(!strcmp(tmp, "dcodec")){
4828 opt_data_codec(o, tmp, tmp2);
4829 }else if(opt_default(tmp, tmp2) < 0){
4830 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4840 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4844 static int opt_passlogfile(const char *opt, const char *arg)
4846 pass_logfilename_prefix = arg;
4847 #if CONFIG_LIBX264_ENCODER
4848 return opt_default("passlogfile", arg);
4854 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4856 char *s= av_malloc(strlen(opt)+2);
4857 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4858 return parse_option(o, s, arg, options);
4861 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4863 if(!strcmp(opt, "b")){
4864 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4865 return parse_option(o, av_strdup("b:v"), arg, options);
4867 return opt_default(opt, arg);
4870 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4872 return parse_option(o, "filter:v", arg, options);
4875 #define OFFSET(x) offsetof(OptionsContext, x)
4876 static const OptionDef options[] = {
4878 #include "cmdutils_common_opts.h"
4879 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4880 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4881 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4882 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4883 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4884 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4885 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4886 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4887 { "map_channel", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_channel}, "map an audio channel from one stream to another", "file.stream.channel[:syncfile.syncstream]" },
4888 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4889 "outfile[,metadata]:infile[,metadata]" },
4890 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4891 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4892 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4893 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4894 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4895 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4896 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4897 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4898 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4899 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4900 "add timings for benchmarking" },
4901 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4902 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4903 "dump each input packet" },
4904 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4905 "when dumping packets, also dump the payload" },
4906 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4907 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4908 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4909 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4910 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4911 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4912 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4913 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4914 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
4915 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4916 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4917 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4918 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4919 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4920 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4921 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4922 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4924 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4926 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4927 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4928 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4931 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4932 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4933 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4934 { "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" },
4935 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4936 { "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" },
4937 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4938 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4939 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4940 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4941 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4942 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4943 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4944 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4945 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4946 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4947 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4948 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4949 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4950 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4951 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4952 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4953 "use same quantizer as source (implies VBR)" },
4954 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4955 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4956 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4957 "deinterlace pictures" },
4958 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4959 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4960 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4962 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4964 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4965 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4966 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4967 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4968 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4969 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4970 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4971 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4972 { "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" },
4973 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4976 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4977 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4978 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4979 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4980 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4981 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4982 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
4983 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4984 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
4985 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
4987 /* subtitle options */
4988 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
4989 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4990 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
4993 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4994 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4995 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4998 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
4999 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5001 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5002 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5003 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5005 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5006 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5007 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5008 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5009 /* data codec support */
5010 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5011 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5013 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5017 int main(int argc, char **argv)
5019 OptionsContext o = { 0 };
5022 reset_options(&o, 0);
5024 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5025 parse_loglevel(argc, argv, options);
5027 if(argc>1 && !strcmp(argv[1], "-d")){
5029 av_log_set_callback(log_callback_null);
5034 avcodec_register_all();
5036 avdevice_register_all();
5039 avfilter_register_all();
5042 avformat_network_init();
5044 show_banner(argc, argv, options);
5049 parse_options(&o, argc, argv, options, opt_output_file);
5051 if (nb_output_files <= 0 && nb_input_files == 0) {
5053 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5057 /* file converter / grab */
5058 if (nb_output_files <= 0) {
5059 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5063 if (nb_input_files == 0) {
5064 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5069 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
5071 ti = getutime() - ti;
5073 int maxrss = getmaxrss() / 1024;
5074 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);