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, "%s failed for stream %d, 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_compensate(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 != dec->width ||
1369 ost->resample_height != dec->height ||
1370 ost->resample_pix_fmt != dec->pix_fmt;
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\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 ost->resample_width = dec->width;
1380 ost->resample_height = dec->height;
1381 ost->resample_pix_fmt = dec->pix_fmt;
1384 ost->video_resample = dec->width != enc->width ||
1385 dec->height != enc->height ||
1386 dec->pix_fmt != enc->pix_fmt;
1388 if (ost->video_resample) {
1389 *out_picture = &ost->resample_frame;
1390 if (!ost->img_resample_ctx || resample_changed) {
1391 /* initialize the destination picture */
1392 if (!ost->resample_frame.data[0]) {
1393 avcodec_get_frame_defaults(&ost->resample_frame);
1394 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1395 enc->width, enc->height)) {
1396 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1400 /* initialize a new scaler context */
1401 sws_freeContext(ost->img_resample_ctx);
1402 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1403 enc->width, enc->height, enc->pix_fmt,
1404 ost->sws_flags, NULL, NULL, NULL);
1405 if (ost->img_resample_ctx == NULL) {
1406 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1410 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1411 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1417 static void do_video_out(AVFormatContext *s,
1420 AVFrame *in_picture,
1421 int *frame_size, float quality)
1423 int nb_frames, i, ret, format_video_sync;
1424 AVFrame *final_picture;
1425 AVCodecContext *enc;
1427 double duration = 0;
1429 enc = ost->st->codec;
1431 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1432 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1433 if(ist->st->avg_frame_rate.num)
1434 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1436 duration /= av_q2d(enc->time_base);
1439 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1441 /* by default, we output a single frame */
1446 format_video_sync = video_sync_method;
1447 if (format_video_sync == VSYNC_AUTO)
1448 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1450 if (format_video_sync != VSYNC_PASSTHROUGH) {
1451 double vdelta = sync_ipts - ost->sync_opts + duration;
1452 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1455 else if (format_video_sync == VSYNC_VFR) {
1456 if (vdelta <= -0.6) {
1458 } else if (vdelta > 0.6)
1459 ost->sync_opts = lrintf(sync_ipts);
1460 } else if (vdelta > 1.1)
1461 nb_frames = lrintf(vdelta);
1462 //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);
1463 if (nb_frames == 0) {
1465 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1466 } else if (nb_frames > 1) {
1467 nb_frames_dup += nb_frames - 1;
1468 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1471 ost->sync_opts = lrintf(sync_ipts);
1473 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1477 do_video_resample(ost, ist, in_picture, &final_picture);
1479 /* duplicates frame if needed */
1480 for (i = 0; i < nb_frames; i++) {
1482 av_init_packet(&pkt);
1483 pkt.stream_index = ost->index;
1485 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1486 enc->codec->id == CODEC_ID_RAWVIDEO) {
1487 /* raw pictures are written as AVPicture structure to
1488 avoid any copies. We support temporarily the older
1490 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1491 enc->coded_frame->top_field_first = in_picture->top_field_first;
1492 pkt.data = (uint8_t *)final_picture;
1493 pkt.size = sizeof(AVPicture);
1494 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1495 pkt.flags |= AV_PKT_FLAG_KEY;
1497 write_frame(s, &pkt, ost);
1499 AVFrame big_picture;
1501 big_picture = *final_picture;
1502 /* better than nothing: use input picture interlaced
1504 big_picture.interlaced_frame = in_picture->interlaced_frame;
1505 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1506 if (ost->top_field_first == -1)
1507 big_picture.top_field_first = in_picture->top_field_first;
1509 big_picture.top_field_first = !!ost->top_field_first;
1512 /* handles same_quant here. This is not correct because it may
1513 not be a global option */
1514 big_picture.quality = quality;
1515 if (!enc->me_threshold)
1516 big_picture.pict_type = 0;
1517 // big_picture.pts = AV_NOPTS_VALUE;
1518 big_picture.pts = ost->sync_opts;
1519 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1520 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1521 if (ost->forced_kf_index < ost->forced_kf_count &&
1522 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1523 big_picture.pict_type = AV_PICTURE_TYPE_I;
1524 ost->forced_kf_index++;
1526 ret = avcodec_encode_video(enc,
1527 bit_buffer, bit_buffer_size,
1530 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1535 pkt.data = bit_buffer;
1537 if (enc->coded_frame->pts != AV_NOPTS_VALUE)
1538 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1539 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1540 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1541 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1543 if (enc->coded_frame->key_frame)
1544 pkt.flags |= AV_PKT_FLAG_KEY;
1545 write_frame(s, &pkt, ost);
1548 // fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1549 // enc->frame_number-1, ret, enc->pict_type);
1550 /* if two pass, output log */
1551 if (ost->logfile && enc->stats_out) {
1552 fprintf(ost->logfile, "%s", enc->stats_out);
1560 static double psnr(double d)
1562 return -10.0 * log(d) / log(10.0);
1565 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1568 AVCodecContext *enc;
1570 double ti1, bitrate, avg_bitrate;
1572 /* this is executed just the first time do_video_stats is called */
1574 vstats_file = fopen(vstats_filename, "w");
1581 enc = ost->st->codec;
1582 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1583 frame_number = ost->frame_number;
1584 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1585 if (enc->flags&CODEC_FLAG_PSNR)
1586 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1588 fprintf(vstats_file,"f_size= %6d ", frame_size);
1589 /* compute pts value */
1590 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1594 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1595 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1596 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1597 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1598 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1602 static void print_report(OutputFile *output_files,
1603 OutputStream *ost_table, int nb_ostreams,
1604 int is_last_report, int64_t timer_start, int64_t cur_time)
1608 AVFormatContext *oc;
1610 AVCodecContext *enc;
1611 int frame_number, vid, i;
1613 int64_t pts = INT64_MAX;
1614 static int64_t last_time = -1;
1615 static int qp_histogram[52];
1616 int hours, mins, secs, us;
1618 if (!print_stats && !is_last_report)
1621 if (!is_last_report) {
1622 if (last_time == -1) {
1623 last_time = cur_time;
1626 if ((cur_time - last_time) < 500000)
1628 last_time = cur_time;
1632 oc = output_files[0].ctx;
1634 total_size = avio_size(oc->pb);
1635 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
1636 total_size = avio_tell(oc->pb);
1643 for (i = 0; i < nb_ostreams; i++) {
1645 ost = &ost_table[i];
1646 enc = ost->st->codec;
1647 if (!ost->stream_copy && enc->coded_frame)
1648 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1649 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1650 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1652 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1653 float t = (cur_time-timer_start) / 1000000.0;
1655 frame_number = ost->frame_number;
1656 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1657 frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1659 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1663 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1665 for (j = 0; j < 32; j++)
1666 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1668 if (enc->flags&CODEC_FLAG_PSNR) {
1670 double error, error_sum = 0;
1671 double scale, scale_sum = 0;
1672 char type[3] = { 'Y','U','V' };
1673 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1674 for (j = 0; j < 3; j++) {
1675 if (is_last_report) {
1676 error = enc->error[j];
1677 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1679 error = enc->coded_frame->error[j];
1680 scale = enc->width * enc->height * 255.0 * 255.0;
1686 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1688 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1692 /* compute min output value */
1693 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1694 ost->st->time_base, AV_TIME_BASE_Q));
1697 secs = pts / AV_TIME_BASE;
1698 us = pts % AV_TIME_BASE;
1704 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1706 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1707 "size=%8.0fkB time=", total_size / 1024.0);
1708 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1709 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1710 (100 * us) / AV_TIME_BASE);
1711 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1712 "bitrate=%6.1fkbits/s", bitrate);
1714 if (nb_frames_dup || nb_frames_drop)
1715 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1716 nb_frames_dup, nb_frames_drop);
1718 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1722 if (is_last_report) {
1723 int64_t raw= audio_size + video_size + extra_size;
1724 av_log(NULL, AV_LOG_INFO, "\n");
1725 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1726 video_size / 1024.0,
1727 audio_size / 1024.0,
1728 extra_size / 1024.0,
1729 100.0 * (total_size - raw) / raw
1731 if(video_size + audio_size + extra_size == 0){
1732 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1737 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1741 for (i = 0; i < nb_ostreams; i++) {
1742 OutputStream *ost = &ost_table[i];
1743 AVCodecContext *enc = ost->st->codec;
1744 AVFormatContext *os = output_files[ost->file_index].ctx;
1746 if (!ost->encoding_needed)
1749 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1751 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1757 av_init_packet(&pkt);
1758 pkt.stream_index = ost->index;
1760 switch (ost->st->codec->codec_type) {
1761 case AVMEDIA_TYPE_AUDIO:
1762 fifo_bytes = av_fifo_size(ost->fifo);
1764 /* encode any samples remaining in fifo */
1765 if (fifo_bytes > 0) {
1766 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1767 int fs_tmp = enc->frame_size;
1769 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1770 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1771 enc->frame_size = fifo_bytes / (osize * enc->channels);
1773 int frame_bytes = enc->frame_size*osize*enc->channels;
1774 if (allocated_audio_buf_size < frame_bytes)
1776 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1779 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1780 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1781 ost->st->time_base.num, enc->sample_rate);
1782 enc->frame_size = fs_tmp;
1785 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1788 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1792 pkt.flags |= AV_PKT_FLAG_KEY;
1794 case AVMEDIA_TYPE_VIDEO:
1795 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1797 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1801 if (enc->coded_frame && enc->coded_frame->key_frame)
1802 pkt.flags |= AV_PKT_FLAG_KEY;
1803 if (ost->logfile && enc->stats_out) {
1804 fprintf(ost->logfile, "%s", enc->stats_out);
1813 pkt.data = bit_buffer;
1815 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1816 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1817 write_frame(os, &pkt, ost);
1823 * Check whether a packet from ist should be written into ost at this time
1825 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1827 OutputFile *of = &output_files[ost->file_index];
1828 int ist_index = ist - input_streams;
1830 if (ost->source_index != ist_index)
1833 if (of->start_time && ist->pts < of->start_time)
1836 if (of->recording_time != INT64_MAX &&
1837 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1838 (AVRational){ 1, 1000000 }) >= 0) {
1839 ost->is_past_recording_time = 1;
1846 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1848 OutputFile *of = &output_files[ost->file_index];
1849 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1853 av_init_packet(&opkt);
1855 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1856 !ost->copy_initial_nonkeyframes)
1859 /* force the input stream PTS */
1860 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1861 audio_size += pkt->size;
1862 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1863 video_size += pkt->size;
1867 opkt.stream_index = ost->index;
1868 if (pkt->pts != AV_NOPTS_VALUE)
1869 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1871 opkt.pts = AV_NOPTS_VALUE;
1873 if (pkt->dts == AV_NOPTS_VALUE)
1874 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1876 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1877 opkt.dts -= ost_tb_start_time;
1879 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1880 opkt.flags = pkt->flags;
1882 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1883 if ( ost->st->codec->codec_id != CODEC_ID_H264
1884 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1885 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1887 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1888 opkt.destruct = av_destruct_packet;
1890 opkt.data = pkt->data;
1891 opkt.size = pkt->size;
1893 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1894 /* store AVPicture in AVPacket, as expected by the output format */
1895 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1896 opkt.data = (uint8_t *)&pict;
1897 opkt.size = sizeof(AVPicture);
1898 opkt.flags |= AV_PKT_FLAG_KEY;
1901 write_frame(of->ctx, &opkt, ost);
1902 ost->st->codec->frame_number++;
1903 av_free_packet(&opkt);
1906 static void rate_emu_sleep(InputStream *ist)
1908 if (input_files[ist->file_index].rate_emu) {
1909 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1910 int64_t now = av_gettime() - ist->start;
1916 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1918 AVFrame *decoded_frame;
1919 AVCodecContext *avctx = ist->st->codec;
1920 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1923 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1924 return AVERROR(ENOMEM);
1926 avcodec_get_frame_defaults(ist->decoded_frame);
1927 decoded_frame = ist->decoded_frame;
1929 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1935 /* no audio frame */
1939 /* if the decoder provides a pts, use it instead of the last packet pts.
1940 the decoder could be delaying output by a packet or more. */
1941 if (decoded_frame->pts != AV_NOPTS_VALUE)
1942 ist->next_pts = decoded_frame->pts;
1944 /* increment next_pts to use for the case where the input stream does not
1945 have timestamps or there are multiple frames in the packet */
1946 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1949 // preprocess audio (volume)
1950 if (audio_volume != 256) {
1951 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1952 void *samples = decoded_frame->data[0];
1953 switch (avctx->sample_fmt) {
1954 case AV_SAMPLE_FMT_U8:
1956 uint8_t *volp = samples;
1957 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1958 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1959 *volp++ = av_clip_uint8(v);
1963 case AV_SAMPLE_FMT_S16:
1965 int16_t *volp = samples;
1966 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1967 int v = ((*volp) * audio_volume + 128) >> 8;
1968 *volp++ = av_clip_int16(v);
1972 case AV_SAMPLE_FMT_S32:
1974 int32_t *volp = samples;
1975 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1976 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1977 *volp++ = av_clipl_int32(v);
1981 case AV_SAMPLE_FMT_FLT:
1983 float *volp = samples;
1984 float scale = audio_volume / 256.f;
1985 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1990 case AV_SAMPLE_FMT_DBL:
1992 double *volp = samples;
1993 double scale = audio_volume / 256.;
1994 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2000 av_log(NULL, AV_LOG_FATAL,
2001 "Audio volume adjustment on sample format %s is not supported.\n",
2002 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
2007 rate_emu_sleep(ist);
2009 for (i = 0; i < nb_output_streams; i++) {
2010 OutputStream *ost = &output_streams[i];
2012 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2014 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
2020 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
2022 AVFrame *decoded_frame, *filtered_frame = NULL;
2023 void *buffer_to_free = NULL;
2027 int frame_available = 1;
2030 int64_t *best_effort_timestamp;
2031 AVRational *frame_sample_aspect;
2033 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2034 return AVERROR(ENOMEM);
2036 avcodec_get_frame_defaults(ist->decoded_frame);
2037 decoded_frame = ist->decoded_frame;
2038 pkt->pts = *pkt_pts;
2039 pkt->dts = *pkt_dts;
2040 *pkt_pts = AV_NOPTS_VALUE;
2042 if (pkt->duration) {
2043 duration = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2044 } else if(ist->st->codec->time_base.num != 0) {
2045 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2046 duration = ((int64_t)AV_TIME_BASE *
2047 ist->st->codec->time_base.num * ticks) /
2048 ist->st->codec->time_base.den;
2051 if(*pkt_dts != AV_NOPTS_VALUE && duration) {
2052 *pkt_dts += duration;
2054 *pkt_dts = AV_NOPTS_VALUE;
2056 ret = avcodec_decode_video2(ist->st->codec,
2057 decoded_frame, got_output, pkt);
2061 quality = same_quant ? decoded_frame->quality : 0;
2063 /* no picture yet */
2067 best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
2068 if(*best_effort_timestamp != AV_NOPTS_VALUE)
2069 ist->next_pts = ist->pts = *best_effort_timestamp;
2071 ist->next_pts += duration;
2074 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2077 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2078 for(i=0;i<nb_output_streams;i++) {
2079 OutputStream *ost = ost = &output_streams[i];
2080 if(check_output_constraints(ist, ost)){
2081 if (!frame_sample_aspect->num)
2082 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2083 decoded_frame->pts = ist->pts;
2084 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER) {
2085 FrameBuffer *buf = decoded_frame->opaque;
2086 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2087 decoded_frame->data, decoded_frame->linesize,
2088 AV_PERM_READ | AV_PERM_PRESERVE,
2089 ist->st->codec->width, ist->st->codec->height,
2090 ist->st->codec->pix_fmt);
2092 avfilter_copy_frame_props(fb, decoded_frame);
2094 fb->buf->priv = buf;
2095 fb->buf->free = filter_release_buffer;
2098 av_buffersrc_buffer(ost->input_video_filter, fb);
2100 if((av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE)) < 0){
2101 av_log(0, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2108 rate_emu_sleep(ist);
2110 for (i = 0; i < nb_output_streams; i++) {
2111 OutputStream *ost = &output_streams[i];
2114 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2118 if (ost->input_video_filter) {
2119 frame_available = av_buffersink_poll_frame(ost->output_video_filter);
2121 while (frame_available) {
2122 if (ost->output_video_filter) {
2123 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
2124 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0){
2125 av_log(0, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");
2128 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2129 av_free(buffer_to_free);
2130 return AVERROR(ENOMEM);
2132 avcodec_get_frame_defaults(ist->filtered_frame);
2133 filtered_frame = ist->filtered_frame;
2134 *filtered_frame= *decoded_frame; //for me_threshold
2136 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
2137 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2140 if (ost->picref->video && !ost->frame_aspect_ratio)
2141 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
2143 filtered_frame = decoded_frame;
2146 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
2147 same_quant ? quality : ost->st->codec->global_quality);
2148 if (vstats_filename && frame_size)
2149 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
2152 frame_available = ost->output_video_filter && av_buffersink_poll_frame(ost->output_video_filter);
2153 avfilter_unref_buffer(ost->picref);
2158 av_free(buffer_to_free);
2162 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2164 AVSubtitle subtitle;
2165 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2166 &subtitle, got_output, pkt);
2172 rate_emu_sleep(ist);
2174 for (i = 0; i < nb_output_streams; i++) {
2175 OutputStream *ost = &output_streams[i];
2177 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2180 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2183 avsubtitle_free(&subtitle);
2187 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2188 static int output_packet(InputStream *ist,
2189 OutputStream *ost_table, int nb_ostreams,
2190 const AVPacket *pkt)
2194 int64_t pkt_dts = AV_NOPTS_VALUE;
2195 int64_t pkt_pts = AV_NOPTS_VALUE;
2199 if (ist->next_pts == AV_NOPTS_VALUE)
2200 ist->next_pts = ist->pts;
2204 av_init_packet(&avpkt);
2212 if (pkt->dts != AV_NOPTS_VALUE) {
2213 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2214 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2215 pkt_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2217 if(pkt->pts != AV_NOPTS_VALUE)
2218 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2220 // while we have more to decode or while the decoder did output something on EOF
2221 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2224 ist->pts = ist->next_pts;
2226 if (avpkt.size && avpkt.size != pkt->size) {
2227 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2228 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2229 ist->showed_multi_packet_warning = 1;
2232 switch (ist->st->codec->codec_type) {
2233 case AVMEDIA_TYPE_AUDIO:
2234 ret = transcode_audio (ist, &avpkt, &got_output);
2236 case AVMEDIA_TYPE_VIDEO:
2237 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
2239 case AVMEDIA_TYPE_SUBTITLE:
2240 ret = transcode_subtitles(ist, &avpkt, &got_output);
2250 avpkt.pts= AV_NOPTS_VALUE;
2252 // touch data and size only if not EOF
2254 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2264 /* handle stream copy */
2265 if (!ist->decoding_needed) {
2266 rate_emu_sleep(ist);
2267 ist->pts = ist->next_pts;
2268 switch (ist->st->codec->codec_type) {
2269 case AVMEDIA_TYPE_AUDIO:
2270 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2271 ist->st->codec->sample_rate;
2273 case AVMEDIA_TYPE_VIDEO:
2274 if (pkt->duration) {
2275 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2276 } else if(ist->st->codec->time_base.num != 0) {
2277 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2278 ist->next_pts += ((int64_t)AV_TIME_BASE *
2279 ist->st->codec->time_base.num * ticks) /
2280 ist->st->codec->time_base.den;
2285 for (i = 0; pkt && i < nb_ostreams; i++) {
2286 OutputStream *ost = &ost_table[i];
2288 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2291 do_streamcopy(ist, ost, pkt);
2297 static void print_sdp(OutputFile *output_files, int n)
2301 AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2305 for (i = 0; i < n; i++)
2306 avc[i] = output_files[i].ctx;
2308 av_sdp_create(avc, n, sdp, sizeof(sdp));
2309 printf("SDP:\n%s\n", sdp);
2314 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2315 char *error, int error_len)
2317 InputStream *ist = &input_streams[ist_index];
2318 if (ist->decoding_needed) {
2319 AVCodec *codec = ist->dec;
2321 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2322 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2323 return AVERROR(EINVAL);
2326 ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
2327 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2328 ist->st->codec->get_buffer = codec_get_buffer;
2329 ist->st->codec->release_buffer = codec_release_buffer;
2330 ist->st->codec->opaque = ist;
2333 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2334 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2335 ist->file_index, ist->st->index);
2336 return AVERROR(EINVAL);
2338 assert_codec_experimental(ist->st->codec, 0);
2339 assert_avoptions(ist->opts);
2342 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;
2343 ist->next_pts = AV_NOPTS_VALUE;
2349 static int transcode_init(OutputFile *output_files, int nb_output_files,
2350 InputFile *input_files, int nb_input_files)
2352 int ret = 0, i, j, k;
2353 AVFormatContext *oc;
2354 AVCodecContext *codec, *icodec;
2360 /* init framerate emulation */
2361 for (i = 0; i < nb_input_files; i++) {
2362 InputFile *ifile = &input_files[i];
2363 if (ifile->rate_emu)
2364 for (j = 0; j < ifile->nb_streams; j++)
2365 input_streams[j + ifile->ist_index].start = av_gettime();
2368 /* output stream init */
2369 for (i = 0; i < nb_output_files; i++) {
2370 oc = output_files[i].ctx;
2371 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2372 av_dump_format(oc, i, oc->filename, 1);
2373 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2374 return AVERROR(EINVAL);
2378 /* for each output stream, we compute the right encoding parameters */
2379 for (i = 0; i < nb_output_streams; i++) {
2380 ost = &output_streams[i];
2381 oc = output_files[ost->file_index].ctx;
2382 ist = &input_streams[ost->source_index];
2384 if (ost->attachment_filename)
2387 codec = ost->st->codec;
2388 icodec = ist->st->codec;
2390 ost->st->disposition = ist->st->disposition;
2391 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2392 codec->chroma_sample_location = icodec->chroma_sample_location;
2394 if (ost->stream_copy) {
2395 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2397 if (extra_size > INT_MAX) {
2398 return AVERROR(EINVAL);
2401 /* if stream_copy is selected, no need to decode or encode */
2402 codec->codec_id = icodec->codec_id;
2403 codec->codec_type = icodec->codec_type;
2405 if (!codec->codec_tag) {
2406 if (!oc->oformat->codec_tag ||
2407 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2408 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2409 codec->codec_tag = icodec->codec_tag;
2412 codec->bit_rate = icodec->bit_rate;
2413 codec->rc_max_rate = icodec->rc_max_rate;
2414 codec->rc_buffer_size = icodec->rc_buffer_size;
2415 codec->field_order = icodec->field_order;
2416 codec->extradata = av_mallocz(extra_size);
2417 if (!codec->extradata) {
2418 return AVERROR(ENOMEM);
2420 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2421 codec->extradata_size= icodec->extradata_size;
2423 codec->time_base = ist->st->time_base;
2424 if(!strcmp(oc->oformat->name, "avi")) {
2425 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2426 && av_q2d(ist->st->time_base) < 1.0/500
2428 codec->time_base = icodec->time_base;
2429 codec->time_base.num *= icodec->ticks_per_frame;
2430 codec->time_base.den *= 2;
2432 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2433 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2434 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2436 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2437 && av_q2d(ist->st->time_base) < 1.0/500
2439 codec->time_base = icodec->time_base;
2440 codec->time_base.num *= icodec->ticks_per_frame;
2443 av_reduce(&codec->time_base.num, &codec->time_base.den,
2444 codec->time_base.num, codec->time_base.den, INT_MAX);
2446 switch (codec->codec_type) {
2447 case AVMEDIA_TYPE_AUDIO:
2448 if (audio_volume != 256) {
2449 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2452 codec->channel_layout = icodec->channel_layout;
2453 codec->sample_rate = icodec->sample_rate;
2454 codec->channels = icodec->channels;
2455 codec->frame_size = icodec->frame_size;
2456 codec->audio_service_type = icodec->audio_service_type;
2457 codec->block_align = icodec->block_align;
2459 case AVMEDIA_TYPE_VIDEO:
2460 codec->pix_fmt = icodec->pix_fmt;
2461 codec->width = icodec->width;
2462 codec->height = icodec->height;
2463 codec->has_b_frames = icodec->has_b_frames;
2464 if (!codec->sample_aspect_ratio.num) {
2465 codec->sample_aspect_ratio =
2466 ost->st->sample_aspect_ratio =
2467 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2468 ist->st->codec->sample_aspect_ratio.num ?
2469 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2471 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2473 case AVMEDIA_TYPE_SUBTITLE:
2474 codec->width = icodec->width;
2475 codec->height = icodec->height;
2477 case AVMEDIA_TYPE_DATA:
2478 case AVMEDIA_TYPE_ATTACHMENT:
2485 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2487 ist->decoding_needed = 1;
2488 ost->encoding_needed = 1;
2490 switch (codec->codec_type) {
2491 case AVMEDIA_TYPE_AUDIO:
2492 ost->fifo = av_fifo_alloc(1024);
2494 return AVERROR(ENOMEM);
2496 if (!codec->sample_rate)
2497 codec->sample_rate = icodec->sample_rate;
2498 choose_sample_rate(ost->st, ost->enc);
2499 codec->time_base = (AVRational){ 1, codec->sample_rate };
2501 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2502 codec->sample_fmt = icodec->sample_fmt;
2503 choose_sample_fmt(ost->st, ost->enc);
2505 if (ost->audio_channels_mapped) {
2506 /* the requested output channel is set to the number of
2507 * -map_channel only if no -ac are specified */
2508 if (!codec->channels) {
2509 codec->channels = ost->audio_channels_mapped;
2510 codec->channel_layout = av_get_default_channel_layout(codec->channels);
2511 if (!codec->channel_layout) {
2512 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2516 /* fill unused channel mapping with -1 (which means a muted
2517 * channel in case the number of output channels is bigger
2518 * than the number of mapped channel) */
2519 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2520 ost->audio_channels_map[j] = -1;
2521 } else if (!codec->channels) {
2522 codec->channels = icodec->channels;
2523 codec->channel_layout = icodec->channel_layout;
2525 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2526 codec->channel_layout = 0;
2528 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2529 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2530 || codec->channel_layout != icodec->channel_layout;
2531 icodec->request_channels = codec->channels;
2532 ost->resample_sample_fmt = icodec->sample_fmt;
2533 ost->resample_sample_rate = icodec->sample_rate;
2534 ost->resample_channels = icodec->channels;
2536 case AVMEDIA_TYPE_VIDEO:
2537 if (codec->pix_fmt == PIX_FMT_NONE)
2538 codec->pix_fmt = icodec->pix_fmt;
2539 choose_pixel_fmt(ost->st, ost->enc);
2541 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2542 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2546 if (!codec->width || !codec->height) {
2547 codec->width = icodec->width;
2548 codec->height = icodec->height;
2551 ost->video_resample = codec->width != icodec->width ||
2552 codec->height != icodec->height ||
2553 codec->pix_fmt != icodec->pix_fmt;
2554 if (ost->video_resample) {
2555 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
2558 ost->resample_height = icodec->height;
2559 ost->resample_width = icodec->width;
2560 ost->resample_pix_fmt = icodec->pix_fmt;
2562 if (!ost->frame_rate.num)
2563 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2564 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2565 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2566 ost->frame_rate = ost->enc->supported_framerates[idx];
2568 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2569 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method
2570 && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2571 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2572 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2574 for (j = 0; j < ost->forced_kf_count; j++)
2575 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2580 if (configure_video_filters(ist, ost)) {
2581 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2586 case AVMEDIA_TYPE_SUBTITLE:
2593 if (codec->codec_id != CODEC_ID_H264 &&
2594 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2595 char logfilename[1024];
2598 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2599 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2601 if (codec->flags & CODEC_FLAG_PASS2) {
2603 size_t logbuffer_size;
2604 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2605 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2609 codec->stats_in = logbuffer;
2611 if (codec->flags & CODEC_FLAG_PASS1) {
2612 f = fopen(logfilename, "wb");
2614 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2615 logfilename, strerror(errno));
2622 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2623 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2624 int size = codec->width * codec->height;
2625 bit_buffer_size = FFMAX(bit_buffer_size, 7*size + 10000);
2630 bit_buffer = av_malloc(bit_buffer_size);
2632 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2634 return AVERROR(ENOMEM);
2637 /* open each encoder */
2638 for (i = 0; i < nb_output_streams; i++) {
2639 ost = &output_streams[i];
2640 if (ost->encoding_needed) {
2641 AVCodec *codec = ost->enc;
2642 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2644 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2645 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2646 ret = AVERROR(EINVAL);
2649 if (dec->subtitle_header) {
2650 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2651 if (!ost->st->codec->subtitle_header) {
2652 ret = AVERROR(ENOMEM);
2655 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2656 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2658 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2659 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2660 ost->file_index, ost->index);
2661 ret = AVERROR(EINVAL);
2664 assert_codec_experimental(ost->st->codec, 1);
2665 assert_avoptions(ost->opts);
2666 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2667 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2668 " It takes bits/s as argument, not kbits/s\n");
2669 extra_size += ost->st->codec->extradata_size;
2671 if (ost->st->codec->me_threshold)
2672 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2676 /* init input streams */
2677 for (i = 0; i < nb_input_streams; i++)
2678 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2681 /* discard unused programs */
2682 for (i = 0; i < nb_input_files; i++) {
2683 InputFile *ifile = &input_files[i];
2684 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2685 AVProgram *p = ifile->ctx->programs[j];
2686 int discard = AVDISCARD_ALL;
2688 for (k = 0; k < p->nb_stream_indexes; k++)
2689 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2690 discard = AVDISCARD_DEFAULT;
2693 p->discard = discard;
2697 /* open files and write file headers */
2698 for (i = 0; i < nb_output_files; i++) {
2699 oc = output_files[i].ctx;
2700 oc->interrupt_callback = int_cb;
2701 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2702 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2703 ret = AVERROR(EINVAL);
2706 // assert_avoptions(output_files[i].opts);
2707 if (strcmp(oc->oformat->name, "rtp")) {
2713 /* dump the file output parameters - cannot be done before in case
2715 for (i = 0; i < nb_output_files; i++) {
2716 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2719 /* dump the stream mapping */
2720 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2721 for (i = 0; i < nb_output_streams; i++) {
2722 ost = &output_streams[i];
2724 if (ost->attachment_filename) {
2725 /* an attached file */
2726 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2727 ost->attachment_filename, ost->file_index, ost->index);
2730 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2731 input_streams[ost->source_index].file_index,
2732 input_streams[ost->source_index].st->index,
2735 if (ost->audio_channels_mapped) {
2736 av_log(NULL, AV_LOG_INFO, " [ch:");
2737 for (j = 0; j < ost->audio_channels_mapped; j++)
2738 if (ost->audio_channels_map[j] == -1)
2739 av_log(NULL, AV_LOG_INFO, " M");
2741 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2742 av_log(NULL, AV_LOG_INFO, "]");
2744 if (ost->sync_ist != &input_streams[ost->source_index])
2745 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2746 ost->sync_ist->file_index,
2747 ost->sync_ist->st->index);
2748 if (ost->stream_copy)
2749 av_log(NULL, AV_LOG_INFO, " (copy)");
2751 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2752 input_streams[ost->source_index].dec->name : "?",
2753 ost->enc ? ost->enc->name : "?");
2754 av_log(NULL, AV_LOG_INFO, "\n");
2758 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2763 print_sdp(output_files, nb_output_files);
2770 * The following code is the main loop of the file converter
2772 static int transcode(OutputFile *output_files, int nb_output_files,
2773 InputFile *input_files, int nb_input_files)
2776 AVFormatContext *is, *os;
2780 int no_packet_count = 0;
2781 int64_t timer_start;
2784 if (!(no_packet = av_mallocz(nb_input_files)))
2787 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2792 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2795 timer_start = av_gettime();
2797 for (; received_sigterm == 0;) {
2798 int file_index, ist_index;
2802 int64_t cur_time= av_gettime();
2804 ipts_min = INT64_MAX;
2806 /* if 'q' pressed, exits */
2808 static int64_t last_time;
2809 if (received_nb_signals)
2811 /* read_key() returns 0 on EOF */
2812 if(cur_time - last_time >= 100000 && !run_as_daemon){
2814 last_time = cur_time;
2819 if (key == '+') av_log_set_level(av_log_get_level()+10);
2820 if (key == '-') av_log_set_level(av_log_get_level()-10);
2821 if (key == 's') qp_hist ^= 1;
2824 do_hex_dump = do_pkt_dump = 0;
2825 } else if(do_pkt_dump){
2829 av_log_set_level(AV_LOG_DEBUG);
2832 if (key == 'c' || key == 'C'){
2833 char buf[4096], target[64], command[256], arg[256] = {0};
2836 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2838 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2843 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2844 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2845 target, time, command, arg);
2846 for (i = 0; i < nb_output_streams; i++) {
2847 ost = &output_streams[i];
2850 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2851 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2852 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2854 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2859 av_log(NULL, AV_LOG_ERROR,
2860 "Parse error, at least 3 arguments were expected, "
2861 "only %d given in string '%s'\n", n, buf);
2865 if (key == 'd' || key == 'D'){
2868 debug = input_streams[0].st->codec->debug<<1;
2869 if(!debug) debug = 1;
2870 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2873 if(scanf("%d", &debug)!=1)
2874 fprintf(stderr,"error parsing debug value\n");
2875 for(i=0;i<nb_input_streams;i++) {
2876 input_streams[i].st->codec->debug = debug;
2878 for(i=0;i<nb_output_streams;i++) {
2879 ost = &output_streams[i];
2880 ost->st->codec->debug = debug;
2882 if(debug) av_log_set_level(AV_LOG_DEBUG);
2883 fprintf(stderr,"debug=%d\n", debug);
2886 fprintf(stderr, "key function\n"
2887 "? show this help\n"
2888 "+ increase verbosity\n"
2889 "- decrease verbosity\n"
2890 "c Send command to filtergraph\n"
2891 "D cycle through available debug modes\n"
2892 "h dump packets/hex press to cycle through the 3 states\n"
2894 "s Show QP histogram\n"
2899 /* select the stream that we must read now by looking at the
2900 smallest output pts */
2902 for (i = 0; i < nb_output_streams; i++) {
2906 ost = &output_streams[i];
2907 of = &output_files[ost->file_index];
2908 os = output_files[ost->file_index].ctx;
2909 ist = &input_streams[ost->source_index];
2910 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2911 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2913 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2915 if (!input_files[ist->file_index].eof_reached) {
2916 if (ipts < ipts_min) {
2919 file_index = ist->file_index;
2921 if (opts < opts_min) {
2923 if (!input_sync) file_index = ist->file_index;
2926 if (ost->frame_number >= ost->max_frames) {
2928 for (j = 0; j < of->ctx->nb_streams; j++)
2929 output_streams[of->ost_index + j].is_past_recording_time = 1;
2933 /* if none, if is finished */
2934 if (file_index < 0) {
2935 if (no_packet_count) {
2936 no_packet_count = 0;
2937 memset(no_packet, 0, nb_input_files);
2944 /* read a frame from it and output it in the fifo */
2945 is = input_files[file_index].ctx;
2946 ret = av_read_frame(is, &pkt);
2947 if (ret == AVERROR(EAGAIN)) {
2948 no_packet[file_index] = 1;
2953 input_files[file_index].eof_reached = 1;
2960 no_packet_count = 0;
2961 memset(no_packet, 0, nb_input_files);
2964 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2965 is->streams[pkt.stream_index]);
2967 /* the following test is needed in case new streams appear
2968 dynamically in stream : we ignore them */
2969 if (pkt.stream_index >= input_files[file_index].nb_streams)
2970 goto discard_packet;
2971 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2972 ist = &input_streams[ist_index];
2974 goto discard_packet;
2976 if (pkt.dts != AV_NOPTS_VALUE)
2977 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2978 if (pkt.pts != AV_NOPTS_VALUE)
2979 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2981 if (pkt.pts != AV_NOPTS_VALUE)
2982 pkt.pts *= ist->ts_scale;
2983 if (pkt.dts != AV_NOPTS_VALUE)
2984 pkt.dts *= ist->ts_scale;
2986 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
2988 // pkt.dts, input_files[ist->file_index].ts_offset,
2989 // ist->st->codec->codec_type);
2990 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2991 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2992 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2993 int64_t delta = pkt_dts - ist->next_pts;
2994 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2995 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2996 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2997 pkt_dts+1<ist->pts)&& !copy_ts){
2998 input_files[ist->file_index].ts_offset -= delta;
2999 av_log(NULL, AV_LOG_DEBUG,
3000 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3001 delta, input_files[ist->file_index].ts_offset);
3002 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3003 if (pkt.pts != AV_NOPTS_VALUE)
3004 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3008 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3009 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
3011 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3012 ist->file_index, ist->st->index);
3015 av_free_packet(&pkt);
3020 av_free_packet(&pkt);
3022 /* dump report by using the output first video and audio streams */
3023 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
3026 /* at the end of stream, we must flush the decoder buffers */
3027 for (i = 0; i < nb_input_streams; i++) {
3028 ist = &input_streams[i];
3029 if (ist->decoding_needed) {
3030 output_packet(ist, output_streams, nb_output_streams, NULL);
3033 flush_encoders(output_streams, nb_output_streams);
3037 /* write the trailer if needed and close file */
3038 for (i = 0; i < nb_output_files; i++) {
3039 os = output_files[i].ctx;
3040 av_write_trailer(os);
3043 /* dump report by using the first video and audio streams */
3044 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
3046 /* close each encoder */
3047 for (i = 0; i < nb_output_streams; i++) {
3048 ost = &output_streams[i];
3049 if (ost->encoding_needed) {
3050 av_freep(&ost->st->codec->stats_in);
3051 avcodec_close(ost->st->codec);
3054 avfilter_graph_free(&ost->graph);
3058 /* close each decoder */
3059 for (i = 0; i < nb_input_streams; i++) {
3060 ist = &input_streams[i];
3061 if (ist->decoding_needed) {
3062 avcodec_close(ist->st->codec);
3070 av_freep(&bit_buffer);
3071 av_freep(&no_packet);
3073 if (output_streams) {
3074 for (i = 0; i < nb_output_streams; i++) {
3075 ost = &output_streams[i];
3077 if (ost->stream_copy)
3078 av_freep(&ost->st->codec->extradata);
3080 fclose(ost->logfile);
3081 ost->logfile = NULL;
3083 av_fifo_free(ost->fifo); /* works even if fifo is not
3084 initialized but set to zero */
3085 av_freep(&ost->st->codec->subtitle_header);
3086 av_free(ost->resample_frame.data[0]);
3087 av_free(ost->forced_kf_pts);
3088 if (ost->video_resample)
3089 sws_freeContext(ost->img_resample_ctx);
3090 swr_free(&ost->swr);
3091 av_dict_free(&ost->opts);
3098 static int opt_frame_crop(const char *opt, const char *arg)
3100 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3101 return AVERROR(EINVAL);
3104 static int opt_pad(const char *opt, const char *arg)
3106 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3110 static double parse_frame_aspect_ratio(const char *arg)
3117 p = strchr(arg, ':');
3119 x = strtol(arg, &end, 10);
3121 y = strtol(end + 1, &end, 10);
3123 ar = (double)x / (double)y;
3125 ar = strtod(arg, NULL);
3128 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
3134 static int opt_video_channel(const char *opt, const char *arg)
3136 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3137 return opt_default("channel", arg);
3140 static int opt_video_standard(const char *opt, const char *arg)
3142 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3143 return opt_default("standard", arg);
3146 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3148 audio_codec_name = arg;
3149 return parse_option(o, "codec:a", arg, options);
3152 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3154 video_codec_name = arg;
3155 return parse_option(o, "codec:v", arg, options);
3158 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3160 subtitle_codec_name = arg;
3161 return parse_option(o, "codec:s", arg, options);
3164 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3166 return parse_option(o, "codec:d", arg, options);
3169 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3171 StreamMap *m = NULL;
3172 int i, negative = 0, file_idx;
3173 int sync_file_idx = -1, sync_stream_idx = 0;
3181 map = av_strdup(arg);
3183 /* parse sync stream first, just pick first matching stream */
3184 if (sync = strchr(map, ',')) {
3186 sync_file_idx = strtol(sync + 1, &sync, 0);
3187 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3188 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3193 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
3194 if (check_stream_specifier(input_files[sync_file_idx].ctx,
3195 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
3196 sync_stream_idx = i;
3199 if (i == input_files[sync_file_idx].nb_streams) {
3200 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3201 "match any streams.\n", arg);
3207 file_idx = strtol(map, &p, 0);
3208 if (file_idx >= nb_input_files || file_idx < 0) {
3209 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3213 /* disable some already defined maps */
3214 for (i = 0; i < o->nb_stream_maps; i++) {
3215 m = &o->stream_maps[i];
3216 if (file_idx == m->file_index &&
3217 check_stream_specifier(input_files[m->file_index].ctx,
3218 input_files[m->file_index].ctx->streams[m->stream_index],
3219 *p == ':' ? p + 1 : p) > 0)
3223 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3224 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3225 *p == ':' ? p + 1 : p) <= 0)
3227 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3228 &o->nb_stream_maps, o->nb_stream_maps + 1);
3229 m = &o->stream_maps[o->nb_stream_maps - 1];
3231 m->file_index = file_idx;
3232 m->stream_index = i;
3234 if (sync_file_idx >= 0) {
3235 m->sync_file_index = sync_file_idx;
3236 m->sync_stream_index = sync_stream_idx;
3238 m->sync_file_index = file_idx;
3239 m->sync_stream_index = i;
3244 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3252 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3254 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3255 &o->nb_attachments, o->nb_attachments + 1);
3256 o->attachments[o->nb_attachments - 1] = arg;
3260 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3266 o->audio_channel_maps =
3267 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3268 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3269 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3271 /* muted channel syntax */
3272 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3273 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3274 m->file_idx = m->stream_idx = -1;
3276 m->ofile_idx = m->ostream_idx = -1;
3281 n = sscanf(arg, "%d.%d.%d:%d.%d",
3282 &m->file_idx, &m->stream_idx, &m->channel_idx,
3283 &m->ofile_idx, &m->ostream_idx);
3285 if (n != 3 && n != 5) {
3286 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3287 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3291 if (n != 5) // only file.stream.channel specified
3292 m->ofile_idx = m->ostream_idx = -1;
3295 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3296 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3300 if (m->stream_idx < 0 ||
3301 m->stream_idx >= input_files[m->file_idx].nb_streams) {
3302 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3303 m->file_idx, m->stream_idx);
3306 st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3307 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3308 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3309 m->file_idx, m->stream_idx);
3312 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3313 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3314 m->file_idx, m->stream_idx, m->channel_idx);
3321 * Parse a metadata specifier in arg.
3322 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3323 * @param index for type c/p, chapter/program index is written here
3324 * @param stream_spec for type s, the stream specifier is written here
3326 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3334 if (*(++arg) && *arg != ':') {
3335 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3338 *stream_spec = *arg == ':' ? arg + 1 : "";
3342 if (*(++arg) == ':')
3343 *index = strtol(++arg, NULL, 0);
3346 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3353 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3355 AVDictionary **meta_in = NULL;
3356 AVDictionary **meta_out = NULL;
3358 char type_in, type_out;
3359 const char *istream_spec = NULL, *ostream_spec = NULL;
3360 int idx_in = 0, idx_out = 0;
3362 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3363 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3365 if (type_in == 'g' || type_out == 'g')
3366 o->metadata_global_manual = 1;
3367 if (type_in == 's' || type_out == 's')
3368 o->metadata_streams_manual = 1;
3369 if (type_in == 'c' || type_out == 'c')
3370 o->metadata_chapters_manual = 1;
3372 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3373 if ((index) < 0 || (index) >= (nb_elems)) {\
3374 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3379 #define SET_DICT(type, meta, context, index)\
3382 meta = &context->metadata;\
3385 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3386 meta = &context->chapters[index]->metadata;\
3389 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3390 meta = &context->programs[index]->metadata;\
3394 SET_DICT(type_in, meta_in, ic, idx_in);
3395 SET_DICT(type_out, meta_out, oc, idx_out);
3397 /* for input streams choose first matching stream */
3398 if (type_in == 's') {
3399 for (i = 0; i < ic->nb_streams; i++) {
3400 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3401 meta_in = &ic->streams[i]->metadata;
3407 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3412 if (type_out == 's') {
3413 for (i = 0; i < oc->nb_streams; i++) {
3414 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3415 meta_out = &oc->streams[i]->metadata;
3416 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3421 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3426 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3429 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3430 struct tm time = *gmtime((time_t*)&recording_timestamp);
3431 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3432 parse_option(o, "metadata", buf, options);
3434 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3435 "tag instead.\n", opt);
3439 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3441 const char *codec_string = encoder ? "encoder" : "decoder";
3445 avcodec_find_encoder_by_name(name) :
3446 avcodec_find_decoder_by_name(name);
3448 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3451 if (codec->type != type) {
3452 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3458 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3460 char *codec_name = NULL;
3462 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3464 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3465 st->codec->codec_id = codec->id;
3468 return avcodec_find_decoder(st->codec->codec_id);
3472 * Add all the streams from the given input file to the global
3473 * list of input streams.
3475 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3478 char *next, *codec_tag = NULL;
3480 for (i = 0; i < ic->nb_streams; i++) {
3481 AVStream *st = ic->streams[i];
3482 AVCodecContext *dec = st->codec;
3485 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3486 ist = &input_streams[nb_input_streams - 1];
3488 ist->file_index = nb_input_files;
3490 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3492 ist->ts_scale = 1.0;
3493 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3495 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3497 uint32_t tag = strtol(codec_tag, &next, 0);
3499 tag = AV_RL32(codec_tag);
3500 st->codec->codec_tag = tag;
3503 ist->dec = choose_decoder(o, ic, st);
3505 switch (dec->codec_type) {
3506 case AVMEDIA_TYPE_AUDIO:
3508 ist->dec = avcodec_find_decoder(dec->codec_id);
3509 if (o->audio_disable)
3510 st->discard = AVDISCARD_ALL;
3512 case AVMEDIA_TYPE_VIDEO:
3514 ist->dec = avcodec_find_decoder(dec->codec_id);
3516 dec->flags |= CODEC_FLAG_EMU_EDGE;
3519 if (o->video_disable)
3520 st->discard = AVDISCARD_ALL;
3521 else if (video_discard)
3522 st->discard = video_discard;
3524 case AVMEDIA_TYPE_DATA:
3525 if (o->data_disable)
3526 st->discard= AVDISCARD_ALL;
3528 case AVMEDIA_TYPE_SUBTITLE:
3530 ist->dec = avcodec_find_decoder(dec->codec_id);
3531 if(o->subtitle_disable)
3532 st->discard = AVDISCARD_ALL;
3534 case AVMEDIA_TYPE_ATTACHMENT:
3535 case AVMEDIA_TYPE_UNKNOWN:
3543 static void assert_file_overwrite(const char *filename)
3545 if ((!file_overwrite || no_file_overwrite) &&
3546 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3547 av_strstart(filename, "file:", NULL))) {
3548 if (avio_check(filename, 0) == 0) {
3549 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3550 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3553 signal(SIGINT, SIG_DFL);
3554 if (!read_yesno()) {
3555 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3561 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3568 static void dump_attachment(AVStream *st, const char *filename)
3571 AVIOContext *out = NULL;
3572 AVDictionaryEntry *e;
3574 if (!st->codec->extradata_size) {
3575 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3576 nb_input_files - 1, st->index);
3579 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3580 filename = e->value;
3582 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3583 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3587 assert_file_overwrite(filename);
3589 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3590 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3595 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3600 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3602 AVFormatContext *ic;
3603 AVInputFormat *file_iformat = NULL;
3607 AVDictionary **opts;
3608 int orig_nb_streams; // number of streams before avformat_find_stream_info
3611 if (!(file_iformat = av_find_input_format(o->format))) {
3612 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3617 if (!strcmp(filename, "-"))
3620 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3621 !strcmp(filename, "/dev/stdin");
3623 /* get default parameters from command line */
3624 ic = avformat_alloc_context();
3626 print_error(filename, AVERROR(ENOMEM));
3629 if (o->nb_audio_sample_rate) {
3630 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3631 av_dict_set(&format_opts, "sample_rate", buf, 0);
3633 if (o->nb_audio_channels) {
3634 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3635 av_dict_set(&format_opts, "channels", buf, 0);
3637 if (o->nb_frame_rates) {
3638 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3640 if (o->nb_frame_sizes) {
3641 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3643 if (o->nb_frame_pix_fmts)
3644 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3646 ic->video_codec_id = video_codec_name ?
3647 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3648 ic->audio_codec_id = audio_codec_name ?
3649 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3650 ic->subtitle_codec_id= subtitle_codec_name ?
3651 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3652 ic->flags |= AVFMT_FLAG_NONBLOCK;
3653 ic->interrupt_callback = int_cb;
3656 av_log(NULL, AV_LOG_WARNING,
3657 "-loop_input is deprecated, use -loop 1\n"
3658 "Note, both loop options only work with -f image2\n"
3660 ic->loop_input = loop_input;
3663 /* open the input file with generic avformat function */
3664 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3666 print_error(filename, err);
3669 assert_avoptions(format_opts);
3671 /* apply forced codec ids */
3672 for (i = 0; i < ic->nb_streams; i++)
3673 choose_decoder(o, ic, ic->streams[i]);
3675 /* Set AVCodecContext options for avformat_find_stream_info */
3676 opts = setup_find_stream_info_opts(ic, codec_opts);
3677 orig_nb_streams = ic->nb_streams;
3679 /* If not enough info to get the stream parameters, we decode the
3680 first frames to get it. (used in mpeg case for example) */
3681 ret = avformat_find_stream_info(ic, opts);
3683 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3684 avformat_close_input(&ic);
3688 timestamp = o->start_time;
3689 /* add the stream start time */
3690 if (ic->start_time != AV_NOPTS_VALUE)
3691 timestamp += ic->start_time;
3693 /* if seeking requested, we execute it */
3694 if (o->start_time != 0) {
3695 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3697 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3698 filename, (double)timestamp / AV_TIME_BASE);
3702 /* update the current parameters so that they match the one of the input stream */
3703 add_input_streams(o, ic);
3705 /* dump the file content */
3706 av_dump_format(ic, nb_input_files, filename, 0);
3708 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3709 input_files[nb_input_files - 1].ctx = ic;
3710 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3711 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3712 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3713 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3715 for (i = 0; i < o->nb_dump_attachment; i++) {
3718 for (j = 0; j < ic->nb_streams; j++) {
3719 AVStream *st = ic->streams[j];
3721 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3722 dump_attachment(st, o->dump_attachment[i].u.str);
3726 for (i = 0; i < orig_nb_streams; i++)
3727 av_dict_free(&opts[i]);
3730 reset_options(o, 1);
3734 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3739 for (p = kf; *p; p++)
3742 ost->forced_kf_count = n;
3743 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3744 if (!ost->forced_kf_pts) {
3745 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3748 for (i = 0; i < n; i++) {
3749 p = i ? strchr(p, ',') + 1 : kf;
3750 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3754 static uint8_t *get_line(AVIOContext *s)
3760 if (avio_open_dyn_buf(&line) < 0) {
3761 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3765 while ((c = avio_r8(s)) && c != '\n')
3768 avio_close_dyn_buf(line, &buf);
3773 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3776 char filename[1000];
3777 const char *base[3] = { getenv("AVCONV_DATADIR"),
3782 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3786 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3787 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3788 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3791 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3792 i != 1 ? "" : "/.avconv", preset_name);
3793 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3799 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3801 char *codec_name = NULL;
3803 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3805 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3806 NULL, ost->st->codec->codec_type);
3807 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3808 } else if (!strcmp(codec_name, "copy"))
3809 ost->stream_copy = 1;
3811 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3812 ost->st->codec->codec_id = ost->enc->id;
3816 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3819 AVStream *st = avformat_new_stream(oc, NULL);
3820 int idx = oc->nb_streams - 1, ret = 0;
3821 char *bsf = NULL, *next, *codec_tag = NULL;
3822 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3824 char *buf = NULL, *arg = NULL, *preset = NULL;
3825 AVIOContext *s = NULL;
3828 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3832 if (oc->nb_streams - 1 < o->nb_streamid_map)
3833 st->id = o->streamid_map[oc->nb_streams - 1];
3835 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3836 nb_output_streams + 1);
3837 ost = &output_streams[nb_output_streams - 1];
3838 ost->file_index = nb_output_files;
3841 st->codec->codec_type = type;
3842 choose_encoder(o, oc, ost);
3844 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3847 avcodec_get_context_defaults3(st->codec, ost->enc);
3848 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3850 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3851 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3854 if (!buf[0] || buf[0] == '#') {
3858 if (!(arg = strchr(buf, '='))) {
3859 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3863 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3865 } while (!s->eof_reached);
3869 av_log(NULL, AV_LOG_FATAL,
3870 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3871 preset, ost->file_index, ost->index);
3875 ost->max_frames = INT64_MAX;
3876 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3878 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3880 if (next = strchr(bsf, ','))
3882 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3883 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3887 bsfc_prev->next = bsfc;
3889 ost->bitstream_filters = bsfc;
3895 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3897 uint32_t tag = strtol(codec_tag, &next, 0);
3899 tag = AV_RL32(codec_tag);
3900 st->codec->codec_tag = tag;
3903 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3904 if (qscale >= 0 || same_quant) {
3905 st->codec->flags |= CODEC_FLAG_QSCALE;
3906 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3909 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3910 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3912 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3916 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3919 const char *p = str;
3926 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3933 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3937 AVCodecContext *video_enc;
3939 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3941 video_enc = st->codec;
3943 if (!ost->stream_copy) {
3944 const char *p = NULL;
3945 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3946 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3947 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3950 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3951 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3952 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3956 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3957 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3958 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3962 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3963 if (frame_aspect_ratio)
3964 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3966 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3967 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3968 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3969 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3972 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3975 video_enc->gop_size = 0;
3976 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3978 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3979 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3982 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3984 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3986 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3987 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3990 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3993 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3994 for (i = 0; p; i++) {
3996 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3998 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4001 /* FIXME realloc failure */
4002 video_enc->rc_override =
4003 av_realloc(video_enc->rc_override,
4004 sizeof(RcOverride) * (i + 1));
4005 video_enc->rc_override[i].start_frame = start;
4006 video_enc->rc_override[i].end_frame = end;
4008 video_enc->rc_override[i].qscale = q;
4009 video_enc->rc_override[i].quality_factor = 1.0;
4012 video_enc->rc_override[i].qscale = 0;
4013 video_enc->rc_override[i].quality_factor = -q/100.0;
4018 video_enc->rc_override_count = i;
4019 if (!video_enc->rc_initial_buffer_occupancy)
4020 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4021 video_enc->intra_dc_precision = intra_dc_precision - 8;
4024 video_enc->flags|= CODEC_FLAG_PSNR;
4029 video_enc->flags |= CODEC_FLAG_PASS1;
4032 video_enc->flags |= CODEC_FLAG_PASS2;
4036 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4037 if (forced_key_frames)
4038 parse_forced_key_frames(forced_key_frames, ost);
4040 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4042 ost->top_field_first = -1;
4043 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4045 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4048 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4050 ost->avfilter = av_strdup(filters);
4057 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
4062 AVCodecContext *audio_enc;
4064 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
4067 audio_enc = st->codec;
4068 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4070 if (!ost->stream_copy) {
4071 char *sample_fmt = NULL;
4073 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4075 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4077 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4078 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4082 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4084 ost->rematrix_volume=1.0;
4085 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4088 /* check for channel mapping for this audio stream */
4089 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4090 AudioChannelMap *map = &o->audio_channel_maps[n];
4091 InputStream *ist = &input_streams[ost->source_index];
4092 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4093 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4094 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4095 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4096 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4098 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4099 ost->file_index, ost->st->index);
4106 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
4110 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
4111 if (!ost->stream_copy) {
4112 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4119 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
4121 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
4122 ost->stream_copy = 1;
4126 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
4130 AVCodecContext *subtitle_enc;
4132 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
4134 subtitle_enc = st->codec;
4136 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4141 /* arg format is "output-stream-index:streamid-value". */
4142 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4148 av_strlcpy(idx_str, arg, sizeof(idx_str));
4149 p = strchr(idx_str, ':');
4151 av_log(NULL, AV_LOG_FATAL,
4152 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4157 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4158 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4159 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4163 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4165 AVFormatContext *is = ifile->ctx;
4166 AVFormatContext *os = ofile->ctx;
4169 for (i = 0; i < is->nb_chapters; i++) {
4170 AVChapter *in_ch = is->chapters[i], *out_ch;
4171 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4172 AV_TIME_BASE_Q, in_ch->time_base);
4173 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4174 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4177 if (in_ch->end < ts_off)
4179 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4182 out_ch = av_mallocz(sizeof(AVChapter));
4184 return AVERROR(ENOMEM);
4186 out_ch->id = in_ch->id;
4187 out_ch->time_base = in_ch->time_base;
4188 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4189 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4192 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4195 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4197 return AVERROR(ENOMEM);
4198 os->chapters[os->nb_chapters - 1] = out_ch;
4203 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4206 AVFormatContext *ic = avformat_alloc_context();
4208 ic->interrupt_callback = int_cb;
4209 err = avformat_open_input(&ic, filename, NULL, NULL);
4212 /* copy stream format */
4213 for(i=0;i<ic->nb_streams;i++) {
4217 AVCodecContext *avctx;
4219 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4220 ost = new_output_stream(o, s, codec->type);
4225 // FIXME: a more elegant solution is needed
4226 memcpy(st, ic->streams[i], sizeof(AVStream));
4227 st->info = av_malloc(sizeof(*st->info));
4228 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4230 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4232 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4233 choose_sample_fmt(st, codec);
4234 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4235 choose_pixel_fmt(st, codec);
4238 avformat_close_input(&ic);
4242 static void opt_output_file(void *optctx, const char *filename)
4244 OptionsContext *o = optctx;
4245 AVFormatContext *oc;
4247 AVOutputFormat *file_oformat;
4251 if (!strcmp(filename, "-"))
4254 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4256 print_error(filename, err);
4259 file_oformat= oc->oformat;
4260 oc->interrupt_callback = int_cb;
4262 if (!strcmp(file_oformat->name, "ffm") &&
4263 av_strstart(filename, "http:", NULL)) {
4265 /* special case for files sent to ffserver: we get the stream
4266 parameters from ffserver */
4267 int err = read_ffserver_streams(o, oc, filename);
4269 print_error(filename, err);
4272 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4273 ost = &output_streams[j];
4274 for (i = 0; i < nb_input_streams; i++) {
4275 ist = &input_streams[i];
4276 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4278 ost->source_index= i;
4284 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));
4288 } else if (!o->nb_stream_maps) {
4289 /* pick the "best" stream of each type */
4290 #define NEW_STREAM(type, index)\
4292 ost = new_ ## type ## _stream(o, oc);\
4293 ost->source_index = index;\
4294 ost->sync_ist = &input_streams[index];\
4295 input_streams[index].discard = 0;\
4298 /* video: highest resolution */
4299 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4300 int area = 0, idx = -1;
4301 for (i = 0; i < nb_input_streams; i++) {
4302 ist = &input_streams[i];
4303 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4304 ist->st->codec->width * ist->st->codec->height > area) {
4305 area = ist->st->codec->width * ist->st->codec->height;
4309 NEW_STREAM(video, idx);
4312 /* audio: most channels */
4313 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4314 int channels = 0, idx = -1;
4315 for (i = 0; i < nb_input_streams; i++) {
4316 ist = &input_streams[i];
4317 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4318 ist->st->codec->channels > channels) {
4319 channels = ist->st->codec->channels;
4323 NEW_STREAM(audio, idx);
4326 /* subtitles: pick first */
4327 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4328 for (i = 0; i < nb_input_streams; i++)
4329 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4330 NEW_STREAM(subtitle, i);
4334 /* do something with data? */
4336 for (i = 0; i < o->nb_stream_maps; i++) {
4337 StreamMap *map = &o->stream_maps[i];
4342 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4343 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4345 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4347 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4349 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4352 switch (ist->st->codec->codec_type) {
4353 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4354 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4355 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4356 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4357 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4359 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4360 map->file_index, map->stream_index);
4364 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4365 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4366 map->sync_stream_index];
4371 /* handle attached files */
4372 for (i = 0; i < o->nb_attachments; i++) {
4374 uint8_t *attachment;
4378 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4379 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4383 if ((len = avio_size(pb)) <= 0) {
4384 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4388 if (!(attachment = av_malloc(len))) {
4389 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4393 avio_read(pb, attachment, len);
4395 ost = new_attachment_stream(o, oc);
4396 ost->stream_copy = 0;
4397 ost->source_index = -1;
4398 ost->attachment_filename = o->attachments[i];
4399 ost->st->codec->extradata = attachment;
4400 ost->st->codec->extradata_size = len;
4402 p = strrchr(o->attachments[i], '/');
4403 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4407 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4408 output_files[nb_output_files - 1].ctx = oc;
4409 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4410 output_files[nb_output_files - 1].recording_time = o->recording_time;
4411 output_files[nb_output_files - 1].start_time = o->start_time;
4412 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4413 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4415 /* check filename in case of an image number is expected */
4416 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4417 if (!av_filename_number_test(oc->filename)) {
4418 print_error(oc->filename, AVERROR(EINVAL));
4423 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4424 /* test if it already exists to avoid losing precious files */
4425 assert_file_overwrite(filename);
4428 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4429 &oc->interrupt_callback,
4430 &output_files[nb_output_files - 1].opts)) < 0) {
4431 print_error(filename, err);
4436 if (o->mux_preload) {
4438 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4439 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4441 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4443 if (loop_output >= 0) {
4444 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4445 oc->loop_output = loop_output;
4449 for (i = 0; i < o->nb_metadata_map; i++) {
4451 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4453 if (in_file_index < 0)
4455 if (in_file_index >= nb_input_files) {
4456 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4459 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4463 if (o->chapters_input_file >= nb_input_files) {
4464 if (o->chapters_input_file == INT_MAX) {
4465 /* copy chapters from the first input file that has them*/
4466 o->chapters_input_file = -1;
4467 for (i = 0; i < nb_input_files; i++)
4468 if (input_files[i].ctx->nb_chapters) {
4469 o->chapters_input_file = i;
4473 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4474 o->chapters_input_file);
4478 if (o->chapters_input_file >= 0)
4479 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4480 !o->metadata_chapters_manual);
4482 /* copy global metadata by default */
4483 if (!o->metadata_global_manual && nb_input_files){
4484 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4485 AV_DICT_DONT_OVERWRITE);
4486 if(o->recording_time != INT64_MAX)
4487 av_dict_set(&oc->metadata, "duration", NULL, 0);
4489 if (!o->metadata_streams_manual)
4490 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4492 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4494 ist = &input_streams[output_streams[i].source_index];
4495 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4498 /* process manually set metadata */
4499 for (i = 0; i < o->nb_metadata; i++) {
4502 const char *stream_spec;
4503 int index = 0, j, ret = 0;
4505 val = strchr(o->metadata[i].u.str, '=');
4507 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4508 o->metadata[i].u.str);
4513 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4515 for (j = 0; j < oc->nb_streams; j++) {
4516 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4517 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4521 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4529 if (index < 0 || index >= oc->nb_chapters) {
4530 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4533 m = &oc->chapters[index]->metadata;
4536 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4539 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4543 reset_options(o, 0);
4546 /* same option as mencoder */
4547 static int opt_pass(const char *opt, const char *arg)
4549 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4553 static int64_t getutime(void)
4556 struct rusage rusage;
4558 getrusage(RUSAGE_SELF, &rusage);
4559 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4560 #elif HAVE_GETPROCESSTIMES
4562 FILETIME c, e, k, u;
4563 proc = GetCurrentProcess();
4564 GetProcessTimes(proc, &c, &e, &k, &u);
4565 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4567 return av_gettime();
4571 static int64_t getmaxrss(void)
4573 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4574 struct rusage rusage;
4575 getrusage(RUSAGE_SELF, &rusage);
4576 return (int64_t)rusage.ru_maxrss * 1024;
4577 #elif HAVE_GETPROCESSMEMORYINFO
4579 PROCESS_MEMORY_COUNTERS memcounters;
4580 proc = GetCurrentProcess();
4581 memcounters.cb = sizeof(memcounters);
4582 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4583 return memcounters.PeakPagefileUsage;
4589 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4591 return parse_option(o, "q:a", arg, options);
4594 static void show_usage(void)
4596 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
4597 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4598 av_log(NULL, AV_LOG_INFO, "\n");
4601 static int opt_help(const char *opt, const char *arg)
4603 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4604 av_log_set_callback(log_callback_help);
4606 show_help_options(options, "Main options:\n",
4607 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4608 show_help_options(options, "\nAdvanced options:\n",
4609 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4611 show_help_options(options, "\nVideo options:\n",
4612 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4614 show_help_options(options, "\nAdvanced Video options:\n",
4615 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4616 OPT_VIDEO | OPT_EXPERT);
4617 show_help_options(options, "\nAudio options:\n",
4618 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4620 show_help_options(options, "\nAdvanced Audio options:\n",
4621 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4622 OPT_AUDIO | OPT_EXPERT);
4623 show_help_options(options, "\nSubtitle options:\n",
4624 OPT_SUBTITLE | OPT_GRAB,
4626 show_help_options(options, "\nAudio/Video grab options:\n",
4630 show_help_children(avcodec_get_class(), flags);
4631 show_help_children(avformat_get_class(), flags);
4632 show_help_children(sws_get_class(), flags);
4637 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4639 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4640 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4642 if (!strncmp(arg, "pal-", 4)) {
4645 } else if (!strncmp(arg, "ntsc-", 5)) {
4648 } else if (!strncmp(arg, "film-", 5)) {
4652 /* Try to determine PAL/NTSC by peeking in the input files */
4653 if (nb_input_files) {
4655 for (j = 0; j < nb_input_files; j++) {
4656 for (i = 0; i < input_files[j].nb_streams; i++) {
4657 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4658 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4660 fr = c->time_base.den * 1000 / c->time_base.num;
4664 } else if ((fr == 29970) || (fr == 23976)) {
4669 if (norm != UNKNOWN)
4673 if (norm != UNKNOWN)
4674 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4677 if (norm == UNKNOWN) {
4678 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4679 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4680 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4684 if (!strcmp(arg, "vcd")) {
4685 opt_video_codec(o, "c:v", "mpeg1video");
4686 opt_audio_codec(o, "c:a", "mp2");
4687 parse_option(o, "f", "vcd", options);
4689 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4690 parse_option(o, "r", frame_rates[norm], options);
4691 opt_default("g", norm == PAL ? "15" : "18");
4693 opt_default("b:v", "1150000");
4694 opt_default("maxrate", "1150000");
4695 opt_default("minrate", "1150000");
4696 opt_default("bufsize", "327680"); // 40*1024*8;
4698 opt_default("b:a", "224000");
4699 parse_option(o, "ar", "44100", options);
4700 parse_option(o, "ac", "2", options);
4702 opt_default("packetsize", "2324");
4703 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4705 /* We have to offset the PTS, so that it is consistent with the SCR.
4706 SCR starts at 36000, but the first two packs contain only padding
4707 and the first pack from the other stream, respectively, may also have
4708 been written before.
4709 So the real data starts at SCR 36000+3*1200. */
4710 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4711 } else if (!strcmp(arg, "svcd")) {
4713 opt_video_codec(o, "c:v", "mpeg2video");
4714 opt_audio_codec(o, "c:a", "mp2");
4715 parse_option(o, "f", "svcd", options);
4717 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4718 parse_option(o, "r", frame_rates[norm], options);
4719 parse_option(o, "pix_fmt", "yuv420p", options);
4720 opt_default("g", norm == PAL ? "15" : "18");
4722 opt_default("b:v", "2040000");
4723 opt_default("maxrate", "2516000");
4724 opt_default("minrate", "0"); // 1145000;
4725 opt_default("bufsize", "1835008"); // 224*1024*8;
4726 opt_default("flags", "+scan_offset");
4729 opt_default("b:a", "224000");
4730 parse_option(o, "ar", "44100", options);
4732 opt_default("packetsize", "2324");
4734 } else if (!strcmp(arg, "dvd")) {
4736 opt_video_codec(o, "c:v", "mpeg2video");
4737 opt_audio_codec(o, "c:a", "ac3");
4738 parse_option(o, "f", "dvd", options);
4740 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4741 parse_option(o, "r", frame_rates[norm], options);
4742 parse_option(o, "pix_fmt", "yuv420p", options);
4743 opt_default("g", norm == PAL ? "15" : "18");
4745 opt_default("b:v", "6000000");
4746 opt_default("maxrate", "9000000");
4747 opt_default("minrate", "0"); // 1500000;
4748 opt_default("bufsize", "1835008"); // 224*1024*8;
4750 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4751 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4753 opt_default("b:a", "448000");
4754 parse_option(o, "ar", "48000", options);
4756 } else if (!strncmp(arg, "dv", 2)) {
4758 parse_option(o, "f", "dv", options);
4760 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4761 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4762 norm == PAL ? "yuv420p" : "yuv411p", options);
4763 parse_option(o, "r", frame_rates[norm], options);
4765 parse_option(o, "ar", "48000", options);
4766 parse_option(o, "ac", "2", options);
4769 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4770 return AVERROR(EINVAL);
4775 static int opt_vstats_file(const char *opt, const char *arg)
4777 av_free (vstats_filename);
4778 vstats_filename = av_strdup (arg);
4782 static int opt_vstats(const char *opt, const char *arg)
4785 time_t today2 = time(NULL);
4786 struct tm *today = localtime(&today2);
4788 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4790 return opt_vstats_file(opt, filename);
4793 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4795 return parse_option(o, "frames:v", arg, options);
4798 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4800 return parse_option(o, "frames:a", arg, options);
4803 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4805 return parse_option(o, "frames:d", arg, options);
4808 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4811 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4812 const char *codec_name = *opt == 'v' ? video_codec_name :
4813 *opt == 'a' ? audio_codec_name :
4814 subtitle_codec_name;
4816 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4817 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4818 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4820 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4825 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4826 if(line[0] == '#' && !e)
4828 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4830 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4833 if(!strcmp(tmp, "acodec")){
4834 opt_audio_codec(o, tmp, tmp2);
4835 }else if(!strcmp(tmp, "vcodec")){
4836 opt_video_codec(o, tmp, tmp2);
4837 }else if(!strcmp(tmp, "scodec")){
4838 opt_subtitle_codec(o, tmp, tmp2);
4839 }else if(!strcmp(tmp, "dcodec")){
4840 opt_data_codec(o, tmp, tmp2);
4841 }else if(opt_default(tmp, tmp2) < 0){
4842 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4852 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4856 static int opt_passlogfile(const char *opt, const char *arg)
4858 pass_logfilename_prefix = arg;
4859 #if CONFIG_LIBX264_ENCODER
4860 return opt_default("passlogfile", arg);
4866 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4868 char *s= av_malloc(strlen(opt)+2);
4869 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4870 return parse_option(o, s, arg, options);
4873 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4875 if(!strcmp(opt, "b")){
4876 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4877 return parse_option(o, av_strdup("b:v"), arg, options);
4879 return opt_default(opt, arg);
4882 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4884 return parse_option(o, "filter:v", arg, options);
4887 static int opt_vsync(const char *opt, const char *arg)
4889 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
4890 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
4891 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4893 if (video_sync_method == VSYNC_AUTO)
4894 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4898 #define OFFSET(x) offsetof(OptionsContext, x)
4899 static const OptionDef options[] = {
4901 #include "cmdutils_common_opts.h"
4902 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4903 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4904 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4905 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4906 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4907 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4908 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4909 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4910 { "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]" },
4911 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4912 "outfile[,metadata]:infile[,metadata]" },
4913 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4914 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4915 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4916 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4917 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4918 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4919 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4920 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4921 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4922 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4923 "add timings for benchmarking" },
4924 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4925 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4926 "dump each input packet" },
4927 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4928 "when dumping packets, also dump the payload" },
4929 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4930 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4931 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4932 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4933 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4934 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4935 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4936 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4937 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
4938 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4939 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4940 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4941 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4942 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4943 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4944 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4945 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4947 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4949 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4950 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4951 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4954 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4955 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4956 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4957 { "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" },
4958 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4959 { "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" },
4960 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4961 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4962 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4963 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4964 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4965 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4966 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4967 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4968 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4969 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4970 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4971 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4972 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4973 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4974 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4975 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4976 "use same quantizer as source (implies VBR)" },
4977 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4978 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4979 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4980 "deinterlace pictures" },
4981 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4982 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4983 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4985 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4987 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4988 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4989 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4990 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4991 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4992 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4993 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4994 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4995 { "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" },
4996 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4999 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5000 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5001 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5002 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5003 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5004 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5005 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5006 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5007 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5008 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
5010 /* subtitle options */
5011 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5012 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5013 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5016 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5017 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5018 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5021 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5022 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5024 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5025 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5026 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5028 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5029 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5030 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5031 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5032 /* data codec support */
5033 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5034 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5036 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5040 int main(int argc, char **argv)
5042 OptionsContext o = { 0 };
5045 reset_options(&o, 0);
5047 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5048 parse_loglevel(argc, argv, options);
5050 if(argc>1 && !strcmp(argv[1], "-d")){
5052 av_log_set_callback(log_callback_null);
5057 avcodec_register_all();
5059 avdevice_register_all();
5062 avfilter_register_all();
5065 avformat_network_init();
5067 show_banner(argc, argv, options);
5072 parse_options(&o, argc, argv, options, opt_output_file);
5074 if (nb_output_files <= 0 && nb_input_files == 0) {
5076 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5080 /* file converter / grab */
5081 if (nb_output_files <= 0) {
5082 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5086 if (nb_input_files == 0) {
5087 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5092 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
5094 ti = getutime() - ti;
5096 int maxrss = getmaxrss() / 1024;
5097 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);