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"
97 #define VSYNC_PASSTHROUGH 0
101 const char program_name[] = "ffmpeg";
102 const int program_birth_year = 2000;
104 /* select an input stream for an output stream */
105 typedef struct StreamMap {
106 int disabled; /** 1 is this mapping is disabled by a negative map */
110 int sync_stream_index;
114 int file_idx, stream_idx, channel_idx; // input
115 int ofile_idx, ostream_idx; // output
119 * select an input file for an output file
121 typedef struct MetadataMap {
122 int file; ///< file index
123 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
124 int index; ///< stream/chapter/program number
127 static const OptionDef options[];
129 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
131 static int frame_bits_per_raw_sample = 0;
132 static int video_discard = 0;
133 static int same_quant = 0;
134 static int do_deinterlace = 0;
135 static int intra_dc_precision = 8;
136 static int loop_input = 0;
137 static int loop_output = AVFMT_NOOUTPUTLOOP;
138 static int qp_hist = 0;
139 static int intra_only = 0;
140 static const char *video_codec_name = NULL;
141 static const char *audio_codec_name = NULL;
142 static const char *subtitle_codec_name = NULL;
144 static int file_overwrite = 0;
145 static int no_file_overwrite = 0;
146 static int do_benchmark = 0;
147 static int do_hex_dump = 0;
148 static int do_pkt_dump = 0;
149 static int do_psnr = 0;
150 static int do_pass = 0;
151 static const char *pass_logfilename_prefix;
152 static int video_sync_method = VSYNC_AUTO;
153 static int audio_sync_method = 0;
154 static float audio_drift_threshold = 0.1;
155 static int copy_ts = 0;
156 static int copy_tb = -1;
157 static int opt_shortest = 0;
158 static char *vstats_filename;
159 static FILE *vstats_file;
161 static int audio_volume = 256;
163 static int exit_on_error = 0;
164 static int using_stdin = 0;
165 static int run_as_daemon = 0;
166 static volatile int received_nb_signals = 0;
167 static int64_t video_size = 0;
168 static int64_t audio_size = 0;
169 static int64_t extra_size = 0;
170 static int nb_frames_dup = 0;
171 static int nb_frames_drop = 0;
172 static int input_sync;
174 static float dts_delta_threshold = 10;
176 static int print_stats = 1;
178 static uint8_t *audio_buf;
179 static uint8_t *audio_out;
180 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
182 static uint8_t *input_tmp= NULL;
184 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
186 typedef struct FrameBuffer {
192 enum PixelFormat pix_fmt;
195 struct InputStream *ist;
196 struct FrameBuffer *next;
199 typedef struct InputStream {
202 int discard; /* true if stream data should be discarded */
203 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
205 AVFrame *decoded_frame;
206 AVFrame *filtered_frame;
208 int64_t start; /* time when read started */
209 int64_t next_pts; /* synthetic pts for cases where pkt.pts
211 int64_t pts; /* current pts */
213 int is_start; /* is 1 at the start and after a discontinuity */
214 int showed_multi_packet_warning;
217 /* a pool of free buffers for decoded data */
218 FrameBuffer *buffer_pool;
222 typedef struct InputFile {
223 AVFormatContext *ctx;
224 int eof_reached; /* true if eof reached */
225 int ist_index; /* index of first stream in input_streams */
226 int buffer_size; /* current total buffer size */
228 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
229 from ctx.nb_streams if new streams appear during av_read_frame() */
233 typedef struct OutputStream {
234 int file_index; /* file index */
235 int index; /* stream index in the output file */
236 int source_index; /* InputStream index */
237 AVStream *st; /* stream in the output file */
238 int encoding_needed; /* true if encoding needed for this stream */
240 /* input pts and corresponding output pts
242 // double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
243 struct InputStream *sync_ist; /* input stream to sync against */
244 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
245 AVBitStreamFilterContext *bitstream_filters;
251 AVFrame resample_frame; /* temporary frame for image resampling */
252 struct SwsContext *img_resample_ctx; /* for image resampling */
255 int resample_pix_fmt;
256 AVRational frame_rate;
260 float frame_aspect_ratio;
262 /* forced key frames */
263 int64_t *forced_kf_pts;
269 int audio_channels_map[SWR_CH_MAX]; ///< list of the channels id to pick from the source stream
270 int audio_channels_mapped; ///< number of channels in audio_channels_map
271 int resample_sample_fmt;
272 int resample_channels;
273 int resample_sample_rate;
274 float rematrix_volume;
275 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
278 struct SwrContext *swr;
281 AVFilterContext *output_video_filter;
282 AVFilterContext *input_video_filter;
283 AVFilterBufferRef *picref;
285 AVFilterGraph *graph;
290 int is_past_recording_time;
292 const char *attachment_filename;
293 int copy_initial_nonkeyframes;
299 /* init terminal so that we can grab keys */
300 static struct termios oldtty;
303 typedef struct OutputFile {
304 AVFormatContext *ctx;
306 int ost_index; /* index of the first stream in output_streams */
307 int64_t recording_time; /* desired length of the resulting file in microseconds */
308 int64_t start_time; /* start time in microseconds */
309 uint64_t limit_filesize;
312 static InputStream *input_streams = NULL;
313 static int nb_input_streams = 0;
314 static InputFile *input_files = NULL;
315 static int nb_input_files = 0;
317 static OutputStream *output_streams = NULL;
318 static int nb_output_streams = 0;
319 static OutputFile *output_files = NULL;
320 static int nb_output_files = 0;
322 typedef struct OptionsContext {
323 /* input/output options */
327 SpecifierOpt *codec_names;
329 SpecifierOpt *audio_channels;
330 int nb_audio_channels;
331 SpecifierOpt *audio_sample_rate;
332 int nb_audio_sample_rate;
333 SpecifierOpt *rematrix_volume;
334 int nb_rematrix_volume;
335 SpecifierOpt *frame_rates;
337 SpecifierOpt *frame_sizes;
339 SpecifierOpt *frame_pix_fmts;
340 int nb_frame_pix_fmts;
343 int64_t input_ts_offset;
346 SpecifierOpt *ts_scale;
348 SpecifierOpt *dump_attachment;
349 int nb_dump_attachment;
352 StreamMap *stream_maps;
354 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
355 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
356 /* first item specifies output metadata, second is input */
357 MetadataMap (*meta_data_maps)[2];
358 int nb_meta_data_maps;
359 int metadata_global_manual;
360 int metadata_streams_manual;
361 int metadata_chapters_manual;
362 const char **attachments;
365 int chapters_input_file;
367 int64_t recording_time;
368 uint64_t limit_filesize;
374 int subtitle_disable;
377 /* indexed by output file stream index */
381 SpecifierOpt *metadata;
383 SpecifierOpt *max_frames;
385 SpecifierOpt *bitstream_filters;
386 int nb_bitstream_filters;
387 SpecifierOpt *codec_tags;
389 SpecifierOpt *sample_fmts;
391 SpecifierOpt *qscale;
393 SpecifierOpt *forced_key_frames;
394 int nb_forced_key_frames;
395 SpecifierOpt *force_fps;
397 SpecifierOpt *frame_aspect_ratios;
398 int nb_frame_aspect_ratios;
399 SpecifierOpt *rc_overrides;
401 SpecifierOpt *intra_matrices;
402 int nb_intra_matrices;
403 SpecifierOpt *inter_matrices;
404 int nb_inter_matrices;
405 SpecifierOpt *top_field_first;
406 int nb_top_field_first;
407 SpecifierOpt *metadata_map;
409 SpecifierOpt *presets;
411 SpecifierOpt *copy_initial_nonkeyframes;
412 int nb_copy_initial_nonkeyframes;
414 SpecifierOpt *filters;
419 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
422 for (i = 0; i < o->nb_ ## name; i++) {\
423 char *spec = o->name[i].specifier;\
424 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
425 outvar = o->name[i].u.type;\
431 static void reset_options(OptionsContext *o, int is_input)
433 const OptionDef *po = options;
434 OptionsContext bak= *o;
436 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
438 void *dst = (uint8_t*)o + po->u.off;
440 if (po->flags & OPT_SPEC) {
441 SpecifierOpt **so = dst;
442 int i, *count = (int*)(so + 1);
443 for (i = 0; i < *count; i++) {
444 av_freep(&(*so)[i].specifier);
445 if (po->flags & OPT_STRING)
446 av_freep(&(*so)[i].u.str);
450 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
455 av_freep(&o->stream_maps);
456 av_freep(&o->audio_channel_maps);
457 av_freep(&o->meta_data_maps);
458 av_freep(&o->streamid_map);
460 memset(o, 0, sizeof(*o));
462 if(is_input) o->recording_time = bak.recording_time;
463 else o->recording_time = INT64_MAX;
464 o->mux_max_delay = 0.7;
465 o->limit_filesize = UINT64_MAX;
466 o->chapters_input_file = INT_MAX;
472 static int alloc_buffer(InputStream *ist, FrameBuffer **pbuf)
474 AVCodecContext *s = ist->st->codec;
475 FrameBuffer *buf = av_mallocz(sizeof(*buf));
477 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
478 int h_chroma_shift, v_chroma_shift;
479 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
480 int w = s->width, h = s->height;
483 return AVERROR(ENOMEM);
485 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
490 avcodec_align_dimensions(s, &w, &h);
491 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
492 s->pix_fmt, 32)) < 0) {
496 /* XXX this shouldn't be needed, but some tests break without this line
497 * those decoders are buggy and need to be fixed.
498 * the following tests fail:
499 * bethsoft-vid, cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
501 memset(buf->base[0], 128, ret);
503 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
504 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
505 const int h_shift = i==0 ? 0 : h_chroma_shift;
506 const int v_shift = i==0 ? 0 : v_chroma_shift;
507 if (s->flags & CODEC_FLAG_EMU_EDGE)
508 buf->data[i] = buf->base[i];
510 buf->data[i] = buf->base[i] +
511 FFALIGN((buf->linesize[i]*edge >> v_shift) +
512 (pixel_size*edge >> h_shift), 32);
516 buf->pix_fmt = s->pix_fmt;
523 static void free_buffer_pool(InputStream *ist)
525 FrameBuffer *buf = ist->buffer_pool;
527 ist->buffer_pool = buf->next;
528 av_freep(&buf->base[0]);
530 buf = ist->buffer_pool;
534 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
536 av_assert0(buf->refcount);
538 if (!buf->refcount) {
539 buf->next = ist->buffer_pool;
540 ist->buffer_pool = buf;
544 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
546 InputStream *ist = s->opaque;
550 if (!ist->buffer_pool && (ret = alloc_buffer(ist, &ist->buffer_pool)) < 0)
553 buf = ist->buffer_pool;
554 ist->buffer_pool = buf->next;
556 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
557 av_freep(&buf->base[0]);
560 if ((ret = alloc_buffer(ist, &buf)) < 0)
566 frame->type = FF_BUFFER_TYPE_USER;
567 frame->extended_data = frame->data;
568 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
570 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
571 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
572 frame->data[i] = buf->data[i];
573 frame->linesize[i] = buf->linesize[i];
579 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
581 InputStream *ist = s->opaque;
582 FrameBuffer *buf = frame->opaque;
585 if(frame->type!=FF_BUFFER_TYPE_USER)
586 return avcodec_default_release_buffer(s, frame);
588 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
589 frame->data[i] = NULL;
591 unref_buffer(ist, buf);
594 static void filter_release_buffer(AVFilterBuffer *fb)
596 FrameBuffer *buf = fb->priv;
598 unref_buffer(buf->ist, buf);
603 static int configure_video_filters(InputStream *ist, OutputStream *ost)
605 AVFilterContext *last_filter, *filter;
606 /** filter graph containing all filters including input & output */
607 AVCodecContext *codec = ost->st->codec;
608 AVCodecContext *icodec = ist->st->codec;
609 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
610 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
611 AVRational sample_aspect_ratio;
615 ost->graph = avfilter_graph_alloc();
617 if (ist->st->sample_aspect_ratio.num) {
618 sample_aspect_ratio = ist->st->sample_aspect_ratio;
620 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
622 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
623 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
624 sample_aspect_ratio.num, sample_aspect_ratio.den);
626 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
627 "src", args, NULL, ost->graph);
630 #if FF_API_OLD_VSINK_API
631 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
632 "out", NULL, pix_fmts, ost->graph);
634 buffersink_params->pixel_fmts = pix_fmts;
635 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
636 "out", NULL, buffersink_params, ost->graph);
638 av_freep(&buffersink_params);
641 last_filter = ost->input_video_filter;
643 if (codec->width != icodec->width || codec->height != icodec->height) {
644 snprintf(args, 255, "%d:%d:flags=0x%X",
647 (unsigned)ost->sws_flags);
648 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
649 NULL, args, NULL, ost->graph)) < 0)
651 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
653 last_filter = filter;
656 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
657 ost->graph->scale_sws_opts = av_strdup(args);
660 AVFilterInOut *outputs = avfilter_inout_alloc();
661 AVFilterInOut *inputs = avfilter_inout_alloc();
663 outputs->name = av_strdup("in");
664 outputs->filter_ctx = last_filter;
665 outputs->pad_idx = 0;
666 outputs->next = NULL;
668 inputs->name = av_strdup("out");
669 inputs->filter_ctx = ost->output_video_filter;
673 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
675 av_freep(&ost->avfilter);
677 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
681 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
684 codec->width = ost->output_video_filter->inputs[0]->w;
685 codec->height = ost->output_video_filter->inputs[0]->h;
686 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
687 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
688 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
689 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
693 #endif /* CONFIG_AVFILTER */
695 static void term_exit(void)
697 av_log(NULL, AV_LOG_QUIET, "%s", "");
700 tcsetattr (0, TCSANOW, &oldtty);
704 static volatile int received_sigterm = 0;
706 static void sigterm_handler(int sig)
708 received_sigterm = sig;
709 received_nb_signals++;
711 if(received_nb_signals > 3)
715 static void term_init(void)
725 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
726 |INLCR|IGNCR|ICRNL|IXON);
727 tty.c_oflag |= OPOST;
728 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
729 tty.c_cflag &= ~(CSIZE|PARENB);
734 tcsetattr (0, TCSANOW, &tty);
735 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
738 avformat_network_deinit();
740 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
741 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
743 signal(SIGXCPU, sigterm_handler);
747 /* read a key without blocking */
748 static int read_key(void)
760 n = select(1, &rfds, NULL, NULL, &tv);
769 # if HAVE_PEEKNAMEDPIPE
771 static HANDLE input_handle;
774 input_handle = GetStdHandle(STD_INPUT_HANDLE);
775 is_pipe = !GetConsoleMode(input_handle, &dw);
778 if (stdin->_cnt > 0) {
783 /* When running under a GUI, you will end here. */
784 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
801 static int decode_interrupt_cb(void *ctx)
803 return received_nb_signals > 1;
806 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
808 void av_noreturn exit_program(int ret)
813 for (i = 0; i < nb_output_files; i++) {
814 AVFormatContext *s = output_files[i].ctx;
815 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
817 avformat_free_context(s);
818 av_dict_free(&output_files[i].opts);
820 for (i = 0; i < nb_output_streams; i++) {
821 AVBitStreamFilterContext *bsfc = output_streams[i].bitstream_filters;
823 AVBitStreamFilterContext *next = bsfc->next;
824 av_bitstream_filter_close(bsfc);
827 output_streams[i].bitstream_filters = NULL;
829 for (i = 0; i < nb_input_files; i++) {
830 avformat_close_input(&input_files[i].ctx);
832 for (i = 0; i < nb_input_streams; i++) {
833 av_freep(&input_streams[i].decoded_frame);
834 av_freep(&input_streams[i].filtered_frame);
835 av_dict_free(&input_streams[i].opts);
836 free_buffer_pool(&input_streams[i]);
841 av_free(vstats_filename);
843 av_freep(&input_streams);
844 av_freep(&input_files);
845 av_freep(&output_streams);
846 av_freep(&output_files);
851 allocated_audio_buf_size = allocated_audio_out_size = 0;
856 avformat_network_deinit();
858 av_freep(&input_tmp);
860 if (received_sigterm) {
861 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
862 (int) received_sigterm);
866 exit(ret); /* not all OS-es handle main() return value */
869 static void assert_avoptions(AVDictionary *m)
871 AVDictionaryEntry *t;
872 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
873 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
878 static void assert_codec_experimental(AVCodecContext *c, int encoder)
880 const char *codec_string = encoder ? "encoder" : "decoder";
882 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
883 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
884 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
885 "results.\nAdd '-strict experimental' if you want to use it.\n",
886 codec_string, c->codec->name);
887 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
888 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
889 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
890 codec_string, codec->name);
895 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
897 if (codec && codec->sample_fmts) {
898 const enum AVSampleFormat *p = codec->sample_fmts;
899 for (; *p != -1; p++) {
900 if (*p == st->codec->sample_fmt)
904 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
905 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
906 if(av_get_sample_fmt_name(st->codec->sample_fmt))
907 av_log(NULL, AV_LOG_WARNING,
908 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
909 av_get_sample_fmt_name(st->codec->sample_fmt),
911 av_get_sample_fmt_name(codec->sample_fmts[0]));
912 st->codec->sample_fmt = codec->sample_fmts[0];
917 static void choose_sample_rate(AVStream *st, AVCodec *codec)
919 if (codec && codec->supported_samplerates) {
920 const int *p = codec->supported_samplerates;
922 int best_dist = INT_MAX;
924 int dist = abs(st->codec->sample_rate - *p);
925 if (dist < best_dist) {
931 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
933 st->codec->sample_rate = best;
937 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
939 if (codec && codec->pix_fmts) {
940 const enum PixelFormat *p = codec->pix_fmts;
941 int has_alpha= av_pix_fmt_descriptors[st->codec->pix_fmt].nb_components % 2 == 0;
942 enum PixelFormat best= PIX_FMT_NONE;
943 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
944 if (st->codec->codec_id == CODEC_ID_MJPEG) {
945 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
946 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
947 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
948 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
951 for (; *p != PIX_FMT_NONE; p++) {
952 best= avcodec_find_best_pix_fmt2(best, *p, st->codec->pix_fmt, has_alpha, NULL);
953 if (*p == st->codec->pix_fmt)
956 if (*p == PIX_FMT_NONE) {
957 if (st->codec->pix_fmt != PIX_FMT_NONE)
958 av_log(NULL, AV_LOG_WARNING,
959 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
960 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
962 av_pix_fmt_descriptors[best].name);
963 st->codec->pix_fmt = best;
968 static double get_sync_ipts(const OutputStream *ost)
970 const InputStream *ist = ost->sync_ist;
971 OutputFile *of = &output_files[ost->file_index];
972 return (double)(ist->pts - of->start_time) / AV_TIME_BASE;
975 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
977 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
978 AVCodecContext *avctx = ost->st->codec;
982 AVPacket new_pkt = *pkt;
983 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
984 &new_pkt.data, &new_pkt.size,
985 pkt->data, pkt->size,
986 pkt->flags & AV_PKT_FLAG_KEY);
989 new_pkt.destruct = av_destruct_packet;
991 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
992 bsfc->filter->name, pkt->stream_index,
993 avctx->codec ? avctx->codec->name : "copy");
1003 ret = av_interleaved_write_frame(s, pkt);
1005 print_error("av_interleaved_write_frame()", ret);
1008 ost->frame_number++;
1011 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1013 int fill_char = 0x00;
1014 if (sample_fmt == AV_SAMPLE_FMT_U8)
1016 memset(buf, fill_char, size);
1019 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1020 InputStream *ist, AVFrame *decoded_frame)
1023 int64_t audio_out_size, audio_buf_size, size_out;
1025 int frame_bytes, ret, resample_changed;
1026 AVCodecContext *enc = ost->st->codec;
1027 AVCodecContext *dec = ist->st->codec;
1028 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1029 int isize = av_get_bytes_per_sample(dec->sample_fmt);
1030 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
1031 uint8_t *buf = decoded_frame->data[0];
1032 int size = decoded_frame->nb_samples * dec->channels * isize;
1033 int64_t allocated_for_size = size;
1036 audio_buf_size = (allocated_for_size + isize * dec->channels - 1) / (isize * dec->channels);
1037 audio_buf_size = (audio_buf_size * enc->sample_rate + dec->sample_rate) / dec->sample_rate;
1038 audio_buf_size = audio_buf_size * 2 + 10000; // safety factors for the deprecated resampling API
1039 audio_buf_size = FFMAX(audio_buf_size, enc->frame_size);
1040 audio_buf_size *= osize * enc->channels;
1042 audio_out_size = FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
1043 if (coded_bps > 8 * osize)
1044 audio_out_size = audio_out_size * coded_bps / (8*osize);
1045 audio_out_size += FF_MIN_BUFFER_SIZE;
1047 if (audio_out_size > INT_MAX || audio_buf_size > INT_MAX) {
1048 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
1052 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
1053 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
1054 if (!audio_buf || !audio_out) {
1055 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1059 if (enc->channels != dec->channels
1060 || enc->sample_fmt != dec->sample_fmt
1061 || enc->sample_rate!= dec->sample_rate
1063 ost->audio_resample = 1;
1065 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1066 ost->resample_channels != dec->channels ||
1067 ost->resample_sample_rate != dec->sample_rate;
1069 if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
1070 if (resample_changed) {
1071 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",
1072 ist->file_index, ist->st->index,
1073 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
1074 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
1075 ost->resample_sample_fmt = dec->sample_fmt;
1076 ost->resample_channels = dec->channels;
1077 ost->resample_sample_rate = dec->sample_rate;
1078 swr_free(&ost->swr);
1080 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1081 if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
1082 ost->resample_sample_fmt == enc->sample_fmt &&
1083 ost->resample_channels == enc->channels &&
1084 ost->resample_sample_rate == enc->sample_rate) {
1086 ost->audio_resample = 0;
1088 ost->swr = swr_alloc_set_opts(ost->swr,
1089 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
1090 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
1092 if (ost->audio_channels_mapped)
1093 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
1094 av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
1095 if (ost->audio_channels_mapped) {
1096 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
1097 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
1099 if (av_opt_set_int(ost->swr, "ich", dec->channels, 0) < 0) {
1100 av_log(NULL, AV_LOG_FATAL, "Unsupported number of input channels\n");
1103 if (av_opt_set_int(ost->swr, "och", enc->channels, 0) < 0) {
1104 av_log(NULL, AV_LOG_FATAL, "Unsupported number of output channels\n");
1107 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
1108 if(ost->swr && swr_init(ost->swr) < 0){
1109 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
1110 swr_free(&ost->swr);
1114 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1115 dec->channels, dec->sample_rate,
1116 enc->channels, enc->sample_rate);
1122 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1124 if (audio_sync_method) {
1125 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts -
1126 av_fifo_size(ost->fifo) / (enc->channels * osize);
1127 int idelta = delta * dec->sample_rate / enc->sample_rate;
1128 int byte_delta = idelta * isize * dec->channels;
1130 // FIXME resample delay
1131 if (fabs(delta) > 50) {
1132 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1133 if (byte_delta < 0) {
1134 byte_delta = FFMAX(byte_delta, -size);
1137 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1138 -byte_delta / (isize * dec->channels));
1143 input_tmp = av_realloc(input_tmp, byte_delta + size);
1145 if (byte_delta > allocated_for_size - size) {
1146 allocated_for_size = byte_delta + (int64_t)size;
1151 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
1152 memcpy(input_tmp + byte_delta, buf, size);
1155 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1157 } else if (audio_sync_method > 1) {
1158 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1159 av_assert0(ost->audio_resample);
1160 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1161 delta, comp, enc->sample_rate);
1162 // 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));
1163 swr_set_compensation(ost->swr, comp, enc->sample_rate);
1167 ost->sync_opts = lrintf(get_sync_ipts(ost) * enc->sample_rate) -
1168 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1170 if (ost->audio_resample) {
1172 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
1173 (const uint8_t*[]){buf }, size / (dec->channels * isize));
1174 size_out = size_out * enc->channels * osize;
1180 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1182 /* now encode as many frames as possible */
1183 if (enc->frame_size > 1) {
1184 /* output resampled raw samples */
1185 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1186 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1189 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1191 frame_bytes = enc->frame_size * osize * enc->channels;
1193 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1195 av_init_packet(&pkt);
1197 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1199 // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1201 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1202 (short *)audio_buf);
1204 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1208 pkt.stream_index = ost->index;
1209 pkt.data = audio_out;
1211 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1212 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1213 pkt.flags |= AV_PKT_FLAG_KEY;
1214 write_frame(s, &pkt, ost);
1216 ost->sync_opts += enc->frame_size;
1220 av_init_packet(&pkt);
1222 ost->sync_opts += size_out / (osize * enc->channels);
1224 /* output a pcm frame */
1225 /* determine the size of the coded buffer */
1228 size_out = size_out * coded_bps / 8;
1230 if (size_out > audio_out_size) {
1231 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1235 // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1236 ret = avcodec_encode_audio(enc, audio_out, size_out,
1239 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1243 pkt.stream_index = ost->index;
1244 pkt.data = audio_out;
1246 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1247 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1248 pkt.flags |= AV_PKT_FLAG_KEY;
1249 write_frame(s, &pkt, ost);
1253 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1255 AVCodecContext *dec;
1256 AVPicture *picture2;
1257 AVPicture picture_tmp;
1260 dec = ist->st->codec;
1262 /* deinterlace : must be done before any resize */
1263 if (do_deinterlace) {
1266 /* create temporary picture */
1267 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1268 buf = av_malloc(size);
1272 picture2 = &picture_tmp;
1273 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1275 if (avpicture_deinterlace(picture2, picture,
1276 dec->pix_fmt, dec->width, dec->height) < 0) {
1277 /* if error, do not deinterlace */
1278 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1287 if (picture != picture2)
1288 *picture = *picture2;
1292 static void do_subtitle_out(AVFormatContext *s,
1298 static uint8_t *subtitle_out = NULL;
1299 int subtitle_out_max_size = 1024 * 1024;
1300 int subtitle_out_size, nb, i;
1301 AVCodecContext *enc;
1304 if (pts == AV_NOPTS_VALUE) {
1305 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1311 enc = ost->st->codec;
1313 if (!subtitle_out) {
1314 subtitle_out = av_malloc(subtitle_out_max_size);
1317 /* Note: DVB subtitle need one packet to draw them and one other
1318 packet to clear them */
1319 /* XXX: signal it in the codec context ? */
1320 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1325 for (i = 0; i < nb; i++) {
1326 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1327 // start_display_time is required to be 0
1328 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1329 sub->end_display_time -= sub->start_display_time;
1330 sub->start_display_time = 0;
1331 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1332 subtitle_out_max_size, sub);
1333 if (subtitle_out_size < 0) {
1334 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1338 av_init_packet(&pkt);
1339 pkt.stream_index = ost->index;
1340 pkt.data = subtitle_out;
1341 pkt.size = subtitle_out_size;
1342 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1343 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1344 /* XXX: the pts correction is handled here. Maybe handling
1345 it in the codec would be better */
1347 pkt.pts += 90 * sub->start_display_time;
1349 pkt.pts += 90 * sub->end_display_time;
1351 write_frame(s, &pkt, ost);
1355 static int bit_buffer_size = 1024 * 256;
1356 static uint8_t *bit_buffer = NULL;
1358 static void do_video_resample(OutputStream *ost,
1360 AVFrame *in_picture,
1361 AVFrame **out_picture)
1364 *out_picture = in_picture;
1366 AVCodecContext *dec = ist->st->codec;
1367 AVCodecContext *enc = ost->st->codec;
1368 int resample_changed = ost->resample_width != in_picture->width ||
1369 ost->resample_height != in_picture->height ||
1370 ost->resample_pix_fmt != in_picture->format;
1372 *out_picture = in_picture;
1373 if (resample_changed) {
1374 av_log(NULL, AV_LOG_INFO,
1375 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s / frm size:%dx%d fmt:%s\n",
1376 ist->file_index, ist->st->index,
1377 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1378 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt),
1379 in_picture->width, in_picture->height, av_get_pix_fmt_name(in_picture->format));
1380 ost->resample_width = in_picture->width;
1381 ost->resample_height = in_picture->height;
1382 ost->resample_pix_fmt = in_picture->format;
1385 ost->video_resample = in_picture->width != enc->width ||
1386 in_picture->height != enc->height ||
1387 in_picture->format != enc->pix_fmt;
1389 if (ost->video_resample) {
1390 *out_picture = &ost->resample_frame;
1391 if (!ost->img_resample_ctx || resample_changed) {
1392 /* initialize the destination picture */
1393 if (!ost->resample_frame.data[0]) {
1394 avcodec_get_frame_defaults(&ost->resample_frame);
1395 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1396 enc->width, enc->height)) {
1397 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1401 /* initialize a new scaler context */
1402 sws_freeContext(ost->img_resample_ctx);
1403 ost->img_resample_ctx = sws_getContext(in_picture->width, in_picture->height, in_picture->format,
1404 enc->width, enc->height, enc->pix_fmt,
1405 ost->sws_flags, NULL, NULL, NULL);
1406 if (ost->img_resample_ctx == NULL) {
1407 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1411 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1412 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1418 static void do_video_out(AVFormatContext *s,
1421 AVFrame *in_picture,
1422 int *frame_size, float quality)
1424 int nb_frames, i, ret, format_video_sync;
1425 AVFrame *final_picture;
1426 AVCodecContext *enc;
1428 double duration = 0;
1430 enc = ost->st->codec;
1432 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1433 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1434 if(ist->st->avg_frame_rate.num)
1435 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1437 duration /= av_q2d(enc->time_base);
1440 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1442 /* by default, we output a single frame */
1447 format_video_sync = video_sync_method;
1448 if (format_video_sync == VSYNC_AUTO)
1449 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1451 if (format_video_sync != VSYNC_PASSTHROUGH) {
1452 double vdelta = sync_ipts - ost->sync_opts + duration;
1453 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1456 else if (format_video_sync == VSYNC_VFR) {
1457 if (vdelta <= -0.6) {
1459 } else if (vdelta > 0.6)
1460 ost->sync_opts = lrintf(sync_ipts);
1461 } else if (vdelta > 1.1)
1462 nb_frames = lrintf(vdelta);
1463 //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);
1464 if (nb_frames == 0) {
1466 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1467 } else if (nb_frames > 1) {
1468 nb_frames_dup += nb_frames - 1;
1469 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1472 ost->sync_opts = lrintf(sync_ipts);
1474 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1478 do_video_resample(ost, ist, in_picture, &final_picture);
1480 /* duplicates frame if needed */
1481 for (i = 0; i < nb_frames; i++) {
1483 av_init_packet(&pkt);
1484 pkt.stream_index = ost->index;
1486 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1487 enc->codec->id == CODEC_ID_RAWVIDEO) {
1488 /* raw pictures are written as AVPicture structure to
1489 avoid any copies. We support temporarily the older
1491 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1492 enc->coded_frame->top_field_first = in_picture->top_field_first;
1493 pkt.data = (uint8_t *)final_picture;
1494 pkt.size = sizeof(AVPicture);
1495 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1496 pkt.flags |= AV_PKT_FLAG_KEY;
1498 write_frame(s, &pkt, ost);
1500 AVFrame big_picture;
1502 big_picture = *final_picture;
1503 /* better than nothing: use input picture interlaced
1505 big_picture.interlaced_frame = in_picture->interlaced_frame;
1506 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1507 if (ost->top_field_first == -1)
1508 big_picture.top_field_first = in_picture->top_field_first;
1510 big_picture.top_field_first = !!ost->top_field_first;
1513 /* handles same_quant here. This is not correct because it may
1514 not be a global option */
1515 big_picture.quality = quality;
1516 if (!enc->me_threshold)
1517 big_picture.pict_type = 0;
1518 // big_picture.pts = AV_NOPTS_VALUE;
1519 big_picture.pts = ost->sync_opts;
1520 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1521 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1522 if (ost->forced_kf_index < ost->forced_kf_count &&
1523 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1524 big_picture.pict_type = AV_PICTURE_TYPE_I;
1525 ost->forced_kf_index++;
1527 ret = avcodec_encode_video(enc,
1528 bit_buffer, bit_buffer_size,
1531 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1536 pkt.data = bit_buffer;
1538 if (enc->coded_frame->pts != AV_NOPTS_VALUE)
1539 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1540 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1541 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1542 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1544 if (enc->coded_frame->key_frame)
1545 pkt.flags |= AV_PKT_FLAG_KEY;
1546 write_frame(s, &pkt, ost);
1549 // fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1550 // enc->frame_number-1, ret, enc->pict_type);
1551 /* if two pass, output log */
1552 if (ost->logfile && enc->stats_out) {
1553 fprintf(ost->logfile, "%s", enc->stats_out);
1561 static double psnr(double d)
1563 return -10.0 * log(d) / log(10.0);
1566 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1569 AVCodecContext *enc;
1571 double ti1, bitrate, avg_bitrate;
1573 /* this is executed just the first time do_video_stats is called */
1575 vstats_file = fopen(vstats_filename, "w");
1582 enc = ost->st->codec;
1583 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1584 frame_number = ost->frame_number;
1585 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1586 if (enc->flags&CODEC_FLAG_PSNR)
1587 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1589 fprintf(vstats_file,"f_size= %6d ", frame_size);
1590 /* compute pts value */
1591 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1595 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1596 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1597 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1598 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1599 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1603 static void print_report(OutputFile *output_files,
1604 OutputStream *ost_table, int nb_ostreams,
1605 int is_last_report, int64_t timer_start, int64_t cur_time)
1609 AVFormatContext *oc;
1611 AVCodecContext *enc;
1612 int frame_number, vid, i;
1614 int64_t pts = INT64_MAX;
1615 static int64_t last_time = -1;
1616 static int qp_histogram[52];
1617 int hours, mins, secs, us;
1619 if (!print_stats && !is_last_report)
1622 if (!is_last_report) {
1623 if (last_time == -1) {
1624 last_time = cur_time;
1627 if ((cur_time - last_time) < 500000)
1629 last_time = cur_time;
1633 oc = output_files[0].ctx;
1635 total_size = avio_size(oc->pb);
1636 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
1637 total_size = avio_tell(oc->pb);
1644 for (i = 0; i < nb_ostreams; i++) {
1646 ost = &ost_table[i];
1647 enc = ost->st->codec;
1648 if (!ost->stream_copy && enc->coded_frame)
1649 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1650 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1651 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1653 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1654 float t = (cur_time-timer_start) / 1000000.0;
1656 frame_number = ost->frame_number;
1657 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1658 frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1660 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1664 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1666 for (j = 0; j < 32; j++)
1667 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1669 if (enc->flags&CODEC_FLAG_PSNR) {
1671 double error, error_sum = 0;
1672 double scale, scale_sum = 0;
1673 char type[3] = { 'Y','U','V' };
1674 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1675 for (j = 0; j < 3; j++) {
1676 if (is_last_report) {
1677 error = enc->error[j];
1678 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1680 error = enc->coded_frame->error[j];
1681 scale = enc->width * enc->height * 255.0 * 255.0;
1687 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1689 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1693 /* compute min output value */
1694 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1695 ost->st->time_base, AV_TIME_BASE_Q));
1698 secs = pts / AV_TIME_BASE;
1699 us = pts % AV_TIME_BASE;
1705 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1707 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1708 "size=%8.0fkB time=", total_size / 1024.0);
1709 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1710 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1711 (100 * us) / AV_TIME_BASE);
1712 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1713 "bitrate=%6.1fkbits/s", bitrate);
1715 if (nb_frames_dup || nb_frames_drop)
1716 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1717 nb_frames_dup, nb_frames_drop);
1719 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1723 if (is_last_report) {
1724 int64_t raw= audio_size + video_size + extra_size;
1725 av_log(NULL, AV_LOG_INFO, "\n");
1726 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1727 video_size / 1024.0,
1728 audio_size / 1024.0,
1729 extra_size / 1024.0,
1730 100.0 * (total_size - raw) / raw
1732 if(video_size + audio_size + extra_size == 0){
1733 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1738 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1742 for (i = 0; i < nb_ostreams; i++) {
1743 OutputStream *ost = &ost_table[i];
1744 AVCodecContext *enc = ost->st->codec;
1745 AVFormatContext *os = output_files[ost->file_index].ctx;
1747 if (!ost->encoding_needed)
1750 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1752 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1758 av_init_packet(&pkt);
1759 pkt.stream_index = ost->index;
1761 switch (ost->st->codec->codec_type) {
1762 case AVMEDIA_TYPE_AUDIO:
1763 fifo_bytes = av_fifo_size(ost->fifo);
1765 /* encode any samples remaining in fifo */
1766 if (fifo_bytes > 0) {
1767 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1768 int fs_tmp = enc->frame_size;
1770 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1771 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1772 enc->frame_size = fifo_bytes / (osize * enc->channels);
1774 int frame_bytes = enc->frame_size*osize*enc->channels;
1775 if (allocated_audio_buf_size < frame_bytes)
1777 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1780 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1781 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1782 ost->st->time_base.num, enc->sample_rate);
1783 enc->frame_size = fs_tmp;
1786 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1789 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1793 pkt.flags |= AV_PKT_FLAG_KEY;
1795 case AVMEDIA_TYPE_VIDEO:
1796 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1798 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1802 if (enc->coded_frame && enc->coded_frame->key_frame)
1803 pkt.flags |= AV_PKT_FLAG_KEY;
1804 if (ost->logfile && enc->stats_out) {
1805 fprintf(ost->logfile, "%s", enc->stats_out);
1814 pkt.data = bit_buffer;
1816 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1817 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1818 write_frame(os, &pkt, ost);
1824 * Check whether a packet from ist should be written into ost at this time
1826 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1828 OutputFile *of = &output_files[ost->file_index];
1829 int ist_index = ist - input_streams;
1831 if (ost->source_index != ist_index)
1834 if (of->start_time && ist->pts < of->start_time)
1837 if (of->recording_time != INT64_MAX &&
1838 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1839 (AVRational){ 1, 1000000 }) >= 0) {
1840 ost->is_past_recording_time = 1;
1847 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1849 OutputFile *of = &output_files[ost->file_index];
1850 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1854 av_init_packet(&opkt);
1856 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1857 !ost->copy_initial_nonkeyframes)
1860 /* force the input stream PTS */
1861 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1862 audio_size += pkt->size;
1863 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1864 video_size += pkt->size;
1868 opkt.stream_index = ost->index;
1869 if (pkt->pts != AV_NOPTS_VALUE)
1870 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1872 opkt.pts = AV_NOPTS_VALUE;
1874 if (pkt->dts == AV_NOPTS_VALUE)
1875 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1877 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1878 opkt.dts -= ost_tb_start_time;
1880 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1881 opkt.flags = pkt->flags;
1883 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1884 if ( ost->st->codec->codec_id != CODEC_ID_H264
1885 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1886 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1888 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1889 opkt.destruct = av_destruct_packet;
1891 opkt.data = pkt->data;
1892 opkt.size = pkt->size;
1894 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1895 /* store AVPicture in AVPacket, as expected by the output format */
1896 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1897 opkt.data = (uint8_t *)&pict;
1898 opkt.size = sizeof(AVPicture);
1899 opkt.flags |= AV_PKT_FLAG_KEY;
1902 write_frame(of->ctx, &opkt, ost);
1903 ost->st->codec->frame_number++;
1904 av_free_packet(&opkt);
1907 static void rate_emu_sleep(InputStream *ist)
1909 if (input_files[ist->file_index].rate_emu) {
1910 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1911 int64_t now = av_gettime() - ist->start;
1917 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1919 AVFrame *decoded_frame;
1920 AVCodecContext *avctx = ist->st->codec;
1921 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1924 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1925 return AVERROR(ENOMEM);
1927 avcodec_get_frame_defaults(ist->decoded_frame);
1928 decoded_frame = ist->decoded_frame;
1930 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1936 /* no audio frame */
1940 /* if the decoder provides a pts, use it instead of the last packet pts.
1941 the decoder could be delaying output by a packet or more. */
1942 if (decoded_frame->pts != AV_NOPTS_VALUE)
1943 ist->next_pts = decoded_frame->pts;
1945 /* increment next_pts to use for the case where the input stream does not
1946 have timestamps or there are multiple frames in the packet */
1947 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1950 // preprocess audio (volume)
1951 if (audio_volume != 256) {
1952 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1953 void *samples = decoded_frame->data[0];
1954 switch (avctx->sample_fmt) {
1955 case AV_SAMPLE_FMT_U8:
1957 uint8_t *volp = samples;
1958 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1959 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1960 *volp++ = av_clip_uint8(v);
1964 case AV_SAMPLE_FMT_S16:
1966 int16_t *volp = samples;
1967 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1968 int v = ((*volp) * audio_volume + 128) >> 8;
1969 *volp++ = av_clip_int16(v);
1973 case AV_SAMPLE_FMT_S32:
1975 int32_t *volp = samples;
1976 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1977 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1978 *volp++ = av_clipl_int32(v);
1982 case AV_SAMPLE_FMT_FLT:
1984 float *volp = samples;
1985 float scale = audio_volume / 256.f;
1986 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1991 case AV_SAMPLE_FMT_DBL:
1993 double *volp = samples;
1994 double scale = audio_volume / 256.;
1995 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2001 av_log(NULL, AV_LOG_FATAL,
2002 "Audio volume adjustment on sample format %s is not supported.\n",
2003 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
2008 rate_emu_sleep(ist);
2010 for (i = 0; i < nb_output_streams; i++) {
2011 OutputStream *ost = &output_streams[i];
2013 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2015 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
2021 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
2023 AVFrame *decoded_frame, *filtered_frame = NULL;
2024 void *buffer_to_free = NULL;
2028 int frame_available = 1;
2031 int64_t *best_effort_timestamp;
2032 AVRational *frame_sample_aspect;
2034 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2035 return AVERROR(ENOMEM);
2037 avcodec_get_frame_defaults(ist->decoded_frame);
2038 decoded_frame = ist->decoded_frame;
2039 pkt->pts = *pkt_pts;
2040 pkt->dts = *pkt_dts;
2041 *pkt_pts = AV_NOPTS_VALUE;
2043 if (pkt->duration) {
2044 duration = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2045 } else if(ist->st->codec->time_base.num != 0) {
2046 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2047 duration = ((int64_t)AV_TIME_BASE *
2048 ist->st->codec->time_base.num * ticks) /
2049 ist->st->codec->time_base.den;
2052 if(*pkt_dts != AV_NOPTS_VALUE && duration) {
2053 *pkt_dts += duration;
2055 *pkt_dts = AV_NOPTS_VALUE;
2057 ret = avcodec_decode_video2(ist->st->codec,
2058 decoded_frame, got_output, pkt);
2062 quality = same_quant ? decoded_frame->quality : 0;
2064 /* no picture yet */
2068 best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
2069 if(*best_effort_timestamp != AV_NOPTS_VALUE)
2070 ist->next_pts = ist->pts = *best_effort_timestamp;
2072 ist->next_pts += duration;
2075 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2078 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2079 for(i=0;i<nb_output_streams;i++) {
2080 OutputStream *ost = ost = &output_streams[i];
2081 if(check_output_constraints(ist, ost) && ost->encoding_needed){
2082 if (!frame_sample_aspect->num)
2083 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2084 decoded_frame->pts = ist->pts;
2085 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER) {
2086 FrameBuffer *buf = decoded_frame->opaque;
2087 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2088 decoded_frame->data, decoded_frame->linesize,
2089 AV_PERM_READ | AV_PERM_PRESERVE,
2090 ist->st->codec->width, ist->st->codec->height,
2091 ist->st->codec->pix_fmt);
2093 avfilter_copy_frame_props(fb, decoded_frame);
2095 fb->buf->priv = buf;
2096 fb->buf->free = filter_release_buffer;
2099 av_buffersrc_buffer(ost->input_video_filter, fb);
2101 if((av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE)) < 0){
2102 av_log(0, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2109 rate_emu_sleep(ist);
2111 for (i = 0; i < nb_output_streams; i++) {
2112 OutputStream *ost = &output_streams[i];
2115 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2119 if (ost->input_video_filter) {
2120 frame_available = av_buffersink_poll_frame(ost->output_video_filter);
2122 while (frame_available) {
2123 if (ost->output_video_filter) {
2124 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
2125 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0){
2126 av_log(0, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");
2129 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2130 av_free(buffer_to_free);
2131 return AVERROR(ENOMEM);
2133 avcodec_get_frame_defaults(ist->filtered_frame);
2134 filtered_frame = ist->filtered_frame;
2135 *filtered_frame= *decoded_frame; //for me_threshold
2137 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
2138 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2141 if (ost->picref->video && !ost->frame_aspect_ratio)
2142 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
2144 filtered_frame = decoded_frame;
2147 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
2148 same_quant ? quality : ost->st->codec->global_quality);
2149 if (vstats_filename && frame_size)
2150 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
2153 frame_available = ost->output_video_filter && av_buffersink_poll_frame(ost->output_video_filter);
2154 avfilter_unref_buffer(ost->picref);
2159 av_free(buffer_to_free);
2163 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2165 AVSubtitle subtitle;
2166 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2167 &subtitle, got_output, pkt);
2173 rate_emu_sleep(ist);
2175 for (i = 0; i < nb_output_streams; i++) {
2176 OutputStream *ost = &output_streams[i];
2178 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2181 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2184 avsubtitle_free(&subtitle);
2188 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2189 static int output_packet(InputStream *ist,
2190 OutputStream *ost_table, int nb_ostreams,
2191 const AVPacket *pkt)
2195 int64_t pkt_dts = AV_NOPTS_VALUE;
2196 int64_t pkt_pts = AV_NOPTS_VALUE;
2200 if (ist->next_pts == AV_NOPTS_VALUE)
2201 ist->next_pts = ist->pts;
2205 av_init_packet(&avpkt);
2213 if (pkt->dts != AV_NOPTS_VALUE) {
2214 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2215 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2216 pkt_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2218 if(pkt->pts != AV_NOPTS_VALUE)
2219 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2221 // while we have more to decode or while the decoder did output something on EOF
2222 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2225 ist->pts = ist->next_pts;
2227 if (avpkt.size && avpkt.size != pkt->size) {
2228 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2229 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2230 ist->showed_multi_packet_warning = 1;
2233 switch (ist->st->codec->codec_type) {
2234 case AVMEDIA_TYPE_AUDIO:
2235 ret = transcode_audio (ist, &avpkt, &got_output);
2237 case AVMEDIA_TYPE_VIDEO:
2238 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
2240 case AVMEDIA_TYPE_SUBTITLE:
2241 ret = transcode_subtitles(ist, &avpkt, &got_output);
2251 avpkt.pts= AV_NOPTS_VALUE;
2253 // touch data and size only if not EOF
2255 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2265 /* handle stream copy */
2266 if (!ist->decoding_needed) {
2267 rate_emu_sleep(ist);
2268 ist->pts = ist->next_pts;
2269 switch (ist->st->codec->codec_type) {
2270 case AVMEDIA_TYPE_AUDIO:
2271 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2272 ist->st->codec->sample_rate;
2274 case AVMEDIA_TYPE_VIDEO:
2275 if (pkt->duration) {
2276 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2277 } else if(ist->st->codec->time_base.num != 0) {
2278 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2279 ist->next_pts += ((int64_t)AV_TIME_BASE *
2280 ist->st->codec->time_base.num * ticks) /
2281 ist->st->codec->time_base.den;
2286 for (i = 0; pkt && i < nb_ostreams; i++) {
2287 OutputStream *ost = &ost_table[i];
2289 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2292 do_streamcopy(ist, ost, pkt);
2298 static void print_sdp(OutputFile *output_files, int n)
2302 AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2306 for (i = 0; i < n; i++)
2307 avc[i] = output_files[i].ctx;
2309 av_sdp_create(avc, n, sdp, sizeof(sdp));
2310 printf("SDP:\n%s\n", sdp);
2315 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2316 char *error, int error_len)
2318 InputStream *ist = &input_streams[ist_index];
2319 if (ist->decoding_needed) {
2320 AVCodec *codec = ist->dec;
2322 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2323 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2324 return AVERROR(EINVAL);
2327 ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
2328 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2329 ist->st->codec->get_buffer = codec_get_buffer;
2330 ist->st->codec->release_buffer = codec_release_buffer;
2331 ist->st->codec->opaque = ist;
2334 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2335 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2336 ist->file_index, ist->st->index);
2337 return AVERROR(EINVAL);
2339 assert_codec_experimental(ist->st->codec, 0);
2340 assert_avoptions(ist->opts);
2343 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;
2344 ist->next_pts = AV_NOPTS_VALUE;
2350 static int transcode_init(OutputFile *output_files, int nb_output_files,
2351 InputFile *input_files, int nb_input_files)
2353 int ret = 0, i, j, k;
2354 AVFormatContext *oc;
2355 AVCodecContext *codec, *icodec;
2361 /* init framerate emulation */
2362 for (i = 0; i < nb_input_files; i++) {
2363 InputFile *ifile = &input_files[i];
2364 if (ifile->rate_emu)
2365 for (j = 0; j < ifile->nb_streams; j++)
2366 input_streams[j + ifile->ist_index].start = av_gettime();
2369 /* output stream init */
2370 for (i = 0; i < nb_output_files; i++) {
2371 oc = output_files[i].ctx;
2372 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2373 av_dump_format(oc, i, oc->filename, 1);
2374 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2375 return AVERROR(EINVAL);
2379 /* for each output stream, we compute the right encoding parameters */
2380 for (i = 0; i < nb_output_streams; i++) {
2381 ost = &output_streams[i];
2382 oc = output_files[ost->file_index].ctx;
2383 ist = &input_streams[ost->source_index];
2385 if (ost->attachment_filename)
2388 codec = ost->st->codec;
2389 icodec = ist->st->codec;
2391 ost->st->disposition = ist->st->disposition;
2392 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2393 codec->chroma_sample_location = icodec->chroma_sample_location;
2395 if (ost->stream_copy) {
2396 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2398 if (extra_size > INT_MAX) {
2399 return AVERROR(EINVAL);
2402 /* if stream_copy is selected, no need to decode or encode */
2403 codec->codec_id = icodec->codec_id;
2404 codec->codec_type = icodec->codec_type;
2406 if (!codec->codec_tag) {
2407 if (!oc->oformat->codec_tag ||
2408 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2409 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2410 codec->codec_tag = icodec->codec_tag;
2413 codec->bit_rate = icodec->bit_rate;
2414 codec->rc_max_rate = icodec->rc_max_rate;
2415 codec->rc_buffer_size = icodec->rc_buffer_size;
2416 codec->field_order = icodec->field_order;
2417 codec->extradata = av_mallocz(extra_size);
2418 if (!codec->extradata) {
2419 return AVERROR(ENOMEM);
2421 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2422 codec->extradata_size= icodec->extradata_size;
2424 codec->time_base = ist->st->time_base;
2425 if(!strcmp(oc->oformat->name, "avi")) {
2426 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2427 && av_q2d(ist->st->time_base) < 1.0/500
2429 codec->time_base = icodec->time_base;
2430 codec->time_base.num *= icodec->ticks_per_frame;
2431 codec->time_base.den *= 2;
2433 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2434 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2435 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2437 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2438 && av_q2d(ist->st->time_base) < 1.0/500
2440 codec->time_base = icodec->time_base;
2441 codec->time_base.num *= icodec->ticks_per_frame;
2444 av_reduce(&codec->time_base.num, &codec->time_base.den,
2445 codec->time_base.num, codec->time_base.den, INT_MAX);
2447 switch (codec->codec_type) {
2448 case AVMEDIA_TYPE_AUDIO:
2449 if (audio_volume != 256) {
2450 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2453 codec->channel_layout = icodec->channel_layout;
2454 codec->sample_rate = icodec->sample_rate;
2455 codec->channels = icodec->channels;
2456 codec->frame_size = icodec->frame_size;
2457 codec->audio_service_type = icodec->audio_service_type;
2458 codec->block_align = icodec->block_align;
2460 case AVMEDIA_TYPE_VIDEO:
2461 codec->pix_fmt = icodec->pix_fmt;
2462 codec->width = icodec->width;
2463 codec->height = icodec->height;
2464 codec->has_b_frames = icodec->has_b_frames;
2465 if (!codec->sample_aspect_ratio.num) {
2466 codec->sample_aspect_ratio =
2467 ost->st->sample_aspect_ratio =
2468 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2469 ist->st->codec->sample_aspect_ratio.num ?
2470 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2472 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2474 case AVMEDIA_TYPE_SUBTITLE:
2475 codec->width = icodec->width;
2476 codec->height = icodec->height;
2478 case AVMEDIA_TYPE_DATA:
2479 case AVMEDIA_TYPE_ATTACHMENT:
2486 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2488 ist->decoding_needed = 1;
2489 ost->encoding_needed = 1;
2491 switch (codec->codec_type) {
2492 case AVMEDIA_TYPE_AUDIO:
2493 ost->fifo = av_fifo_alloc(1024);
2495 return AVERROR(ENOMEM);
2497 if (!codec->sample_rate)
2498 codec->sample_rate = icodec->sample_rate;
2499 choose_sample_rate(ost->st, ost->enc);
2500 codec->time_base = (AVRational){ 1, codec->sample_rate };
2502 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2503 codec->sample_fmt = icodec->sample_fmt;
2504 choose_sample_fmt(ost->st, ost->enc);
2506 if (ost->audio_channels_mapped) {
2507 /* the requested output channel is set to the number of
2508 * -map_channel only if no -ac are specified */
2509 if (!codec->channels) {
2510 codec->channels = ost->audio_channels_mapped;
2511 codec->channel_layout = av_get_default_channel_layout(codec->channels);
2512 if (!codec->channel_layout) {
2513 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2517 /* fill unused channel mapping with -1 (which means a muted
2518 * channel in case the number of output channels is bigger
2519 * than the number of mapped channel) */
2520 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2521 ost->audio_channels_map[j] = -1;
2522 } else if (!codec->channels) {
2523 codec->channels = icodec->channels;
2524 codec->channel_layout = icodec->channel_layout;
2526 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2527 codec->channel_layout = 0;
2529 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2530 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2531 || codec->channel_layout != icodec->channel_layout;
2532 icodec->request_channels = codec->channels;
2533 ost->resample_sample_fmt = icodec->sample_fmt;
2534 ost->resample_sample_rate = icodec->sample_rate;
2535 ost->resample_channels = icodec->channels;
2537 case AVMEDIA_TYPE_VIDEO:
2538 if (codec->pix_fmt == PIX_FMT_NONE)
2539 codec->pix_fmt = icodec->pix_fmt;
2540 choose_pixel_fmt(ost->st, ost->enc);
2542 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2543 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2547 if (!codec->width || !codec->height) {
2548 codec->width = icodec->width;
2549 codec->height = icodec->height;
2552 ost->video_resample = codec->width != icodec->width ||
2553 codec->height != icodec->height ||
2554 codec->pix_fmt != icodec->pix_fmt;
2555 if (ost->video_resample) {
2556 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
2559 ost->resample_height = icodec->height;
2560 ost->resample_width = icodec->width;
2561 ost->resample_pix_fmt = icodec->pix_fmt;
2563 if (!ost->frame_rate.num)
2564 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2565 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2566 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2567 ost->frame_rate = ost->enc->supported_framerates[idx];
2569 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2570 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method
2571 && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2572 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2573 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2575 for (j = 0; j < ost->forced_kf_count; j++)
2576 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2581 if (configure_video_filters(ist, ost)) {
2582 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2587 case AVMEDIA_TYPE_SUBTITLE:
2594 if (codec->codec_id != CODEC_ID_H264 &&
2595 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2596 char logfilename[1024];
2599 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2600 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2602 if (codec->flags & CODEC_FLAG_PASS2) {
2604 size_t logbuffer_size;
2605 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2606 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2610 codec->stats_in = logbuffer;
2612 if (codec->flags & CODEC_FLAG_PASS1) {
2613 f = fopen(logfilename, "wb");
2615 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2616 logfilename, strerror(errno));
2623 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2624 /* maximum video buffer size is 8-bytes per pixel, plus DPX header size (1664)*/
2625 int size = codec->width * codec->height;
2626 bit_buffer_size = FFMAX(bit_buffer_size, 9*size + 10000);
2631 bit_buffer = av_malloc(bit_buffer_size);
2633 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2635 return AVERROR(ENOMEM);
2638 /* open each encoder */
2639 for (i = 0; i < nb_output_streams; i++) {
2640 ost = &output_streams[i];
2641 if (ost->encoding_needed) {
2642 AVCodec *codec = ost->enc;
2643 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2645 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2646 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2647 ret = AVERROR(EINVAL);
2650 if (dec->subtitle_header) {
2651 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2652 if (!ost->st->codec->subtitle_header) {
2653 ret = AVERROR(ENOMEM);
2656 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2657 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2659 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2660 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2661 ost->file_index, ost->index);
2662 ret = AVERROR(EINVAL);
2665 assert_codec_experimental(ost->st->codec, 1);
2666 assert_avoptions(ost->opts);
2667 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2668 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2669 " It takes bits/s as argument, not kbits/s\n");
2670 extra_size += ost->st->codec->extradata_size;
2672 if (ost->st->codec->me_threshold)
2673 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2677 /* init input streams */
2678 for (i = 0; i < nb_input_streams; i++)
2679 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2682 /* discard unused programs */
2683 for (i = 0; i < nb_input_files; i++) {
2684 InputFile *ifile = &input_files[i];
2685 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2686 AVProgram *p = ifile->ctx->programs[j];
2687 int discard = AVDISCARD_ALL;
2689 for (k = 0; k < p->nb_stream_indexes; k++)
2690 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2691 discard = AVDISCARD_DEFAULT;
2694 p->discard = discard;
2698 /* open files and write file headers */
2699 for (i = 0; i < nb_output_files; i++) {
2700 oc = output_files[i].ctx;
2701 oc->interrupt_callback = int_cb;
2702 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2703 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2704 ret = AVERROR(EINVAL);
2707 // assert_avoptions(output_files[i].opts);
2708 if (strcmp(oc->oformat->name, "rtp")) {
2714 /* dump the file output parameters - cannot be done before in case
2716 for (i = 0; i < nb_output_files; i++) {
2717 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2720 /* dump the stream mapping */
2721 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2722 for (i = 0; i < nb_output_streams; i++) {
2723 ost = &output_streams[i];
2725 if (ost->attachment_filename) {
2726 /* an attached file */
2727 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2728 ost->attachment_filename, ost->file_index, ost->index);
2731 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2732 input_streams[ost->source_index].file_index,
2733 input_streams[ost->source_index].st->index,
2736 if (ost->audio_channels_mapped) {
2737 av_log(NULL, AV_LOG_INFO, " [ch:");
2738 for (j = 0; j < ost->audio_channels_mapped; j++)
2739 if (ost->audio_channels_map[j] == -1)
2740 av_log(NULL, AV_LOG_INFO, " M");
2742 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2743 av_log(NULL, AV_LOG_INFO, "]");
2745 if (ost->sync_ist != &input_streams[ost->source_index])
2746 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2747 ost->sync_ist->file_index,
2748 ost->sync_ist->st->index);
2749 if (ost->stream_copy)
2750 av_log(NULL, AV_LOG_INFO, " (copy)");
2752 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2753 input_streams[ost->source_index].dec->name : "?",
2754 ost->enc ? ost->enc->name : "?");
2755 av_log(NULL, AV_LOG_INFO, "\n");
2759 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2764 print_sdp(output_files, nb_output_files);
2771 * The following code is the main loop of the file converter
2773 static int transcode(OutputFile *output_files, int nb_output_files,
2774 InputFile *input_files, int nb_input_files)
2777 AVFormatContext *is, *os;
2781 int no_packet_count = 0;
2782 int64_t timer_start;
2785 if (!(no_packet = av_mallocz(nb_input_files)))
2788 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2793 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2796 timer_start = av_gettime();
2798 for (; received_sigterm == 0;) {
2799 int file_index, ist_index;
2803 int64_t cur_time= av_gettime();
2805 ipts_min = INT64_MAX;
2807 /* if 'q' pressed, exits */
2809 static int64_t last_time;
2810 if (received_nb_signals)
2812 /* read_key() returns 0 on EOF */
2813 if(cur_time - last_time >= 100000 && !run_as_daemon){
2815 last_time = cur_time;
2820 if (key == '+') av_log_set_level(av_log_get_level()+10);
2821 if (key == '-') av_log_set_level(av_log_get_level()-10);
2822 if (key == 's') qp_hist ^= 1;
2825 do_hex_dump = do_pkt_dump = 0;
2826 } else if(do_pkt_dump){
2830 av_log_set_level(AV_LOG_DEBUG);
2833 if (key == 'c' || key == 'C'){
2834 char buf[4096], target[64], command[256], arg[256] = {0};
2837 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2839 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2844 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2845 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2846 target, time, command, arg);
2847 for (i = 0; i < nb_output_streams; i++) {
2848 ost = &output_streams[i];
2851 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2852 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2853 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2855 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2860 av_log(NULL, AV_LOG_ERROR,
2861 "Parse error, at least 3 arguments were expected, "
2862 "only %d given in string '%s'\n", n, buf);
2866 if (key == 'd' || key == 'D'){
2869 debug = input_streams[0].st->codec->debug<<1;
2870 if(!debug) debug = 1;
2871 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2874 if(scanf("%d", &debug)!=1)
2875 fprintf(stderr,"error parsing debug value\n");
2876 for(i=0;i<nb_input_streams;i++) {
2877 input_streams[i].st->codec->debug = debug;
2879 for(i=0;i<nb_output_streams;i++) {
2880 ost = &output_streams[i];
2881 ost->st->codec->debug = debug;
2883 if(debug) av_log_set_level(AV_LOG_DEBUG);
2884 fprintf(stderr,"debug=%d\n", debug);
2887 fprintf(stderr, "key function\n"
2888 "? show this help\n"
2889 "+ increase verbosity\n"
2890 "- decrease verbosity\n"
2891 "c Send command to filtergraph\n"
2892 "D cycle through available debug modes\n"
2893 "h dump packets/hex press to cycle through the 3 states\n"
2895 "s Show QP histogram\n"
2900 /* select the stream that we must read now by looking at the
2901 smallest output pts */
2903 for (i = 0; i < nb_output_streams; i++) {
2907 ost = &output_streams[i];
2908 of = &output_files[ost->file_index];
2909 os = output_files[ost->file_index].ctx;
2910 ist = &input_streams[ost->source_index];
2911 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2912 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2914 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2916 if (!input_files[ist->file_index].eof_reached) {
2917 if (ipts < ipts_min) {
2920 file_index = ist->file_index;
2922 if (opts < opts_min) {
2924 if (!input_sync) file_index = ist->file_index;
2927 if (ost->frame_number >= ost->max_frames) {
2929 for (j = 0; j < of->ctx->nb_streams; j++)
2930 output_streams[of->ost_index + j].is_past_recording_time = 1;
2934 /* if none, if is finished */
2935 if (file_index < 0) {
2936 if (no_packet_count) {
2937 no_packet_count = 0;
2938 memset(no_packet, 0, nb_input_files);
2945 /* read a frame from it and output it in the fifo */
2946 is = input_files[file_index].ctx;
2947 ret = av_read_frame(is, &pkt);
2948 if (ret == AVERROR(EAGAIN)) {
2949 no_packet[file_index] = 1;
2954 input_files[file_index].eof_reached = 1;
2961 no_packet_count = 0;
2962 memset(no_packet, 0, nb_input_files);
2965 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2966 is->streams[pkt.stream_index]);
2968 /* the following test is needed in case new streams appear
2969 dynamically in stream : we ignore them */
2970 if (pkt.stream_index >= input_files[file_index].nb_streams)
2971 goto discard_packet;
2972 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2973 ist = &input_streams[ist_index];
2975 goto discard_packet;
2977 if (pkt.dts != AV_NOPTS_VALUE)
2978 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2979 if (pkt.pts != AV_NOPTS_VALUE)
2980 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2982 if (pkt.pts != AV_NOPTS_VALUE)
2983 pkt.pts *= ist->ts_scale;
2984 if (pkt.dts != AV_NOPTS_VALUE)
2985 pkt.dts *= ist->ts_scale;
2987 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
2989 // pkt.dts, input_files[ist->file_index].ts_offset,
2990 // ist->st->codec->codec_type);
2991 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2992 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2993 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2994 int64_t delta = pkt_dts - ist->next_pts;
2995 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2996 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2997 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2998 pkt_dts+1<ist->pts)&& !copy_ts){
2999 input_files[ist->file_index].ts_offset -= delta;
3000 av_log(NULL, AV_LOG_DEBUG,
3001 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3002 delta, input_files[ist->file_index].ts_offset);
3003 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3004 if (pkt.pts != AV_NOPTS_VALUE)
3005 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3009 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3010 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
3012 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3013 ist->file_index, ist->st->index);
3016 av_free_packet(&pkt);
3021 av_free_packet(&pkt);
3023 /* dump report by using the output first video and audio streams */
3024 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
3027 /* at the end of stream, we must flush the decoder buffers */
3028 for (i = 0; i < nb_input_streams; i++) {
3029 ist = &input_streams[i];
3030 if (ist->decoding_needed) {
3031 output_packet(ist, output_streams, nb_output_streams, NULL);
3034 flush_encoders(output_streams, nb_output_streams);
3038 /* write the trailer if needed and close file */
3039 for (i = 0; i < nb_output_files; i++) {
3040 os = output_files[i].ctx;
3041 av_write_trailer(os);
3044 /* dump report by using the first video and audio streams */
3045 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
3047 /* close each encoder */
3048 for (i = 0; i < nb_output_streams; i++) {
3049 ost = &output_streams[i];
3050 if (ost->encoding_needed) {
3051 av_freep(&ost->st->codec->stats_in);
3052 avcodec_close(ost->st->codec);
3055 avfilter_graph_free(&ost->graph);
3059 /* close each decoder */
3060 for (i = 0; i < nb_input_streams; i++) {
3061 ist = &input_streams[i];
3062 if (ist->decoding_needed) {
3063 avcodec_close(ist->st->codec);
3071 av_freep(&bit_buffer);
3072 av_freep(&no_packet);
3074 if (output_streams) {
3075 for (i = 0; i < nb_output_streams; i++) {
3076 ost = &output_streams[i];
3078 if (ost->stream_copy)
3079 av_freep(&ost->st->codec->extradata);
3081 fclose(ost->logfile);
3082 ost->logfile = NULL;
3084 av_fifo_free(ost->fifo); /* works even if fifo is not
3085 initialized but set to zero */
3086 av_freep(&ost->st->codec->subtitle_header);
3087 av_free(ost->resample_frame.data[0]);
3088 av_free(ost->forced_kf_pts);
3089 if (ost->video_resample)
3090 sws_freeContext(ost->img_resample_ctx);
3091 swr_free(&ost->swr);
3092 av_dict_free(&ost->opts);
3099 static int opt_frame_crop(const char *opt, const char *arg)
3101 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3102 return AVERROR(EINVAL);
3105 static int opt_pad(const char *opt, const char *arg)
3107 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3111 static double parse_frame_aspect_ratio(const char *arg)
3118 p = strchr(arg, ':');
3120 x = strtol(arg, &end, 10);
3122 y = strtol(end + 1, &end, 10);
3124 ar = (double)x / (double)y;
3126 ar = strtod(arg, NULL);
3129 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
3135 static int opt_video_channel(const char *opt, const char *arg)
3137 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3138 return opt_default("channel", arg);
3141 static int opt_video_standard(const char *opt, const char *arg)
3143 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3144 return opt_default("standard", arg);
3147 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3149 audio_codec_name = arg;
3150 return parse_option(o, "codec:a", arg, options);
3153 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3155 video_codec_name = arg;
3156 return parse_option(o, "codec:v", arg, options);
3159 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3161 subtitle_codec_name = arg;
3162 return parse_option(o, "codec:s", arg, options);
3165 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3167 return parse_option(o, "codec:d", arg, options);
3170 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3172 StreamMap *m = NULL;
3173 int i, negative = 0, file_idx;
3174 int sync_file_idx = -1, sync_stream_idx = 0;
3182 map = av_strdup(arg);
3184 /* parse sync stream first, just pick first matching stream */
3185 if (sync = strchr(map, ',')) {
3187 sync_file_idx = strtol(sync + 1, &sync, 0);
3188 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3189 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3194 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
3195 if (check_stream_specifier(input_files[sync_file_idx].ctx,
3196 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
3197 sync_stream_idx = i;
3200 if (i == input_files[sync_file_idx].nb_streams) {
3201 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3202 "match any streams.\n", arg);
3208 file_idx = strtol(map, &p, 0);
3209 if (file_idx >= nb_input_files || file_idx < 0) {
3210 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3214 /* disable some already defined maps */
3215 for (i = 0; i < o->nb_stream_maps; i++) {
3216 m = &o->stream_maps[i];
3217 if (file_idx == m->file_index &&
3218 check_stream_specifier(input_files[m->file_index].ctx,
3219 input_files[m->file_index].ctx->streams[m->stream_index],
3220 *p == ':' ? p + 1 : p) > 0)
3224 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3225 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3226 *p == ':' ? p + 1 : p) <= 0)
3228 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3229 &o->nb_stream_maps, o->nb_stream_maps + 1);
3230 m = &o->stream_maps[o->nb_stream_maps - 1];
3232 m->file_index = file_idx;
3233 m->stream_index = i;
3235 if (sync_file_idx >= 0) {
3236 m->sync_file_index = sync_file_idx;
3237 m->sync_stream_index = sync_stream_idx;
3239 m->sync_file_index = file_idx;
3240 m->sync_stream_index = i;
3245 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3253 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3255 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3256 &o->nb_attachments, o->nb_attachments + 1);
3257 o->attachments[o->nb_attachments - 1] = arg;
3261 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3267 o->audio_channel_maps =
3268 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3269 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3270 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3272 /* muted channel syntax */
3273 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3274 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3275 m->file_idx = m->stream_idx = -1;
3277 m->ofile_idx = m->ostream_idx = -1;
3282 n = sscanf(arg, "%d.%d.%d:%d.%d",
3283 &m->file_idx, &m->stream_idx, &m->channel_idx,
3284 &m->ofile_idx, &m->ostream_idx);
3286 if (n != 3 && n != 5) {
3287 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3288 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3292 if (n != 5) // only file.stream.channel specified
3293 m->ofile_idx = m->ostream_idx = -1;
3296 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3297 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3301 if (m->stream_idx < 0 ||
3302 m->stream_idx >= input_files[m->file_idx].nb_streams) {
3303 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3304 m->file_idx, m->stream_idx);
3307 st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3308 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3309 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3310 m->file_idx, m->stream_idx);
3313 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3314 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3315 m->file_idx, m->stream_idx, m->channel_idx);
3322 * Parse a metadata specifier in arg.
3323 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3324 * @param index for type c/p, chapter/program index is written here
3325 * @param stream_spec for type s, the stream specifier is written here
3327 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3335 if (*(++arg) && *arg != ':') {
3336 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3339 *stream_spec = *arg == ':' ? arg + 1 : "";
3343 if (*(++arg) == ':')
3344 *index = strtol(++arg, NULL, 0);
3347 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3354 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3356 AVDictionary **meta_in = NULL;
3357 AVDictionary **meta_out = NULL;
3359 char type_in, type_out;
3360 const char *istream_spec = NULL, *ostream_spec = NULL;
3361 int idx_in = 0, idx_out = 0;
3363 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3364 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3366 if (type_in == 'g' || type_out == 'g')
3367 o->metadata_global_manual = 1;
3368 if (type_in == 's' || type_out == 's')
3369 o->metadata_streams_manual = 1;
3370 if (type_in == 'c' || type_out == 'c')
3371 o->metadata_chapters_manual = 1;
3373 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3374 if ((index) < 0 || (index) >= (nb_elems)) {\
3375 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3380 #define SET_DICT(type, meta, context, index)\
3383 meta = &context->metadata;\
3386 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3387 meta = &context->chapters[index]->metadata;\
3390 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3391 meta = &context->programs[index]->metadata;\
3395 SET_DICT(type_in, meta_in, ic, idx_in);
3396 SET_DICT(type_out, meta_out, oc, idx_out);
3398 /* for input streams choose first matching stream */
3399 if (type_in == 's') {
3400 for (i = 0; i < ic->nb_streams; i++) {
3401 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3402 meta_in = &ic->streams[i]->metadata;
3408 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3413 if (type_out == 's') {
3414 for (i = 0; i < oc->nb_streams; i++) {
3415 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3416 meta_out = &oc->streams[i]->metadata;
3417 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3422 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3427 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3430 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3431 struct tm time = *gmtime((time_t*)&recording_timestamp);
3432 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3433 parse_option(o, "metadata", buf, options);
3435 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3436 "tag instead.\n", opt);
3440 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3442 const char *codec_string = encoder ? "encoder" : "decoder";
3446 avcodec_find_encoder_by_name(name) :
3447 avcodec_find_decoder_by_name(name);
3449 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3452 if (codec->type != type) {
3453 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3459 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3461 char *codec_name = NULL;
3463 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3465 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3466 st->codec->codec_id = codec->id;
3469 return avcodec_find_decoder(st->codec->codec_id);
3473 * Add all the streams from the given input file to the global
3474 * list of input streams.
3476 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3479 char *next, *codec_tag = NULL;
3481 for (i = 0; i < ic->nb_streams; i++) {
3482 AVStream *st = ic->streams[i];
3483 AVCodecContext *dec = st->codec;
3486 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3487 ist = &input_streams[nb_input_streams - 1];
3489 ist->file_index = nb_input_files;
3491 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3493 ist->ts_scale = 1.0;
3494 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3496 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3498 uint32_t tag = strtol(codec_tag, &next, 0);
3500 tag = AV_RL32(codec_tag);
3501 st->codec->codec_tag = tag;
3504 ist->dec = choose_decoder(o, ic, st);
3506 switch (dec->codec_type) {
3507 case AVMEDIA_TYPE_AUDIO:
3509 ist->dec = avcodec_find_decoder(dec->codec_id);
3510 if (o->audio_disable)
3511 st->discard = AVDISCARD_ALL;
3513 case AVMEDIA_TYPE_VIDEO:
3515 ist->dec = avcodec_find_decoder(dec->codec_id);
3517 dec->flags |= CODEC_FLAG_EMU_EDGE;
3520 if (o->video_disable)
3521 st->discard = AVDISCARD_ALL;
3522 else if (video_discard)
3523 st->discard = video_discard;
3525 case AVMEDIA_TYPE_DATA:
3526 if (o->data_disable)
3527 st->discard= AVDISCARD_ALL;
3529 case AVMEDIA_TYPE_SUBTITLE:
3531 ist->dec = avcodec_find_decoder(dec->codec_id);
3532 if(o->subtitle_disable)
3533 st->discard = AVDISCARD_ALL;
3535 case AVMEDIA_TYPE_ATTACHMENT:
3536 case AVMEDIA_TYPE_UNKNOWN:
3544 static void assert_file_overwrite(const char *filename)
3546 if ((!file_overwrite || no_file_overwrite) &&
3547 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3548 av_strstart(filename, "file:", NULL))) {
3549 if (avio_check(filename, 0) == 0) {
3550 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3551 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3554 signal(SIGINT, SIG_DFL);
3555 if (!read_yesno()) {
3556 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3562 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3569 static void dump_attachment(AVStream *st, const char *filename)
3572 AVIOContext *out = NULL;
3573 AVDictionaryEntry *e;
3575 if (!st->codec->extradata_size) {
3576 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3577 nb_input_files - 1, st->index);
3580 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3581 filename = e->value;
3583 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3584 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3588 assert_file_overwrite(filename);
3590 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3591 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3596 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3601 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3603 AVFormatContext *ic;
3604 AVInputFormat *file_iformat = NULL;
3608 AVDictionary **opts;
3609 int orig_nb_streams; // number of streams before avformat_find_stream_info
3612 if (!(file_iformat = av_find_input_format(o->format))) {
3613 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3618 if (!strcmp(filename, "-"))
3621 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3622 !strcmp(filename, "/dev/stdin");
3624 /* get default parameters from command line */
3625 ic = avformat_alloc_context();
3627 print_error(filename, AVERROR(ENOMEM));
3630 if (o->nb_audio_sample_rate) {
3631 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3632 av_dict_set(&format_opts, "sample_rate", buf, 0);
3634 if (o->nb_audio_channels) {
3635 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3636 av_dict_set(&format_opts, "channels", buf, 0);
3638 if (o->nb_frame_rates) {
3639 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3641 if (o->nb_frame_sizes) {
3642 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3644 if (o->nb_frame_pix_fmts)
3645 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3647 ic->video_codec_id = video_codec_name ?
3648 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3649 ic->audio_codec_id = audio_codec_name ?
3650 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3651 ic->subtitle_codec_id= subtitle_codec_name ?
3652 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3653 ic->flags |= AVFMT_FLAG_NONBLOCK;
3654 ic->interrupt_callback = int_cb;
3657 av_log(NULL, AV_LOG_WARNING,
3658 "-loop_input is deprecated, use -loop 1\n"
3659 "Note, both loop options only work with -f image2\n"
3661 ic->loop_input = loop_input;
3664 /* open the input file with generic avformat function */
3665 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3667 print_error(filename, err);
3670 assert_avoptions(format_opts);
3672 /* apply forced codec ids */
3673 for (i = 0; i < ic->nb_streams; i++)
3674 choose_decoder(o, ic, ic->streams[i]);
3676 /* Set AVCodecContext options for avformat_find_stream_info */
3677 opts = setup_find_stream_info_opts(ic, codec_opts);
3678 orig_nb_streams = ic->nb_streams;
3680 /* If not enough info to get the stream parameters, we decode the
3681 first frames to get it. (used in mpeg case for example) */
3682 ret = avformat_find_stream_info(ic, opts);
3684 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3685 avformat_close_input(&ic);
3689 timestamp = o->start_time;
3690 /* add the stream start time */
3691 if (ic->start_time != AV_NOPTS_VALUE)
3692 timestamp += ic->start_time;
3694 /* if seeking requested, we execute it */
3695 if (o->start_time != 0) {
3696 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3698 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3699 filename, (double)timestamp / AV_TIME_BASE);
3703 /* update the current parameters so that they match the one of the input stream */
3704 add_input_streams(o, ic);
3706 /* dump the file content */
3707 av_dump_format(ic, nb_input_files, filename, 0);
3709 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3710 input_files[nb_input_files - 1].ctx = ic;
3711 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3712 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3713 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3714 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3716 for (i = 0; i < o->nb_dump_attachment; i++) {
3719 for (j = 0; j < ic->nb_streams; j++) {
3720 AVStream *st = ic->streams[j];
3722 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3723 dump_attachment(st, o->dump_attachment[i].u.str);
3727 for (i = 0; i < orig_nb_streams; i++)
3728 av_dict_free(&opts[i]);
3731 reset_options(o, 1);
3735 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3740 for (p = kf; *p; p++)
3743 ost->forced_kf_count = n;
3744 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3745 if (!ost->forced_kf_pts) {
3746 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3749 for (i = 0; i < n; i++) {
3750 p = i ? strchr(p, ',') + 1 : kf;
3751 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3755 static uint8_t *get_line(AVIOContext *s)
3761 if (avio_open_dyn_buf(&line) < 0) {
3762 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3766 while ((c = avio_r8(s)) && c != '\n')
3769 avio_close_dyn_buf(line, &buf);
3774 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3777 char filename[1000];
3778 const char *base[3] = { getenv("AVCONV_DATADIR"),
3783 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3787 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3788 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3789 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3792 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3793 i != 1 ? "" : "/.avconv", preset_name);
3794 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3800 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3802 char *codec_name = NULL;
3804 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3806 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3807 NULL, ost->st->codec->codec_type);
3808 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3809 } else if (!strcmp(codec_name, "copy"))
3810 ost->stream_copy = 1;
3812 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3813 ost->st->codec->codec_id = ost->enc->id;
3817 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3820 AVStream *st = avformat_new_stream(oc, NULL);
3821 int idx = oc->nb_streams - 1, ret = 0;
3822 char *bsf = NULL, *next, *codec_tag = NULL;
3823 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3825 char *buf = NULL, *arg = NULL, *preset = NULL;
3826 AVIOContext *s = NULL;
3829 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3833 if (oc->nb_streams - 1 < o->nb_streamid_map)
3834 st->id = o->streamid_map[oc->nb_streams - 1];
3836 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3837 nb_output_streams + 1);
3838 ost = &output_streams[nb_output_streams - 1];
3839 ost->file_index = nb_output_files;
3842 st->codec->codec_type = type;
3843 choose_encoder(o, oc, ost);
3845 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3848 avcodec_get_context_defaults3(st->codec, ost->enc);
3849 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3851 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3852 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3855 if (!buf[0] || buf[0] == '#') {
3859 if (!(arg = strchr(buf, '='))) {
3860 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3864 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3866 } while (!s->eof_reached);
3870 av_log(NULL, AV_LOG_FATAL,
3871 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3872 preset, ost->file_index, ost->index);
3876 ost->max_frames = INT64_MAX;
3877 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3879 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3881 if (next = strchr(bsf, ','))
3883 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3884 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3888 bsfc_prev->next = bsfc;
3890 ost->bitstream_filters = bsfc;
3896 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3898 uint32_t tag = strtol(codec_tag, &next, 0);
3900 tag = AV_RL32(codec_tag);
3901 st->codec->codec_tag = tag;
3904 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3905 if (qscale >= 0 || same_quant) {
3906 st->codec->flags |= CODEC_FLAG_QSCALE;
3907 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3910 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3911 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3913 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3917 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3920 const char *p = str;
3927 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3934 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3938 AVCodecContext *video_enc;
3940 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3942 video_enc = st->codec;
3944 if (!ost->stream_copy) {
3945 const char *p = NULL;
3946 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3947 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3948 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3951 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3952 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3953 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3957 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3958 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3959 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3963 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3964 if (frame_aspect_ratio)
3965 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3967 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3968 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3969 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3970 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3973 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3976 video_enc->gop_size = 0;
3977 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3979 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3980 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3983 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3985 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3987 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3988 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3991 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3994 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3995 for (i = 0; p; i++) {
3997 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3999 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4002 /* FIXME realloc failure */
4003 video_enc->rc_override =
4004 av_realloc(video_enc->rc_override,
4005 sizeof(RcOverride) * (i + 1));
4006 video_enc->rc_override[i].start_frame = start;
4007 video_enc->rc_override[i].end_frame = end;
4009 video_enc->rc_override[i].qscale = q;
4010 video_enc->rc_override[i].quality_factor = 1.0;
4013 video_enc->rc_override[i].qscale = 0;
4014 video_enc->rc_override[i].quality_factor = -q/100.0;
4019 video_enc->rc_override_count = i;
4020 if (!video_enc->rc_initial_buffer_occupancy)
4021 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4022 video_enc->intra_dc_precision = intra_dc_precision - 8;
4025 video_enc->flags|= CODEC_FLAG_PSNR;
4030 video_enc->flags |= CODEC_FLAG_PASS1;
4033 video_enc->flags |= CODEC_FLAG_PASS2;
4037 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4038 if (forced_key_frames)
4039 parse_forced_key_frames(forced_key_frames, ost);
4041 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4043 ost->top_field_first = -1;
4044 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4047 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4049 ost->avfilter = av_strdup(filters);
4052 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4058 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
4063 AVCodecContext *audio_enc;
4065 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
4068 audio_enc = st->codec;
4069 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4071 if (!ost->stream_copy) {
4072 char *sample_fmt = NULL;
4074 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4076 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4078 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4079 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4083 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4085 ost->rematrix_volume=1.0;
4086 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4089 /* check for channel mapping for this audio stream */
4090 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4091 AudioChannelMap *map = &o->audio_channel_maps[n];
4092 InputStream *ist = &input_streams[ost->source_index];
4093 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4094 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4095 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4096 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4097 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4099 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4100 ost->file_index, ost->st->index);
4107 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
4111 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
4112 if (!ost->stream_copy) {
4113 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4120 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
4122 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
4123 ost->stream_copy = 1;
4127 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
4131 AVCodecContext *subtitle_enc;
4133 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
4135 subtitle_enc = st->codec;
4137 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4142 /* arg format is "output-stream-index:streamid-value". */
4143 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4149 av_strlcpy(idx_str, arg, sizeof(idx_str));
4150 p = strchr(idx_str, ':');
4152 av_log(NULL, AV_LOG_FATAL,
4153 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4158 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4159 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4160 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4164 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4166 AVFormatContext *is = ifile->ctx;
4167 AVFormatContext *os = ofile->ctx;
4170 for (i = 0; i < is->nb_chapters; i++) {
4171 AVChapter *in_ch = is->chapters[i], *out_ch;
4172 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4173 AV_TIME_BASE_Q, in_ch->time_base);
4174 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4175 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4178 if (in_ch->end < ts_off)
4180 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4183 out_ch = av_mallocz(sizeof(AVChapter));
4185 return AVERROR(ENOMEM);
4187 out_ch->id = in_ch->id;
4188 out_ch->time_base = in_ch->time_base;
4189 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4190 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4193 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4196 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4198 return AVERROR(ENOMEM);
4199 os->chapters[os->nb_chapters - 1] = out_ch;
4204 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4207 AVFormatContext *ic = avformat_alloc_context();
4209 ic->interrupt_callback = int_cb;
4210 err = avformat_open_input(&ic, filename, NULL, NULL);
4213 /* copy stream format */
4214 for(i=0;i<ic->nb_streams;i++) {
4218 AVCodecContext *avctx;
4220 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4221 ost = new_output_stream(o, s, codec->type);
4226 // FIXME: a more elegant solution is needed
4227 memcpy(st, ic->streams[i], sizeof(AVStream));
4228 st->info = av_malloc(sizeof(*st->info));
4229 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4231 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4233 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4234 choose_sample_fmt(st, codec);
4235 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4236 choose_pixel_fmt(st, codec);
4239 avformat_close_input(&ic);
4243 static void opt_output_file(void *optctx, const char *filename)
4245 OptionsContext *o = optctx;
4246 AVFormatContext *oc;
4248 AVOutputFormat *file_oformat;
4252 if (!strcmp(filename, "-"))
4255 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4257 print_error(filename, err);
4260 file_oformat= oc->oformat;
4261 oc->interrupt_callback = int_cb;
4263 if (!strcmp(file_oformat->name, "ffm") &&
4264 av_strstart(filename, "http:", NULL)) {
4266 /* special case for files sent to ffserver: we get the stream
4267 parameters from ffserver */
4268 int err = read_ffserver_streams(o, oc, filename);
4270 print_error(filename, err);
4273 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4274 ost = &output_streams[j];
4275 for (i = 0; i < nb_input_streams; i++) {
4276 ist = &input_streams[i];
4277 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4279 ost->source_index= i;
4285 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));
4289 } else if (!o->nb_stream_maps) {
4290 /* pick the "best" stream of each type */
4291 #define NEW_STREAM(type, index)\
4293 ost = new_ ## type ## _stream(o, oc);\
4294 ost->source_index = index;\
4295 ost->sync_ist = &input_streams[index];\
4296 input_streams[index].discard = 0;\
4299 /* video: highest resolution */
4300 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4301 int area = 0, idx = -1;
4302 for (i = 0; i < nb_input_streams; i++) {
4303 ist = &input_streams[i];
4304 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4305 ist->st->codec->width * ist->st->codec->height > area) {
4306 area = ist->st->codec->width * ist->st->codec->height;
4310 NEW_STREAM(video, idx);
4313 /* audio: most channels */
4314 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4315 int channels = 0, idx = -1;
4316 for (i = 0; i < nb_input_streams; i++) {
4317 ist = &input_streams[i];
4318 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4319 ist->st->codec->channels > channels) {
4320 channels = ist->st->codec->channels;
4324 NEW_STREAM(audio, idx);
4327 /* subtitles: pick first */
4328 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4329 for (i = 0; i < nb_input_streams; i++)
4330 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4331 NEW_STREAM(subtitle, i);
4335 /* do something with data? */
4337 for (i = 0; i < o->nb_stream_maps; i++) {
4338 StreamMap *map = &o->stream_maps[i];
4343 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4344 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4346 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4348 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4350 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4353 switch (ist->st->codec->codec_type) {
4354 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4355 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4356 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4357 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4358 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4360 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4361 map->file_index, map->stream_index);
4365 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4366 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4367 map->sync_stream_index];
4372 /* handle attached files */
4373 for (i = 0; i < o->nb_attachments; i++) {
4375 uint8_t *attachment;
4379 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4380 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4384 if ((len = avio_size(pb)) <= 0) {
4385 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4389 if (!(attachment = av_malloc(len))) {
4390 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4394 avio_read(pb, attachment, len);
4396 ost = new_attachment_stream(o, oc);
4397 ost->stream_copy = 0;
4398 ost->source_index = -1;
4399 ost->attachment_filename = o->attachments[i];
4400 ost->st->codec->extradata = attachment;
4401 ost->st->codec->extradata_size = len;
4403 p = strrchr(o->attachments[i], '/');
4404 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4408 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4409 output_files[nb_output_files - 1].ctx = oc;
4410 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4411 output_files[nb_output_files - 1].recording_time = o->recording_time;
4412 output_files[nb_output_files - 1].start_time = o->start_time;
4413 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4414 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4416 /* check filename in case of an image number is expected */
4417 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4418 if (!av_filename_number_test(oc->filename)) {
4419 print_error(oc->filename, AVERROR(EINVAL));
4424 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4425 /* test if it already exists to avoid losing precious files */
4426 assert_file_overwrite(filename);
4429 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4430 &oc->interrupt_callback,
4431 &output_files[nb_output_files - 1].opts)) < 0) {
4432 print_error(filename, err);
4437 if (o->mux_preload) {
4439 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4440 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4442 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4444 if (loop_output >= 0) {
4445 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4446 oc->loop_output = loop_output;
4450 for (i = 0; i < o->nb_metadata_map; i++) {
4452 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4454 if (in_file_index < 0)
4456 if (in_file_index >= nb_input_files) {
4457 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4460 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4464 if (o->chapters_input_file >= nb_input_files) {
4465 if (o->chapters_input_file == INT_MAX) {
4466 /* copy chapters from the first input file that has them*/
4467 o->chapters_input_file = -1;
4468 for (i = 0; i < nb_input_files; i++)
4469 if (input_files[i].ctx->nb_chapters) {
4470 o->chapters_input_file = i;
4474 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4475 o->chapters_input_file);
4479 if (o->chapters_input_file >= 0)
4480 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4481 !o->metadata_chapters_manual);
4483 /* copy global metadata by default */
4484 if (!o->metadata_global_manual && nb_input_files){
4485 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4486 AV_DICT_DONT_OVERWRITE);
4487 if(o->recording_time != INT64_MAX)
4488 av_dict_set(&oc->metadata, "duration", NULL, 0);
4490 if (!o->metadata_streams_manual)
4491 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4493 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4495 ist = &input_streams[output_streams[i].source_index];
4496 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4499 /* process manually set metadata */
4500 for (i = 0; i < o->nb_metadata; i++) {
4503 const char *stream_spec;
4504 int index = 0, j, ret = 0;
4506 val = strchr(o->metadata[i].u.str, '=');
4508 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4509 o->metadata[i].u.str);
4514 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4516 for (j = 0; j < oc->nb_streams; j++) {
4517 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4518 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4522 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4530 if (index < 0 || index >= oc->nb_chapters) {
4531 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4534 m = &oc->chapters[index]->metadata;
4537 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4540 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4544 reset_options(o, 0);
4547 /* same option as mencoder */
4548 static int opt_pass(const char *opt, const char *arg)
4550 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4554 static int64_t getutime(void)
4557 struct rusage rusage;
4559 getrusage(RUSAGE_SELF, &rusage);
4560 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4561 #elif HAVE_GETPROCESSTIMES
4563 FILETIME c, e, k, u;
4564 proc = GetCurrentProcess();
4565 GetProcessTimes(proc, &c, &e, &k, &u);
4566 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4568 return av_gettime();
4572 static int64_t getmaxrss(void)
4574 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4575 struct rusage rusage;
4576 getrusage(RUSAGE_SELF, &rusage);
4577 return (int64_t)rusage.ru_maxrss * 1024;
4578 #elif HAVE_GETPROCESSMEMORYINFO
4580 PROCESS_MEMORY_COUNTERS memcounters;
4581 proc = GetCurrentProcess();
4582 memcounters.cb = sizeof(memcounters);
4583 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4584 return memcounters.PeakPagefileUsage;
4590 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4592 return parse_option(o, "q:a", arg, options);
4595 static void show_usage(void)
4597 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
4598 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4599 av_log(NULL, AV_LOG_INFO, "\n");
4602 static int opt_help(const char *opt, const char *arg)
4604 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4605 av_log_set_callback(log_callback_help);
4607 show_help_options(options, "Main options:\n",
4608 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4609 show_help_options(options, "\nAdvanced options:\n",
4610 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4612 show_help_options(options, "\nVideo options:\n",
4613 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4615 show_help_options(options, "\nAdvanced Video options:\n",
4616 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4617 OPT_VIDEO | OPT_EXPERT);
4618 show_help_options(options, "\nAudio options:\n",
4619 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4621 show_help_options(options, "\nAdvanced Audio options:\n",
4622 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4623 OPT_AUDIO | OPT_EXPERT);
4624 show_help_options(options, "\nSubtitle options:\n",
4625 OPT_SUBTITLE | OPT_GRAB,
4627 show_help_options(options, "\nAudio/Video grab options:\n",
4631 show_help_children(avcodec_get_class(), flags);
4632 show_help_children(avformat_get_class(), flags);
4633 show_help_children(sws_get_class(), flags);
4638 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4640 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4641 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4643 if (!strncmp(arg, "pal-", 4)) {
4646 } else if (!strncmp(arg, "ntsc-", 5)) {
4649 } else if (!strncmp(arg, "film-", 5)) {
4653 /* Try to determine PAL/NTSC by peeking in the input files */
4654 if (nb_input_files) {
4656 for (j = 0; j < nb_input_files; j++) {
4657 for (i = 0; i < input_files[j].nb_streams; i++) {
4658 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4659 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4661 fr = c->time_base.den * 1000 / c->time_base.num;
4665 } else if ((fr == 29970) || (fr == 23976)) {
4670 if (norm != UNKNOWN)
4674 if (norm != UNKNOWN)
4675 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4678 if (norm == UNKNOWN) {
4679 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4680 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4681 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4685 if (!strcmp(arg, "vcd")) {
4686 opt_video_codec(o, "c:v", "mpeg1video");
4687 opt_audio_codec(o, "c:a", "mp2");
4688 parse_option(o, "f", "vcd", options);
4690 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4691 parse_option(o, "r", frame_rates[norm], options);
4692 opt_default("g", norm == PAL ? "15" : "18");
4694 opt_default("b:v", "1150000");
4695 opt_default("maxrate", "1150000");
4696 opt_default("minrate", "1150000");
4697 opt_default("bufsize", "327680"); // 40*1024*8;
4699 opt_default("b:a", "224000");
4700 parse_option(o, "ar", "44100", options);
4701 parse_option(o, "ac", "2", options);
4703 opt_default("packetsize", "2324");
4704 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4706 /* We have to offset the PTS, so that it is consistent with the SCR.
4707 SCR starts at 36000, but the first two packs contain only padding
4708 and the first pack from the other stream, respectively, may also have
4709 been written before.
4710 So the real data starts at SCR 36000+3*1200. */
4711 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4712 } else if (!strcmp(arg, "svcd")) {
4714 opt_video_codec(o, "c:v", "mpeg2video");
4715 opt_audio_codec(o, "c:a", "mp2");
4716 parse_option(o, "f", "svcd", options);
4718 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4719 parse_option(o, "r", frame_rates[norm], options);
4720 parse_option(o, "pix_fmt", "yuv420p", options);
4721 opt_default("g", norm == PAL ? "15" : "18");
4723 opt_default("b:v", "2040000");
4724 opt_default("maxrate", "2516000");
4725 opt_default("minrate", "0"); // 1145000;
4726 opt_default("bufsize", "1835008"); // 224*1024*8;
4727 opt_default("flags", "+scan_offset");
4730 opt_default("b:a", "224000");
4731 parse_option(o, "ar", "44100", options);
4733 opt_default("packetsize", "2324");
4735 } else if (!strcmp(arg, "dvd")) {
4737 opt_video_codec(o, "c:v", "mpeg2video");
4738 opt_audio_codec(o, "c:a", "ac3");
4739 parse_option(o, "f", "dvd", options);
4741 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4742 parse_option(o, "r", frame_rates[norm], options);
4743 parse_option(o, "pix_fmt", "yuv420p", options);
4744 opt_default("g", norm == PAL ? "15" : "18");
4746 opt_default("b:v", "6000000");
4747 opt_default("maxrate", "9000000");
4748 opt_default("minrate", "0"); // 1500000;
4749 opt_default("bufsize", "1835008"); // 224*1024*8;
4751 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4752 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4754 opt_default("b:a", "448000");
4755 parse_option(o, "ar", "48000", options);
4757 } else if (!strncmp(arg, "dv", 2)) {
4759 parse_option(o, "f", "dv", options);
4761 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4762 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4763 norm == PAL ? "yuv420p" : "yuv411p", options);
4764 parse_option(o, "r", frame_rates[norm], options);
4766 parse_option(o, "ar", "48000", options);
4767 parse_option(o, "ac", "2", options);
4770 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4771 return AVERROR(EINVAL);
4776 static int opt_vstats_file(const char *opt, const char *arg)
4778 av_free (vstats_filename);
4779 vstats_filename = av_strdup (arg);
4783 static int opt_vstats(const char *opt, const char *arg)
4786 time_t today2 = time(NULL);
4787 struct tm *today = localtime(&today2);
4789 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4791 return opt_vstats_file(opt, filename);
4794 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4796 return parse_option(o, "frames:v", arg, options);
4799 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4801 return parse_option(o, "frames:a", arg, options);
4804 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4806 return parse_option(o, "frames:d", arg, options);
4809 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4812 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4813 const char *codec_name = *opt == 'v' ? video_codec_name :
4814 *opt == 'a' ? audio_codec_name :
4815 subtitle_codec_name;
4817 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4818 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4819 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4821 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4826 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4827 if(line[0] == '#' && !e)
4829 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4831 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4834 if(!strcmp(tmp, "acodec")){
4835 opt_audio_codec(o, tmp, tmp2);
4836 }else if(!strcmp(tmp, "vcodec")){
4837 opt_video_codec(o, tmp, tmp2);
4838 }else if(!strcmp(tmp, "scodec")){
4839 opt_subtitle_codec(o, tmp, tmp2);
4840 }else if(!strcmp(tmp, "dcodec")){
4841 opt_data_codec(o, tmp, tmp2);
4842 }else if(opt_default(tmp, tmp2) < 0){
4843 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4853 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4857 static int opt_passlogfile(const char *opt, const char *arg)
4859 pass_logfilename_prefix = arg;
4860 #if CONFIG_LIBX264_ENCODER
4861 return opt_default("passlogfile", arg);
4867 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4869 char *s = av_asprintf("%s:%c", opt + 1, *opt);
4870 int ret = parse_option(o, s, arg, options);
4875 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4877 if(!strcmp(opt, "b")){
4878 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4879 return parse_option(o, "b:v", arg, options);
4881 return opt_default(opt, arg);
4884 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4886 return parse_option(o, "filter:v", arg, options);
4889 static int opt_vsync(const char *opt, const char *arg)
4891 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
4892 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
4893 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4895 if (video_sync_method == VSYNC_AUTO)
4896 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4900 #define OFFSET(x) offsetof(OptionsContext, x)
4901 static const OptionDef options[] = {
4903 #include "cmdutils_common_opts.h"
4904 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4905 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4906 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4907 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4908 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4909 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4910 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4911 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4912 { "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]" },
4913 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4914 "outfile[,metadata]:infile[,metadata]" },
4915 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4916 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4917 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4918 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4919 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4920 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4921 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4922 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4923 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4924 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4925 "add timings for benchmarking" },
4926 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4927 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4928 "dump each input packet" },
4929 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4930 "when dumping packets, also dump the payload" },
4931 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4932 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4933 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4934 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4935 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4936 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4937 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4938 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4939 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
4940 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4941 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4942 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4943 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4944 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4945 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4946 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4947 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4949 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4951 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4952 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4953 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4956 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4957 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4958 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4959 { "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" },
4960 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4961 { "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" },
4962 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4963 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4964 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4965 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4966 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4967 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4968 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4969 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4970 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4971 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4972 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4973 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4974 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4975 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4976 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4977 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4978 "use same quantizer as source (implies VBR)" },
4979 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4980 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4981 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4982 "deinterlace pictures" },
4983 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4984 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4985 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4987 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4989 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4990 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4991 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4992 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4993 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4994 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4995 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4996 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4997 { "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" },
4998 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5001 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5002 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5003 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5004 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5005 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5006 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5007 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5008 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5009 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5010 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
5012 /* subtitle options */
5013 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5014 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5015 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5018 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5019 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5020 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5023 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5024 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5026 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5027 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5028 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5030 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5031 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5032 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5033 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5034 /* data codec support */
5035 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5036 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5038 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5042 int main(int argc, char **argv)
5044 OptionsContext o = { 0 };
5047 reset_options(&o, 0);
5049 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5050 parse_loglevel(argc, argv, options);
5052 if(argc>1 && !strcmp(argv[1], "-d")){
5054 av_log_set_callback(log_callback_null);
5059 avcodec_register_all();
5061 avdevice_register_all();
5064 avfilter_register_all();
5067 avformat_network_init();
5069 show_banner(argc, argv, options);
5074 parse_options(&o, argc, argv, options, opt_output_file);
5076 if (nb_output_files <= 0 && nb_input_files == 0) {
5078 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5082 /* file converter / grab */
5083 if (nb_output_files <= 0) {
5084 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5088 if (nb_input_files == 0) {
5089 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5094 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
5096 ti = getutime() - ti;
5098 int maxrss = getmaxrss() / 1024;
5099 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);