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;
1025 int size_out, 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 av_opt_set_int(ost->swr, "ich", dec->channels, 0);
1100 av_opt_set_int(ost->swr, "och", enc->channels, 0);
1101 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
1102 if(ost->swr && swr_init(ost->swr) < 0){
1103 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
1104 swr_free(&ost->swr);
1108 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1109 dec->channels, dec->sample_rate,
1110 enc->channels, enc->sample_rate);
1116 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1118 if (audio_sync_method) {
1119 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts -
1120 av_fifo_size(ost->fifo) / (enc->channels * osize);
1121 int idelta = delta * dec->sample_rate / enc->sample_rate;
1122 int byte_delta = idelta * isize * dec->channels;
1124 // FIXME resample delay
1125 if (fabs(delta) > 50) {
1126 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1127 if (byte_delta < 0) {
1128 byte_delta = FFMAX(byte_delta, -size);
1131 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1132 -byte_delta / (isize * dec->channels));
1137 input_tmp = av_realloc(input_tmp, byte_delta + size);
1139 if (byte_delta > allocated_for_size - size) {
1140 allocated_for_size = byte_delta + (int64_t)size;
1145 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
1146 memcpy(input_tmp + byte_delta, buf, size);
1149 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1151 } else if (audio_sync_method > 1) {
1152 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1153 av_assert0(ost->audio_resample);
1154 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1155 delta, comp, enc->sample_rate);
1156 // 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));
1157 swr_compensate(ost->swr, comp, enc->sample_rate);
1161 ost->sync_opts = lrintf(get_sync_ipts(ost) * enc->sample_rate) -
1162 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1164 if (ost->audio_resample) {
1166 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
1167 (const uint8_t*[]){buf }, size / (dec->channels * isize));
1168 size_out = size_out * enc->channels * osize;
1174 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1176 /* now encode as many frames as possible */
1177 if (enc->frame_size > 1) {
1178 /* output resampled raw samples */
1179 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1180 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1183 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1185 frame_bytes = enc->frame_size * osize * enc->channels;
1187 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1189 av_init_packet(&pkt);
1191 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1193 // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1195 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
1196 (short *)audio_buf);
1198 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1202 pkt.stream_index = ost->index;
1203 pkt.data = audio_out;
1205 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1206 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1207 pkt.flags |= AV_PKT_FLAG_KEY;
1208 write_frame(s, &pkt, ost);
1210 ost->sync_opts += enc->frame_size;
1214 av_init_packet(&pkt);
1216 ost->sync_opts += size_out / (osize * enc->channels);
1218 /* output a pcm frame */
1219 /* determine the size of the coded buffer */
1222 size_out = size_out * coded_bps / 8;
1224 if (size_out > audio_out_size) {
1225 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
1229 // FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
1230 ret = avcodec_encode_audio(enc, audio_out, size_out,
1233 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1237 pkt.stream_index = ost->index;
1238 pkt.data = audio_out;
1240 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1241 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1242 pkt.flags |= AV_PKT_FLAG_KEY;
1243 write_frame(s, &pkt, ost);
1247 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1249 AVCodecContext *dec;
1250 AVPicture *picture2;
1251 AVPicture picture_tmp;
1254 dec = ist->st->codec;
1256 /* deinterlace : must be done before any resize */
1257 if (do_deinterlace) {
1260 /* create temporary picture */
1261 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1262 buf = av_malloc(size);
1266 picture2 = &picture_tmp;
1267 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1269 if (avpicture_deinterlace(picture2, picture,
1270 dec->pix_fmt, dec->width, dec->height) < 0) {
1271 /* if error, do not deinterlace */
1272 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1281 if (picture != picture2)
1282 *picture = *picture2;
1286 static void do_subtitle_out(AVFormatContext *s,
1292 static uint8_t *subtitle_out = NULL;
1293 int subtitle_out_max_size = 1024 * 1024;
1294 int subtitle_out_size, nb, i;
1295 AVCodecContext *enc;
1298 if (pts == AV_NOPTS_VALUE) {
1299 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1305 enc = ost->st->codec;
1307 if (!subtitle_out) {
1308 subtitle_out = av_malloc(subtitle_out_max_size);
1311 /* Note: DVB subtitle need one packet to draw them and one other
1312 packet to clear them */
1313 /* XXX: signal it in the codec context ? */
1314 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1319 for (i = 0; i < nb; i++) {
1320 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1321 // start_display_time is required to be 0
1322 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1323 sub->end_display_time -= sub->start_display_time;
1324 sub->start_display_time = 0;
1325 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1326 subtitle_out_max_size, sub);
1327 if (subtitle_out_size < 0) {
1328 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1332 av_init_packet(&pkt);
1333 pkt.stream_index = ost->index;
1334 pkt.data = subtitle_out;
1335 pkt.size = subtitle_out_size;
1336 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1337 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1338 /* XXX: the pts correction is handled here. Maybe handling
1339 it in the codec would be better */
1341 pkt.pts += 90 * sub->start_display_time;
1343 pkt.pts += 90 * sub->end_display_time;
1345 write_frame(s, &pkt, ost);
1349 static int bit_buffer_size = 1024 * 256;
1350 static uint8_t *bit_buffer = NULL;
1352 static void do_video_resample(OutputStream *ost,
1354 AVFrame *in_picture,
1355 AVFrame **out_picture)
1358 *out_picture = in_picture;
1360 AVCodecContext *dec = ist->st->codec;
1361 AVCodecContext *enc = ost->st->codec;
1362 int resample_changed = ost->resample_width != dec->width ||
1363 ost->resample_height != dec->height ||
1364 ost->resample_pix_fmt != dec->pix_fmt;
1366 *out_picture = in_picture;
1367 if (resample_changed) {
1368 av_log(NULL, AV_LOG_INFO,
1369 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1370 ist->file_index, ist->st->index,
1371 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1372 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1373 ost->resample_width = dec->width;
1374 ost->resample_height = dec->height;
1375 ost->resample_pix_fmt = dec->pix_fmt;
1378 ost->video_resample = dec->width != enc->width ||
1379 dec->height != enc->height ||
1380 dec->pix_fmt != enc->pix_fmt;
1382 if (ost->video_resample) {
1383 *out_picture = &ost->resample_frame;
1384 if (!ost->img_resample_ctx || resample_changed) {
1385 /* initialize the destination picture */
1386 if (!ost->resample_frame.data[0]) {
1387 avcodec_get_frame_defaults(&ost->resample_frame);
1388 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1389 enc->width, enc->height)) {
1390 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1394 /* initialize a new scaler context */
1395 sws_freeContext(ost->img_resample_ctx);
1396 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1397 enc->width, enc->height, enc->pix_fmt,
1398 ost->sws_flags, NULL, NULL, NULL);
1399 if (ost->img_resample_ctx == NULL) {
1400 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1404 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1405 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1411 static void do_video_out(AVFormatContext *s,
1414 AVFrame *in_picture,
1415 int *frame_size, float quality)
1417 int nb_frames, i, ret, format_video_sync;
1418 AVFrame *final_picture;
1419 AVCodecContext *enc;
1421 double duration = 0;
1423 enc = ost->st->codec;
1425 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1426 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1427 if(ist->st->avg_frame_rate.num)
1428 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1430 duration /= av_q2d(enc->time_base);
1433 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1435 /* by default, we output a single frame */
1440 format_video_sync = video_sync_method;
1441 if (format_video_sync == VSYNC_AUTO)
1442 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1444 if (format_video_sync != VSYNC_PASSTHROUGH) {
1445 double vdelta = sync_ipts - ost->sync_opts + duration;
1446 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1449 else if (format_video_sync == VSYNC_VFR) {
1450 if (vdelta <= -0.6) {
1452 } else if (vdelta > 0.6)
1453 ost->sync_opts = lrintf(sync_ipts);
1454 } else if (vdelta > 1.1)
1455 nb_frames = lrintf(vdelta);
1456 //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);
1457 if (nb_frames == 0) {
1459 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1460 } else if (nb_frames > 1) {
1461 nb_frames_dup += nb_frames - 1;
1462 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1465 ost->sync_opts = lrintf(sync_ipts);
1467 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1471 do_video_resample(ost, ist, in_picture, &final_picture);
1473 /* duplicates frame if needed */
1474 for (i = 0; i < nb_frames; i++) {
1476 av_init_packet(&pkt);
1477 pkt.stream_index = ost->index;
1479 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1480 enc->codec->id == CODEC_ID_RAWVIDEO) {
1481 /* raw pictures are written as AVPicture structure to
1482 avoid any copies. We support temporarily the older
1484 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1485 enc->coded_frame->top_field_first = in_picture->top_field_first;
1486 pkt.data = (uint8_t *)final_picture;
1487 pkt.size = sizeof(AVPicture);
1488 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1489 pkt.flags |= AV_PKT_FLAG_KEY;
1491 write_frame(s, &pkt, ost);
1493 AVFrame big_picture;
1495 big_picture = *final_picture;
1496 /* better than nothing: use input picture interlaced
1498 big_picture.interlaced_frame = in_picture->interlaced_frame;
1499 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1500 if (ost->top_field_first == -1)
1501 big_picture.top_field_first = in_picture->top_field_first;
1503 big_picture.top_field_first = !!ost->top_field_first;
1506 /* handles same_quant here. This is not correct because it may
1507 not be a global option */
1508 big_picture.quality = quality;
1509 if (!enc->me_threshold)
1510 big_picture.pict_type = 0;
1511 // big_picture.pts = AV_NOPTS_VALUE;
1512 big_picture.pts = ost->sync_opts;
1513 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1514 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1515 if (ost->forced_kf_index < ost->forced_kf_count &&
1516 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1517 big_picture.pict_type = AV_PICTURE_TYPE_I;
1518 ost->forced_kf_index++;
1520 ret = avcodec_encode_video(enc,
1521 bit_buffer, bit_buffer_size,
1524 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1529 pkt.data = bit_buffer;
1531 if (enc->coded_frame->pts != AV_NOPTS_VALUE)
1532 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1533 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1534 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1535 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1537 if (enc->coded_frame->key_frame)
1538 pkt.flags |= AV_PKT_FLAG_KEY;
1539 write_frame(s, &pkt, ost);
1542 // fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1543 // enc->frame_number-1, ret, enc->pict_type);
1544 /* if two pass, output log */
1545 if (ost->logfile && enc->stats_out) {
1546 fprintf(ost->logfile, "%s", enc->stats_out);
1554 static double psnr(double d)
1556 return -10.0 * log(d) / log(10.0);
1559 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1562 AVCodecContext *enc;
1564 double ti1, bitrate, avg_bitrate;
1566 /* this is executed just the first time do_video_stats is called */
1568 vstats_file = fopen(vstats_filename, "w");
1575 enc = ost->st->codec;
1576 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1577 frame_number = ost->frame_number;
1578 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1579 if (enc->flags&CODEC_FLAG_PSNR)
1580 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1582 fprintf(vstats_file,"f_size= %6d ", frame_size);
1583 /* compute pts value */
1584 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1588 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1589 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1590 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1591 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1592 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1596 static void print_report(OutputFile *output_files,
1597 OutputStream *ost_table, int nb_ostreams,
1598 int is_last_report, int64_t timer_start, int64_t cur_time)
1602 AVFormatContext *oc;
1604 AVCodecContext *enc;
1605 int frame_number, vid, i;
1607 int64_t pts = INT64_MAX;
1608 static int64_t last_time = -1;
1609 static int qp_histogram[52];
1610 int hours, mins, secs, us;
1612 if (!print_stats && !is_last_report)
1615 if (!is_last_report) {
1616 if (last_time == -1) {
1617 last_time = cur_time;
1620 if ((cur_time - last_time) < 500000)
1622 last_time = cur_time;
1626 oc = output_files[0].ctx;
1628 total_size = avio_size(oc->pb);
1629 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
1630 total_size = avio_tell(oc->pb);
1637 for (i = 0; i < nb_ostreams; i++) {
1639 ost = &ost_table[i];
1640 enc = ost->st->codec;
1641 if (!ost->stream_copy && enc->coded_frame)
1642 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1643 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1644 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1646 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1647 float t = (cur_time-timer_start) / 1000000.0;
1649 frame_number = ost->frame_number;
1650 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1651 frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1653 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1657 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1659 for (j = 0; j < 32; j++)
1660 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1662 if (enc->flags&CODEC_FLAG_PSNR) {
1664 double error, error_sum = 0;
1665 double scale, scale_sum = 0;
1666 char type[3] = { 'Y','U','V' };
1667 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1668 for (j = 0; j < 3; j++) {
1669 if (is_last_report) {
1670 error = enc->error[j];
1671 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1673 error = enc->coded_frame->error[j];
1674 scale = enc->width * enc->height * 255.0 * 255.0;
1680 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1682 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1686 /* compute min output value */
1687 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1688 ost->st->time_base, AV_TIME_BASE_Q));
1691 secs = pts / AV_TIME_BASE;
1692 us = pts % AV_TIME_BASE;
1698 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1700 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1701 "size=%8.0fkB time=", total_size / 1024.0);
1702 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1703 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1704 (100 * us) / AV_TIME_BASE);
1705 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1706 "bitrate=%6.1fkbits/s", bitrate);
1708 if (nb_frames_dup || nb_frames_drop)
1709 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1710 nb_frames_dup, nb_frames_drop);
1712 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1716 if (is_last_report) {
1717 int64_t raw= audio_size + video_size + extra_size;
1718 av_log(NULL, AV_LOG_INFO, "\n");
1719 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1720 video_size / 1024.0,
1721 audio_size / 1024.0,
1722 extra_size / 1024.0,
1723 100.0 * (total_size - raw) / raw
1725 if(video_size + audio_size + extra_size == 0){
1726 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1731 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1735 for (i = 0; i < nb_ostreams; i++) {
1736 OutputStream *ost = &ost_table[i];
1737 AVCodecContext *enc = ost->st->codec;
1738 AVFormatContext *os = output_files[ost->file_index].ctx;
1740 if (!ost->encoding_needed)
1743 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1745 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1751 av_init_packet(&pkt);
1752 pkt.stream_index = ost->index;
1754 switch (ost->st->codec->codec_type) {
1755 case AVMEDIA_TYPE_AUDIO:
1756 fifo_bytes = av_fifo_size(ost->fifo);
1758 /* encode any samples remaining in fifo */
1759 if (fifo_bytes > 0) {
1760 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1761 int fs_tmp = enc->frame_size;
1763 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1764 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1765 enc->frame_size = fifo_bytes / (osize * enc->channels);
1767 int frame_bytes = enc->frame_size*osize*enc->channels;
1768 if (allocated_audio_buf_size < frame_bytes)
1770 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1773 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1774 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1775 ost->st->time_base.num, enc->sample_rate);
1776 enc->frame_size = fs_tmp;
1779 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1782 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1786 pkt.flags |= AV_PKT_FLAG_KEY;
1788 case AVMEDIA_TYPE_VIDEO:
1789 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1791 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1795 if (enc->coded_frame && enc->coded_frame->key_frame)
1796 pkt.flags |= AV_PKT_FLAG_KEY;
1797 if (ost->logfile && enc->stats_out) {
1798 fprintf(ost->logfile, "%s", enc->stats_out);
1807 pkt.data = bit_buffer;
1809 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1810 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1811 write_frame(os, &pkt, ost);
1817 * Check whether a packet from ist should be written into ost at this time
1819 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1821 OutputFile *of = &output_files[ost->file_index];
1822 int ist_index = ist - input_streams;
1824 if (ost->source_index != ist_index)
1827 if (of->start_time && ist->pts < of->start_time)
1830 if (of->recording_time != INT64_MAX &&
1831 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1832 (AVRational){ 1, 1000000 }) >= 0) {
1833 ost->is_past_recording_time = 1;
1840 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1842 OutputFile *of = &output_files[ost->file_index];
1843 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1847 av_init_packet(&opkt);
1849 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1850 !ost->copy_initial_nonkeyframes)
1853 /* force the input stream PTS */
1854 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1855 audio_size += pkt->size;
1856 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1857 video_size += pkt->size;
1861 opkt.stream_index = ost->index;
1862 if (pkt->pts != AV_NOPTS_VALUE)
1863 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1865 opkt.pts = AV_NOPTS_VALUE;
1867 if (pkt->dts == AV_NOPTS_VALUE)
1868 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1870 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1871 opkt.dts -= ost_tb_start_time;
1873 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1874 opkt.flags = pkt->flags;
1876 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1877 if ( ost->st->codec->codec_id != CODEC_ID_H264
1878 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1879 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1881 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1882 opkt.destruct = av_destruct_packet;
1884 opkt.data = pkt->data;
1885 opkt.size = pkt->size;
1887 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1888 /* store AVPicture in AVPacket, as expected by the output format */
1889 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1890 opkt.data = (uint8_t *)&pict;
1891 opkt.size = sizeof(AVPicture);
1892 opkt.flags |= AV_PKT_FLAG_KEY;
1895 write_frame(of->ctx, &opkt, ost);
1896 ost->st->codec->frame_number++;
1897 av_free_packet(&opkt);
1900 static void rate_emu_sleep(InputStream *ist)
1902 if (input_files[ist->file_index].rate_emu) {
1903 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1904 int64_t now = av_gettime() - ist->start;
1910 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1912 AVFrame *decoded_frame;
1913 AVCodecContext *avctx = ist->st->codec;
1914 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1917 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1918 return AVERROR(ENOMEM);
1920 avcodec_get_frame_defaults(ist->decoded_frame);
1921 decoded_frame = ist->decoded_frame;
1923 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1929 /* no audio frame */
1933 /* if the decoder provides a pts, use it instead of the last packet pts.
1934 the decoder could be delaying output by a packet or more. */
1935 if (decoded_frame->pts != AV_NOPTS_VALUE)
1936 ist->next_pts = decoded_frame->pts;
1938 /* increment next_pts to use for the case where the input stream does not
1939 have timestamps or there are multiple frames in the packet */
1940 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1943 // preprocess audio (volume)
1944 if (audio_volume != 256) {
1945 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1946 void *samples = decoded_frame->data[0];
1947 switch (avctx->sample_fmt) {
1948 case AV_SAMPLE_FMT_U8:
1950 uint8_t *volp = samples;
1951 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1952 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1953 *volp++ = av_clip_uint8(v);
1957 case AV_SAMPLE_FMT_S16:
1959 int16_t *volp = samples;
1960 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1961 int v = ((*volp) * audio_volume + 128) >> 8;
1962 *volp++ = av_clip_int16(v);
1966 case AV_SAMPLE_FMT_S32:
1968 int32_t *volp = samples;
1969 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1970 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
1971 *volp++ = av_clipl_int32(v);
1975 case AV_SAMPLE_FMT_FLT:
1977 float *volp = samples;
1978 float scale = audio_volume / 256.f;
1979 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1984 case AV_SAMPLE_FMT_DBL:
1986 double *volp = samples;
1987 double scale = audio_volume / 256.;
1988 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1994 av_log(NULL, AV_LOG_FATAL,
1995 "Audio volume adjustment on sample format %s is not supported.\n",
1996 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
2001 rate_emu_sleep(ist);
2003 for (i = 0; i < nb_output_streams; i++) {
2004 OutputStream *ost = &output_streams[i];
2006 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2008 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
2014 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
2016 AVFrame *decoded_frame, *filtered_frame = NULL;
2017 void *buffer_to_free = NULL;
2021 int frame_available = 1;
2024 int64_t *best_effort_timestamp;
2025 AVRational *frame_sample_aspect;
2027 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2028 return AVERROR(ENOMEM);
2030 avcodec_get_frame_defaults(ist->decoded_frame);
2031 decoded_frame = ist->decoded_frame;
2032 pkt->pts = *pkt_pts;
2033 pkt->dts = *pkt_dts;
2034 *pkt_pts = AV_NOPTS_VALUE;
2036 if (pkt->duration) {
2037 duration = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2038 } else if(ist->st->codec->time_base.num != 0) {
2039 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2040 duration = ((int64_t)AV_TIME_BASE *
2041 ist->st->codec->time_base.num * ticks) /
2042 ist->st->codec->time_base.den;
2045 if(*pkt_dts != AV_NOPTS_VALUE && duration) {
2046 *pkt_dts += duration;
2048 *pkt_dts = AV_NOPTS_VALUE;
2050 ret = avcodec_decode_video2(ist->st->codec,
2051 decoded_frame, got_output, pkt);
2055 quality = same_quant ? decoded_frame->quality : 0;
2057 /* no picture yet */
2061 best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
2062 if(*best_effort_timestamp != AV_NOPTS_VALUE)
2063 ist->next_pts = ist->pts = *best_effort_timestamp;
2065 ist->next_pts += duration;
2068 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2071 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2072 for(i=0;i<nb_output_streams;i++) {
2073 OutputStream *ost = ost = &output_streams[i];
2074 if(check_output_constraints(ist, ost)){
2075 if (!frame_sample_aspect->num)
2076 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2077 decoded_frame->pts = ist->pts;
2078 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER) {
2079 FrameBuffer *buf = decoded_frame->opaque;
2080 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2081 decoded_frame->data, decoded_frame->linesize,
2082 AV_PERM_READ | AV_PERM_PRESERVE,
2083 ist->st->codec->width, ist->st->codec->height,
2084 ist->st->codec->pix_fmt);
2086 avfilter_copy_frame_props(fb, decoded_frame);
2088 fb->buf->priv = buf;
2089 fb->buf->free = filter_release_buffer;
2092 av_buffersrc_buffer(ost->input_video_filter, fb);
2094 if((av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE)) < 0){
2095 av_log(0, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2102 rate_emu_sleep(ist);
2104 for (i = 0; i < nb_output_streams; i++) {
2105 OutputStream *ost = &output_streams[i];
2108 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2112 if (ost->input_video_filter) {
2113 frame_available = av_buffersink_poll_frame(ost->output_video_filter);
2115 while (frame_available) {
2116 if (ost->output_video_filter) {
2117 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
2118 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0){
2119 av_log(0, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");
2122 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2123 av_free(buffer_to_free);
2124 return AVERROR(ENOMEM);
2126 avcodec_get_frame_defaults(ist->filtered_frame);
2127 filtered_frame = ist->filtered_frame;
2128 *filtered_frame= *decoded_frame; //for me_threshold
2130 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
2131 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2134 if (ost->picref->video && !ost->frame_aspect_ratio)
2135 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
2137 filtered_frame = decoded_frame;
2140 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
2141 same_quant ? quality : ost->st->codec->global_quality);
2142 if (vstats_filename && frame_size)
2143 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
2146 frame_available = ost->output_video_filter && av_buffersink_poll_frame(ost->output_video_filter);
2147 avfilter_unref_buffer(ost->picref);
2152 av_free(buffer_to_free);
2156 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2158 AVSubtitle subtitle;
2159 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2160 &subtitle, got_output, pkt);
2166 rate_emu_sleep(ist);
2168 for (i = 0; i < nb_output_streams; i++) {
2169 OutputStream *ost = &output_streams[i];
2171 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2174 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2177 avsubtitle_free(&subtitle);
2181 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2182 static int output_packet(InputStream *ist,
2183 OutputStream *ost_table, int nb_ostreams,
2184 const AVPacket *pkt)
2188 int64_t pkt_dts = AV_NOPTS_VALUE;
2189 int64_t pkt_pts = AV_NOPTS_VALUE;
2193 if (ist->next_pts == AV_NOPTS_VALUE)
2194 ist->next_pts = ist->pts;
2198 av_init_packet(&avpkt);
2206 if (pkt->dts != AV_NOPTS_VALUE) {
2207 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2208 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2209 pkt_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2211 if(pkt->pts != AV_NOPTS_VALUE)
2212 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2214 // while we have more to decode or while the decoder did output something on EOF
2215 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2218 ist->pts = ist->next_pts;
2220 if (avpkt.size && avpkt.size != pkt->size) {
2221 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2222 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2223 ist->showed_multi_packet_warning = 1;
2226 switch (ist->st->codec->codec_type) {
2227 case AVMEDIA_TYPE_AUDIO:
2228 ret = transcode_audio (ist, &avpkt, &got_output);
2230 case AVMEDIA_TYPE_VIDEO:
2231 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
2233 case AVMEDIA_TYPE_SUBTITLE:
2234 ret = transcode_subtitles(ist, &avpkt, &got_output);
2244 avpkt.pts= AV_NOPTS_VALUE;
2246 // touch data and size only if not EOF
2248 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2258 /* handle stream copy */
2259 if (!ist->decoding_needed) {
2260 rate_emu_sleep(ist);
2261 ist->pts = ist->next_pts;
2262 switch (ist->st->codec->codec_type) {
2263 case AVMEDIA_TYPE_AUDIO:
2264 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2265 ist->st->codec->sample_rate;
2267 case AVMEDIA_TYPE_VIDEO:
2268 if (pkt->duration) {
2269 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2270 } else if(ist->st->codec->time_base.num != 0) {
2271 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2272 ist->next_pts += ((int64_t)AV_TIME_BASE *
2273 ist->st->codec->time_base.num * ticks) /
2274 ist->st->codec->time_base.den;
2279 for (i = 0; pkt && i < nb_ostreams; i++) {
2280 OutputStream *ost = &ost_table[i];
2282 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2285 do_streamcopy(ist, ost, pkt);
2291 static void print_sdp(OutputFile *output_files, int n)
2295 AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2299 for (i = 0; i < n; i++)
2300 avc[i] = output_files[i].ctx;
2302 av_sdp_create(avc, n, sdp, sizeof(sdp));
2303 printf("SDP:\n%s\n", sdp);
2308 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2309 char *error, int error_len)
2311 InputStream *ist = &input_streams[ist_index];
2312 if (ist->decoding_needed) {
2313 AVCodec *codec = ist->dec;
2315 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2316 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2317 return AVERROR(EINVAL);
2320 ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
2321 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2322 ist->st->codec->get_buffer = codec_get_buffer;
2323 ist->st->codec->release_buffer = codec_release_buffer;
2324 ist->st->codec->opaque = ist;
2327 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2328 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2329 ist->file_index, ist->st->index);
2330 return AVERROR(EINVAL);
2332 assert_codec_experimental(ist->st->codec, 0);
2333 assert_avoptions(ist->opts);
2336 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;
2337 ist->next_pts = AV_NOPTS_VALUE;
2343 static int transcode_init(OutputFile *output_files, int nb_output_files,
2344 InputFile *input_files, int nb_input_files)
2346 int ret = 0, i, j, k;
2347 AVFormatContext *oc;
2348 AVCodecContext *codec, *icodec;
2354 /* init framerate emulation */
2355 for (i = 0; i < nb_input_files; i++) {
2356 InputFile *ifile = &input_files[i];
2357 if (ifile->rate_emu)
2358 for (j = 0; j < ifile->nb_streams; j++)
2359 input_streams[j + ifile->ist_index].start = av_gettime();
2362 /* output stream init */
2363 for (i = 0; i < nb_output_files; i++) {
2364 oc = output_files[i].ctx;
2365 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2366 av_dump_format(oc, i, oc->filename, 1);
2367 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2368 return AVERROR(EINVAL);
2372 /* for each output stream, we compute the right encoding parameters */
2373 for (i = 0; i < nb_output_streams; i++) {
2374 ost = &output_streams[i];
2375 oc = output_files[ost->file_index].ctx;
2376 ist = &input_streams[ost->source_index];
2378 if (ost->attachment_filename)
2381 codec = ost->st->codec;
2382 icodec = ist->st->codec;
2384 ost->st->disposition = ist->st->disposition;
2385 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2386 codec->chroma_sample_location = icodec->chroma_sample_location;
2388 if (ost->stream_copy) {
2389 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2391 if (extra_size > INT_MAX) {
2392 return AVERROR(EINVAL);
2395 /* if stream_copy is selected, no need to decode or encode */
2396 codec->codec_id = icodec->codec_id;
2397 codec->codec_type = icodec->codec_type;
2399 if (!codec->codec_tag) {
2400 if (!oc->oformat->codec_tag ||
2401 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2402 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2403 codec->codec_tag = icodec->codec_tag;
2406 codec->bit_rate = icodec->bit_rate;
2407 codec->rc_max_rate = icodec->rc_max_rate;
2408 codec->rc_buffer_size = icodec->rc_buffer_size;
2409 codec->field_order = icodec->field_order;
2410 codec->extradata = av_mallocz(extra_size);
2411 if (!codec->extradata) {
2412 return AVERROR(ENOMEM);
2414 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2415 codec->extradata_size= icodec->extradata_size;
2417 codec->time_base = ist->st->time_base;
2418 if(!strcmp(oc->oformat->name, "avi")) {
2419 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2420 && av_q2d(ist->st->time_base) < 1.0/500
2422 codec->time_base = icodec->time_base;
2423 codec->time_base.num *= icodec->ticks_per_frame;
2424 codec->time_base.den *= 2;
2426 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2427 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2428 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2430 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2431 && av_q2d(ist->st->time_base) < 1.0/500
2433 codec->time_base = icodec->time_base;
2434 codec->time_base.num *= icodec->ticks_per_frame;
2437 av_reduce(&codec->time_base.num, &codec->time_base.den,
2438 codec->time_base.num, codec->time_base.den, INT_MAX);
2440 switch (codec->codec_type) {
2441 case AVMEDIA_TYPE_AUDIO:
2442 if (audio_volume != 256) {
2443 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2446 codec->channel_layout = icodec->channel_layout;
2447 codec->sample_rate = icodec->sample_rate;
2448 codec->channels = icodec->channels;
2449 codec->frame_size = icodec->frame_size;
2450 codec->audio_service_type = icodec->audio_service_type;
2451 codec->block_align = icodec->block_align;
2453 case AVMEDIA_TYPE_VIDEO:
2454 codec->pix_fmt = icodec->pix_fmt;
2455 codec->width = icodec->width;
2456 codec->height = icodec->height;
2457 codec->has_b_frames = icodec->has_b_frames;
2458 if (!codec->sample_aspect_ratio.num) {
2459 codec->sample_aspect_ratio =
2460 ost->st->sample_aspect_ratio =
2461 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2462 ist->st->codec->sample_aspect_ratio.num ?
2463 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2465 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2467 case AVMEDIA_TYPE_SUBTITLE:
2468 codec->width = icodec->width;
2469 codec->height = icodec->height;
2471 case AVMEDIA_TYPE_DATA:
2472 case AVMEDIA_TYPE_ATTACHMENT:
2479 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2481 ist->decoding_needed = 1;
2482 ost->encoding_needed = 1;
2484 switch (codec->codec_type) {
2485 case AVMEDIA_TYPE_AUDIO:
2486 ost->fifo = av_fifo_alloc(1024);
2488 return AVERROR(ENOMEM);
2490 if (!codec->sample_rate)
2491 codec->sample_rate = icodec->sample_rate;
2492 choose_sample_rate(ost->st, ost->enc);
2493 codec->time_base = (AVRational){ 1, codec->sample_rate };
2495 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2496 codec->sample_fmt = icodec->sample_fmt;
2497 choose_sample_fmt(ost->st, ost->enc);
2499 if (ost->audio_channels_mapped) {
2500 /* the requested output channel is set to the number of
2501 * -map_channel only if no -ac are specified */
2502 if (!codec->channels) {
2503 codec->channels = ost->audio_channels_mapped;
2504 codec->channel_layout = av_get_default_channel_layout(codec->channels);
2505 if (!codec->channel_layout) {
2506 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2510 /* fill unused channel mapping with -1 (which means a muted
2511 * channel in case the number of output channels is bigger
2512 * than the number of mapped channel) */
2513 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2514 ost->audio_channels_map[j] = -1;
2515 } else if (!codec->channels) {
2516 codec->channels = icodec->channels;
2517 codec->channel_layout = icodec->channel_layout;
2519 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2520 codec->channel_layout = 0;
2522 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2523 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2524 || codec->channel_layout != icodec->channel_layout;
2525 icodec->request_channels = codec->channels;
2526 ost->resample_sample_fmt = icodec->sample_fmt;
2527 ost->resample_sample_rate = icodec->sample_rate;
2528 ost->resample_channels = icodec->channels;
2530 case AVMEDIA_TYPE_VIDEO:
2531 if (codec->pix_fmt == PIX_FMT_NONE)
2532 codec->pix_fmt = icodec->pix_fmt;
2533 choose_pixel_fmt(ost->st, ost->enc);
2535 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2536 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2540 if (!codec->width || !codec->height) {
2541 codec->width = icodec->width;
2542 codec->height = icodec->height;
2545 ost->video_resample = codec->width != icodec->width ||
2546 codec->height != icodec->height ||
2547 codec->pix_fmt != icodec->pix_fmt;
2548 if (ost->video_resample) {
2549 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
2552 ost->resample_height = icodec->height;
2553 ost->resample_width = icodec->width;
2554 ost->resample_pix_fmt = icodec->pix_fmt;
2556 if (!ost->frame_rate.num)
2557 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2558 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2559 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2560 ost->frame_rate = ost->enc->supported_framerates[idx];
2562 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2563 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method
2564 && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2565 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2566 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2568 for (j = 0; j < ost->forced_kf_count; j++)
2569 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2574 if (configure_video_filters(ist, ost)) {
2575 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2580 case AVMEDIA_TYPE_SUBTITLE:
2587 if (codec->codec_id != CODEC_ID_H264 &&
2588 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2589 char logfilename[1024];
2592 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2593 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2595 if (codec->flags & CODEC_FLAG_PASS2) {
2597 size_t logbuffer_size;
2598 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2599 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2603 codec->stats_in = logbuffer;
2605 if (codec->flags & CODEC_FLAG_PASS1) {
2606 f = fopen(logfilename, "wb");
2608 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2609 logfilename, strerror(errno));
2616 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2617 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size (1664)*/
2618 int size = codec->width * codec->height;
2619 bit_buffer_size = FFMAX(bit_buffer_size, 7*size + 10000);
2624 bit_buffer = av_malloc(bit_buffer_size);
2626 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2628 return AVERROR(ENOMEM);
2631 /* open each encoder */
2632 for (i = 0; i < nb_output_streams; i++) {
2633 ost = &output_streams[i];
2634 if (ost->encoding_needed) {
2635 AVCodec *codec = ost->enc;
2636 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2638 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2639 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2640 ret = AVERROR(EINVAL);
2643 if (dec->subtitle_header) {
2644 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2645 if (!ost->st->codec->subtitle_header) {
2646 ret = AVERROR(ENOMEM);
2649 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2650 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2652 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2653 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2654 ost->file_index, ost->index);
2655 ret = AVERROR(EINVAL);
2658 assert_codec_experimental(ost->st->codec, 1);
2659 assert_avoptions(ost->opts);
2660 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2661 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2662 " It takes bits/s as argument, not kbits/s\n");
2663 extra_size += ost->st->codec->extradata_size;
2665 if (ost->st->codec->me_threshold)
2666 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2670 /* init input streams */
2671 for (i = 0; i < nb_input_streams; i++)
2672 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2675 /* discard unused programs */
2676 for (i = 0; i < nb_input_files; i++) {
2677 InputFile *ifile = &input_files[i];
2678 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2679 AVProgram *p = ifile->ctx->programs[j];
2680 int discard = AVDISCARD_ALL;
2682 for (k = 0; k < p->nb_stream_indexes; k++)
2683 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2684 discard = AVDISCARD_DEFAULT;
2687 p->discard = discard;
2691 /* open files and write file headers */
2692 for (i = 0; i < nb_output_files; i++) {
2693 oc = output_files[i].ctx;
2694 oc->interrupt_callback = int_cb;
2695 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2696 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2697 ret = AVERROR(EINVAL);
2700 // assert_avoptions(output_files[i].opts);
2701 if (strcmp(oc->oformat->name, "rtp")) {
2707 /* dump the file output parameters - cannot be done before in case
2709 for (i = 0; i < nb_output_files; i++) {
2710 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2713 /* dump the stream mapping */
2714 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2715 for (i = 0; i < nb_output_streams; i++) {
2716 ost = &output_streams[i];
2718 if (ost->attachment_filename) {
2719 /* an attached file */
2720 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2721 ost->attachment_filename, ost->file_index, ost->index);
2724 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2725 input_streams[ost->source_index].file_index,
2726 input_streams[ost->source_index].st->index,
2729 if (ost->audio_channels_mapped) {
2730 av_log(NULL, AV_LOG_INFO, " [ch:");
2731 for (j = 0; j < ost->audio_channels_mapped; j++)
2732 if (ost->audio_channels_map[j] == -1)
2733 av_log(NULL, AV_LOG_INFO, " M");
2735 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2736 av_log(NULL, AV_LOG_INFO, "]");
2738 if (ost->sync_ist != &input_streams[ost->source_index])
2739 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2740 ost->sync_ist->file_index,
2741 ost->sync_ist->st->index);
2742 if (ost->stream_copy)
2743 av_log(NULL, AV_LOG_INFO, " (copy)");
2745 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2746 input_streams[ost->source_index].dec->name : "?",
2747 ost->enc ? ost->enc->name : "?");
2748 av_log(NULL, AV_LOG_INFO, "\n");
2752 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2757 print_sdp(output_files, nb_output_files);
2764 * The following code is the main loop of the file converter
2766 static int transcode(OutputFile *output_files, int nb_output_files,
2767 InputFile *input_files, int nb_input_files)
2770 AVFormatContext *is, *os;
2774 int no_packet_count = 0;
2775 int64_t timer_start;
2778 if (!(no_packet = av_mallocz(nb_input_files)))
2781 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2786 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2789 timer_start = av_gettime();
2791 for (; received_sigterm == 0;) {
2792 int file_index, ist_index;
2796 int64_t cur_time= av_gettime();
2798 ipts_min = INT64_MAX;
2800 /* if 'q' pressed, exits */
2802 static int64_t last_time;
2803 if (received_nb_signals)
2805 /* read_key() returns 0 on EOF */
2806 if(cur_time - last_time >= 100000 && !run_as_daemon){
2808 last_time = cur_time;
2813 if (key == '+') av_log_set_level(av_log_get_level()+10);
2814 if (key == '-') av_log_set_level(av_log_get_level()-10);
2815 if (key == 's') qp_hist ^= 1;
2818 do_hex_dump = do_pkt_dump = 0;
2819 } else if(do_pkt_dump){
2823 av_log_set_level(AV_LOG_DEBUG);
2826 if (key == 'c' || key == 'C'){
2827 char buf[4096], target[64], command[256], arg[256] = {0};
2830 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2832 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2837 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2838 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2839 target, time, command, arg);
2840 for (i = 0; i < nb_output_streams; i++) {
2841 ost = &output_streams[i];
2844 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2845 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2846 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2848 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2853 av_log(NULL, AV_LOG_ERROR,
2854 "Parse error, at least 3 arguments were expected, "
2855 "only %d given in string '%s'\n", n, buf);
2859 if (key == 'd' || key == 'D'){
2862 debug = input_streams[0].st->codec->debug<<1;
2863 if(!debug) debug = 1;
2864 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2867 if(scanf("%d", &debug)!=1)
2868 fprintf(stderr,"error parsing debug value\n");
2869 for(i=0;i<nb_input_streams;i++) {
2870 input_streams[i].st->codec->debug = debug;
2872 for(i=0;i<nb_output_streams;i++) {
2873 ost = &output_streams[i];
2874 ost->st->codec->debug = debug;
2876 if(debug) av_log_set_level(AV_LOG_DEBUG);
2877 fprintf(stderr,"debug=%d\n", debug);
2880 fprintf(stderr, "key function\n"
2881 "? show this help\n"
2882 "+ increase verbosity\n"
2883 "- decrease verbosity\n"
2884 "c Send command to filtergraph\n"
2885 "D cycle through available debug modes\n"
2886 "h dump packets/hex press to cycle through the 3 states\n"
2888 "s Show QP histogram\n"
2893 /* select the stream that we must read now by looking at the
2894 smallest output pts */
2896 for (i = 0; i < nb_output_streams; i++) {
2900 ost = &output_streams[i];
2901 of = &output_files[ost->file_index];
2902 os = output_files[ost->file_index].ctx;
2903 ist = &input_streams[ost->source_index];
2904 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2905 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2907 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2909 if (!input_files[ist->file_index].eof_reached) {
2910 if (ipts < ipts_min) {
2913 file_index = ist->file_index;
2915 if (opts < opts_min) {
2917 if (!input_sync) file_index = ist->file_index;
2920 if (ost->frame_number >= ost->max_frames) {
2922 for (j = 0; j < of->ctx->nb_streams; j++)
2923 output_streams[of->ost_index + j].is_past_recording_time = 1;
2927 /* if none, if is finished */
2928 if (file_index < 0) {
2929 if (no_packet_count) {
2930 no_packet_count = 0;
2931 memset(no_packet, 0, nb_input_files);
2938 /* read a frame from it and output it in the fifo */
2939 is = input_files[file_index].ctx;
2940 ret = av_read_frame(is, &pkt);
2941 if (ret == AVERROR(EAGAIN)) {
2942 no_packet[file_index] = 1;
2947 input_files[file_index].eof_reached = 1;
2954 no_packet_count = 0;
2955 memset(no_packet, 0, nb_input_files);
2958 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2959 is->streams[pkt.stream_index]);
2961 /* the following test is needed in case new streams appear
2962 dynamically in stream : we ignore them */
2963 if (pkt.stream_index >= input_files[file_index].nb_streams)
2964 goto discard_packet;
2965 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2966 ist = &input_streams[ist_index];
2968 goto discard_packet;
2970 if (pkt.dts != AV_NOPTS_VALUE)
2971 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2972 if (pkt.pts != AV_NOPTS_VALUE)
2973 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2975 if (pkt.pts != AV_NOPTS_VALUE)
2976 pkt.pts *= ist->ts_scale;
2977 if (pkt.dts != AV_NOPTS_VALUE)
2978 pkt.dts *= ist->ts_scale;
2980 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
2982 // pkt.dts, input_files[ist->file_index].ts_offset,
2983 // ist->st->codec->codec_type);
2984 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2985 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2986 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2987 int64_t delta = pkt_dts - ist->next_pts;
2988 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2989 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2990 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2991 pkt_dts+1<ist->pts)&& !copy_ts){
2992 input_files[ist->file_index].ts_offset -= delta;
2993 av_log(NULL, AV_LOG_DEBUG,
2994 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2995 delta, input_files[ist->file_index].ts_offset);
2996 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2997 if (pkt.pts != AV_NOPTS_VALUE)
2998 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3002 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3003 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
3005 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3006 ist->file_index, ist->st->index);
3009 av_free_packet(&pkt);
3014 av_free_packet(&pkt);
3016 /* dump report by using the output first video and audio streams */
3017 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
3020 /* at the end of stream, we must flush the decoder buffers */
3021 for (i = 0; i < nb_input_streams; i++) {
3022 ist = &input_streams[i];
3023 if (ist->decoding_needed) {
3024 output_packet(ist, output_streams, nb_output_streams, NULL);
3027 flush_encoders(output_streams, nb_output_streams);
3031 /* write the trailer if needed and close file */
3032 for (i = 0; i < nb_output_files; i++) {
3033 os = output_files[i].ctx;
3034 av_write_trailer(os);
3037 /* dump report by using the first video and audio streams */
3038 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
3040 /* close each encoder */
3041 for (i = 0; i < nb_output_streams; i++) {
3042 ost = &output_streams[i];
3043 if (ost->encoding_needed) {
3044 av_freep(&ost->st->codec->stats_in);
3045 avcodec_close(ost->st->codec);
3048 avfilter_graph_free(&ost->graph);
3052 /* close each decoder */
3053 for (i = 0; i < nb_input_streams; i++) {
3054 ist = &input_streams[i];
3055 if (ist->decoding_needed) {
3056 avcodec_close(ist->st->codec);
3064 av_freep(&bit_buffer);
3065 av_freep(&no_packet);
3067 if (output_streams) {
3068 for (i = 0; i < nb_output_streams; i++) {
3069 ost = &output_streams[i];
3071 if (ost->stream_copy)
3072 av_freep(&ost->st->codec->extradata);
3074 fclose(ost->logfile);
3075 ost->logfile = NULL;
3077 av_fifo_free(ost->fifo); /* works even if fifo is not
3078 initialized but set to zero */
3079 av_freep(&ost->st->codec->subtitle_header);
3080 av_free(ost->resample_frame.data[0]);
3081 av_free(ost->forced_kf_pts);
3082 if (ost->video_resample)
3083 sws_freeContext(ost->img_resample_ctx);
3084 swr_free(&ost->swr);
3085 av_dict_free(&ost->opts);
3092 static int opt_frame_crop(const char *opt, const char *arg)
3094 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3095 return AVERROR(EINVAL);
3098 static int opt_pad(const char *opt, const char *arg)
3100 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3104 static double parse_frame_aspect_ratio(const char *arg)
3111 p = strchr(arg, ':');
3113 x = strtol(arg, &end, 10);
3115 y = strtol(end + 1, &end, 10);
3117 ar = (double)x / (double)y;
3119 ar = strtod(arg, NULL);
3122 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
3128 static int opt_video_channel(const char *opt, const char *arg)
3130 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3131 return opt_default("channel", arg);
3134 static int opt_video_standard(const char *opt, const char *arg)
3136 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3137 return opt_default("standard", arg);
3140 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3142 audio_codec_name = arg;
3143 return parse_option(o, "codec:a", arg, options);
3146 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3148 video_codec_name = arg;
3149 return parse_option(o, "codec:v", arg, options);
3152 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3154 subtitle_codec_name = arg;
3155 return parse_option(o, "codec:s", arg, options);
3158 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3160 return parse_option(o, "codec:d", arg, options);
3163 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3165 StreamMap *m = NULL;
3166 int i, negative = 0, file_idx;
3167 int sync_file_idx = -1, sync_stream_idx = 0;
3175 map = av_strdup(arg);
3177 /* parse sync stream first, just pick first matching stream */
3178 if (sync = strchr(map, ',')) {
3180 sync_file_idx = strtol(sync + 1, &sync, 0);
3181 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3182 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3187 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
3188 if (check_stream_specifier(input_files[sync_file_idx].ctx,
3189 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
3190 sync_stream_idx = i;
3193 if (i == input_files[sync_file_idx].nb_streams) {
3194 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3195 "match any streams.\n", arg);
3201 file_idx = strtol(map, &p, 0);
3202 if (file_idx >= nb_input_files || file_idx < 0) {
3203 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3207 /* disable some already defined maps */
3208 for (i = 0; i < o->nb_stream_maps; i++) {
3209 m = &o->stream_maps[i];
3210 if (file_idx == m->file_index &&
3211 check_stream_specifier(input_files[m->file_index].ctx,
3212 input_files[m->file_index].ctx->streams[m->stream_index],
3213 *p == ':' ? p + 1 : p) > 0)
3217 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3218 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3219 *p == ':' ? p + 1 : p) <= 0)
3221 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3222 &o->nb_stream_maps, o->nb_stream_maps + 1);
3223 m = &o->stream_maps[o->nb_stream_maps - 1];
3225 m->file_index = file_idx;
3226 m->stream_index = i;
3228 if (sync_file_idx >= 0) {
3229 m->sync_file_index = sync_file_idx;
3230 m->sync_stream_index = sync_stream_idx;
3232 m->sync_file_index = file_idx;
3233 m->sync_stream_index = i;
3238 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3246 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3248 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3249 &o->nb_attachments, o->nb_attachments + 1);
3250 o->attachments[o->nb_attachments - 1] = arg;
3254 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3260 o->audio_channel_maps =
3261 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3262 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3263 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3265 /* muted channel syntax */
3266 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3267 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3268 m->file_idx = m->stream_idx = -1;
3270 m->ofile_idx = m->ostream_idx = -1;
3275 n = sscanf(arg, "%d.%d.%d:%d.%d",
3276 &m->file_idx, &m->stream_idx, &m->channel_idx,
3277 &m->ofile_idx, &m->ostream_idx);
3279 if (n != 3 && n != 5) {
3280 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3281 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3285 if (n != 5) // only file.stream.channel specified
3286 m->ofile_idx = m->ostream_idx = -1;
3289 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3290 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3294 if (m->stream_idx < 0 ||
3295 m->stream_idx >= input_files[m->file_idx].nb_streams) {
3296 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3297 m->file_idx, m->stream_idx);
3300 st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3301 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3302 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3303 m->file_idx, m->stream_idx);
3306 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3307 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3308 m->file_idx, m->stream_idx, m->channel_idx);
3315 * Parse a metadata specifier in arg.
3316 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3317 * @param index for type c/p, chapter/program index is written here
3318 * @param stream_spec for type s, the stream specifier is written here
3320 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3328 if (*(++arg) && *arg != ':') {
3329 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3332 *stream_spec = *arg == ':' ? arg + 1 : "";
3336 if (*(++arg) == ':')
3337 *index = strtol(++arg, NULL, 0);
3340 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3347 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3349 AVDictionary **meta_in = NULL;
3350 AVDictionary **meta_out = NULL;
3352 char type_in, type_out;
3353 const char *istream_spec = NULL, *ostream_spec = NULL;
3354 int idx_in = 0, idx_out = 0;
3356 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3357 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3359 if (type_in == 'g' || type_out == 'g')
3360 o->metadata_global_manual = 1;
3361 if (type_in == 's' || type_out == 's')
3362 o->metadata_streams_manual = 1;
3363 if (type_in == 'c' || type_out == 'c')
3364 o->metadata_chapters_manual = 1;
3366 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3367 if ((index) < 0 || (index) >= (nb_elems)) {\
3368 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3373 #define SET_DICT(type, meta, context, index)\
3376 meta = &context->metadata;\
3379 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3380 meta = &context->chapters[index]->metadata;\
3383 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3384 meta = &context->programs[index]->metadata;\
3388 SET_DICT(type_in, meta_in, ic, idx_in);
3389 SET_DICT(type_out, meta_out, oc, idx_out);
3391 /* for input streams choose first matching stream */
3392 if (type_in == 's') {
3393 for (i = 0; i < ic->nb_streams; i++) {
3394 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3395 meta_in = &ic->streams[i]->metadata;
3401 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3406 if (type_out == 's') {
3407 for (i = 0; i < oc->nb_streams; i++) {
3408 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3409 meta_out = &oc->streams[i]->metadata;
3410 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3415 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3420 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3423 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3424 struct tm time = *gmtime((time_t*)&recording_timestamp);
3425 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3426 parse_option(o, "metadata", buf, options);
3428 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3429 "tag instead.\n", opt);
3433 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3435 const char *codec_string = encoder ? "encoder" : "decoder";
3439 avcodec_find_encoder_by_name(name) :
3440 avcodec_find_decoder_by_name(name);
3442 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3445 if (codec->type != type) {
3446 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3452 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3454 char *codec_name = NULL;
3456 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3458 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3459 st->codec->codec_id = codec->id;
3462 return avcodec_find_decoder(st->codec->codec_id);
3466 * Add all the streams from the given input file to the global
3467 * list of input streams.
3469 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3472 char *next, *codec_tag = NULL;
3474 for (i = 0; i < ic->nb_streams; i++) {
3475 AVStream *st = ic->streams[i];
3476 AVCodecContext *dec = st->codec;
3479 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3480 ist = &input_streams[nb_input_streams - 1];
3482 ist->file_index = nb_input_files;
3484 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3486 ist->ts_scale = 1.0;
3487 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3489 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3491 uint32_t tag = strtol(codec_tag, &next, 0);
3493 tag = AV_RL32(codec_tag);
3494 st->codec->codec_tag = tag;
3497 ist->dec = choose_decoder(o, ic, st);
3499 switch (dec->codec_type) {
3500 case AVMEDIA_TYPE_AUDIO:
3502 ist->dec = avcodec_find_decoder(dec->codec_id);
3503 if (o->audio_disable)
3504 st->discard = AVDISCARD_ALL;
3506 case AVMEDIA_TYPE_VIDEO:
3508 ist->dec = avcodec_find_decoder(dec->codec_id);
3510 dec->flags |= CODEC_FLAG_EMU_EDGE;
3513 if (o->video_disable)
3514 st->discard = AVDISCARD_ALL;
3515 else if (video_discard)
3516 st->discard = video_discard;
3518 case AVMEDIA_TYPE_DATA:
3519 if (o->data_disable)
3520 st->discard= AVDISCARD_ALL;
3522 case AVMEDIA_TYPE_SUBTITLE:
3524 ist->dec = avcodec_find_decoder(dec->codec_id);
3525 if(o->subtitle_disable)
3526 st->discard = AVDISCARD_ALL;
3528 case AVMEDIA_TYPE_ATTACHMENT:
3529 case AVMEDIA_TYPE_UNKNOWN:
3537 static void assert_file_overwrite(const char *filename)
3539 if ((!file_overwrite || no_file_overwrite) &&
3540 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3541 av_strstart(filename, "file:", NULL))) {
3542 if (avio_check(filename, 0) == 0) {
3543 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3544 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3547 signal(SIGINT, SIG_DFL);
3548 if (!read_yesno()) {
3549 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3555 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3562 static void dump_attachment(AVStream *st, const char *filename)
3565 AVIOContext *out = NULL;
3566 AVDictionaryEntry *e;
3568 if (!st->codec->extradata_size) {
3569 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3570 nb_input_files - 1, st->index);
3573 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3574 filename = e->value;
3576 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3577 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3581 assert_file_overwrite(filename);
3583 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3584 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3589 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3594 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3596 AVFormatContext *ic;
3597 AVInputFormat *file_iformat = NULL;
3601 AVDictionary **opts;
3602 int orig_nb_streams; // number of streams before avformat_find_stream_info
3605 if (!(file_iformat = av_find_input_format(o->format))) {
3606 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3611 if (!strcmp(filename, "-"))
3614 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3615 !strcmp(filename, "/dev/stdin");
3617 /* get default parameters from command line */
3618 ic = avformat_alloc_context();
3620 print_error(filename, AVERROR(ENOMEM));
3623 if (o->nb_audio_sample_rate) {
3624 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3625 av_dict_set(&format_opts, "sample_rate", buf, 0);
3627 if (o->nb_audio_channels) {
3628 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3629 av_dict_set(&format_opts, "channels", buf, 0);
3631 if (o->nb_frame_rates) {
3632 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3634 if (o->nb_frame_sizes) {
3635 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3637 if (o->nb_frame_pix_fmts)
3638 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3640 ic->video_codec_id = video_codec_name ?
3641 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3642 ic->audio_codec_id = audio_codec_name ?
3643 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3644 ic->subtitle_codec_id= subtitle_codec_name ?
3645 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3646 ic->flags |= AVFMT_FLAG_NONBLOCK;
3647 ic->interrupt_callback = int_cb;
3650 av_log(NULL, AV_LOG_WARNING,
3651 "-loop_input is deprecated, use -loop 1\n"
3652 "Note, both loop options only work with -f image2\n"
3654 ic->loop_input = loop_input;
3657 /* open the input file with generic avformat function */
3658 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3660 print_error(filename, err);
3663 assert_avoptions(format_opts);
3665 /* apply forced codec ids */
3666 for (i = 0; i < ic->nb_streams; i++)
3667 choose_decoder(o, ic, ic->streams[i]);
3669 /* Set AVCodecContext options for avformat_find_stream_info */
3670 opts = setup_find_stream_info_opts(ic, codec_opts);
3671 orig_nb_streams = ic->nb_streams;
3673 /* If not enough info to get the stream parameters, we decode the
3674 first frames to get it. (used in mpeg case for example) */
3675 ret = avformat_find_stream_info(ic, opts);
3677 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3678 avformat_close_input(&ic);
3682 timestamp = o->start_time;
3683 /* add the stream start time */
3684 if (ic->start_time != AV_NOPTS_VALUE)
3685 timestamp += ic->start_time;
3687 /* if seeking requested, we execute it */
3688 if (o->start_time != 0) {
3689 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3691 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3692 filename, (double)timestamp / AV_TIME_BASE);
3696 /* update the current parameters so that they match the one of the input stream */
3697 add_input_streams(o, ic);
3699 /* dump the file content */
3700 av_dump_format(ic, nb_input_files, filename, 0);
3702 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3703 input_files[nb_input_files - 1].ctx = ic;
3704 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3705 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3706 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3707 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3709 for (i = 0; i < o->nb_dump_attachment; i++) {
3712 for (j = 0; j < ic->nb_streams; j++) {
3713 AVStream *st = ic->streams[j];
3715 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3716 dump_attachment(st, o->dump_attachment[i].u.str);
3720 for (i = 0; i < orig_nb_streams; i++)
3721 av_dict_free(&opts[i]);
3724 reset_options(o, 1);
3728 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3733 for (p = kf; *p; p++)
3736 ost->forced_kf_count = n;
3737 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3738 if (!ost->forced_kf_pts) {
3739 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3742 for (i = 0; i < n; i++) {
3743 p = i ? strchr(p, ',') + 1 : kf;
3744 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3748 static uint8_t *get_line(AVIOContext *s)
3754 if (avio_open_dyn_buf(&line) < 0) {
3755 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3759 while ((c = avio_r8(s)) && c != '\n')
3762 avio_close_dyn_buf(line, &buf);
3767 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3770 char filename[1000];
3771 const char *base[3] = { getenv("AVCONV_DATADIR"),
3776 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3780 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3781 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3782 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3785 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3786 i != 1 ? "" : "/.avconv", preset_name);
3787 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3793 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3795 char *codec_name = NULL;
3797 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3799 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3800 NULL, ost->st->codec->codec_type);
3801 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3802 } else if (!strcmp(codec_name, "copy"))
3803 ost->stream_copy = 1;
3805 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3806 ost->st->codec->codec_id = ost->enc->id;
3810 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3813 AVStream *st = avformat_new_stream(oc, NULL);
3814 int idx = oc->nb_streams - 1, ret = 0;
3815 char *bsf = NULL, *next, *codec_tag = NULL;
3816 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3818 char *buf = NULL, *arg = NULL, *preset = NULL;
3819 AVIOContext *s = NULL;
3822 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3826 if (oc->nb_streams - 1 < o->nb_streamid_map)
3827 st->id = o->streamid_map[oc->nb_streams - 1];
3829 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3830 nb_output_streams + 1);
3831 ost = &output_streams[nb_output_streams - 1];
3832 ost->file_index = nb_output_files;
3835 st->codec->codec_type = type;
3836 choose_encoder(o, oc, ost);
3838 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3841 avcodec_get_context_defaults3(st->codec, ost->enc);
3842 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3844 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3845 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3848 if (!buf[0] || buf[0] == '#') {
3852 if (!(arg = strchr(buf, '='))) {
3853 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3857 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3859 } while (!s->eof_reached);
3863 av_log(NULL, AV_LOG_FATAL,
3864 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3865 preset, ost->file_index, ost->index);
3869 ost->max_frames = INT64_MAX;
3870 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3872 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3874 if (next = strchr(bsf, ','))
3876 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3877 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3881 bsfc_prev->next = bsfc;
3883 ost->bitstream_filters = bsfc;
3889 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3891 uint32_t tag = strtol(codec_tag, &next, 0);
3893 tag = AV_RL32(codec_tag);
3894 st->codec->codec_tag = tag;
3897 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3898 if (qscale >= 0 || same_quant) {
3899 st->codec->flags |= CODEC_FLAG_QSCALE;
3900 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3903 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3904 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3906 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3910 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3913 const char *p = str;
3920 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3927 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3931 AVCodecContext *video_enc;
3933 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3935 video_enc = st->codec;
3937 if (!ost->stream_copy) {
3938 const char *p = NULL;
3939 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3940 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3941 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3944 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3945 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3946 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3950 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3951 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3952 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3956 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3957 if (frame_aspect_ratio)
3958 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3960 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3961 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3962 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3963 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3966 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3969 video_enc->gop_size = 0;
3970 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3972 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3973 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3976 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3978 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3980 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3981 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3984 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3987 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3988 for (i = 0; p; i++) {
3990 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
3992 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3995 /* FIXME realloc failure */
3996 video_enc->rc_override =
3997 av_realloc(video_enc->rc_override,
3998 sizeof(RcOverride) * (i + 1));
3999 video_enc->rc_override[i].start_frame = start;
4000 video_enc->rc_override[i].end_frame = end;
4002 video_enc->rc_override[i].qscale = q;
4003 video_enc->rc_override[i].quality_factor = 1.0;
4006 video_enc->rc_override[i].qscale = 0;
4007 video_enc->rc_override[i].quality_factor = -q/100.0;
4012 video_enc->rc_override_count = i;
4013 if (!video_enc->rc_initial_buffer_occupancy)
4014 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4015 video_enc->intra_dc_precision = intra_dc_precision - 8;
4018 video_enc->flags|= CODEC_FLAG_PSNR;
4023 video_enc->flags |= CODEC_FLAG_PASS1;
4026 video_enc->flags |= CODEC_FLAG_PASS2;
4030 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4031 if (forced_key_frames)
4032 parse_forced_key_frames(forced_key_frames, ost);
4034 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4036 ost->top_field_first = -1;
4037 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4039 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4042 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4044 ost->avfilter = av_strdup(filters);
4051 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
4056 AVCodecContext *audio_enc;
4058 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
4061 audio_enc = st->codec;
4062 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4064 if (!ost->stream_copy) {
4065 char *sample_fmt = NULL;
4067 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4069 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4071 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4072 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4076 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4078 ost->rematrix_volume=1.0;
4079 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4082 /* check for channel mapping for this audio stream */
4083 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4084 AudioChannelMap *map = &o->audio_channel_maps[n];
4085 InputStream *ist = &input_streams[ost->source_index];
4086 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4087 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4088 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4089 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4090 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4092 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4093 ost->file_index, ost->st->index);
4100 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
4104 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
4105 if (!ost->stream_copy) {
4106 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4113 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
4115 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
4116 ost->stream_copy = 1;
4120 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
4124 AVCodecContext *subtitle_enc;
4126 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
4128 subtitle_enc = st->codec;
4130 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4135 /* arg format is "output-stream-index:streamid-value". */
4136 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4142 av_strlcpy(idx_str, arg, sizeof(idx_str));
4143 p = strchr(idx_str, ':');
4145 av_log(NULL, AV_LOG_FATAL,
4146 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4151 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4152 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4153 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4157 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4159 AVFormatContext *is = ifile->ctx;
4160 AVFormatContext *os = ofile->ctx;
4163 for (i = 0; i < is->nb_chapters; i++) {
4164 AVChapter *in_ch = is->chapters[i], *out_ch;
4165 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4166 AV_TIME_BASE_Q, in_ch->time_base);
4167 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4168 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4171 if (in_ch->end < ts_off)
4173 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4176 out_ch = av_mallocz(sizeof(AVChapter));
4178 return AVERROR(ENOMEM);
4180 out_ch->id = in_ch->id;
4181 out_ch->time_base = in_ch->time_base;
4182 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4183 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4186 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4189 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4191 return AVERROR(ENOMEM);
4192 os->chapters[os->nb_chapters - 1] = out_ch;
4197 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4200 AVFormatContext *ic = avformat_alloc_context();
4202 ic->interrupt_callback = int_cb;
4203 err = avformat_open_input(&ic, filename, NULL, NULL);
4206 /* copy stream format */
4207 for(i=0;i<ic->nb_streams;i++) {
4211 AVCodecContext *avctx;
4213 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4214 ost = new_output_stream(o, s, codec->type);
4219 // FIXME: a more elegant solution is needed
4220 memcpy(st, ic->streams[i], sizeof(AVStream));
4221 st->info = av_malloc(sizeof(*st->info));
4222 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4224 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4226 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4227 choose_sample_fmt(st, codec);
4228 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4229 choose_pixel_fmt(st, codec);
4232 avformat_close_input(&ic);
4236 static void opt_output_file(void *optctx, const char *filename)
4238 OptionsContext *o = optctx;
4239 AVFormatContext *oc;
4241 AVOutputFormat *file_oformat;
4245 if (!strcmp(filename, "-"))
4248 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4250 print_error(filename, err);
4253 file_oformat= oc->oformat;
4254 oc->interrupt_callback = int_cb;
4256 if (!strcmp(file_oformat->name, "ffm") &&
4257 av_strstart(filename, "http:", NULL)) {
4259 /* special case for files sent to ffserver: we get the stream
4260 parameters from ffserver */
4261 int err = read_ffserver_streams(o, oc, filename);
4263 print_error(filename, err);
4266 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4267 ost = &output_streams[j];
4268 for (i = 0; i < nb_input_streams; i++) {
4269 ist = &input_streams[i];
4270 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4272 ost->source_index= i;
4278 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));
4282 } else if (!o->nb_stream_maps) {
4283 /* pick the "best" stream of each type */
4284 #define NEW_STREAM(type, index)\
4286 ost = new_ ## type ## _stream(o, oc);\
4287 ost->source_index = index;\
4288 ost->sync_ist = &input_streams[index];\
4289 input_streams[index].discard = 0;\
4292 /* video: highest resolution */
4293 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4294 int area = 0, idx = -1;
4295 for (i = 0; i < nb_input_streams; i++) {
4296 ist = &input_streams[i];
4297 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4298 ist->st->codec->width * ist->st->codec->height > area) {
4299 area = ist->st->codec->width * ist->st->codec->height;
4303 NEW_STREAM(video, idx);
4306 /* audio: most channels */
4307 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4308 int channels = 0, idx = -1;
4309 for (i = 0; i < nb_input_streams; i++) {
4310 ist = &input_streams[i];
4311 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4312 ist->st->codec->channels > channels) {
4313 channels = ist->st->codec->channels;
4317 NEW_STREAM(audio, idx);
4320 /* subtitles: pick first */
4321 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4322 for (i = 0; i < nb_input_streams; i++)
4323 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4324 NEW_STREAM(subtitle, i);
4328 /* do something with data? */
4330 for (i = 0; i < o->nb_stream_maps; i++) {
4331 StreamMap *map = &o->stream_maps[i];
4336 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4337 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4339 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4341 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4343 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4346 switch (ist->st->codec->codec_type) {
4347 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4348 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4349 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4350 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4351 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4353 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4354 map->file_index, map->stream_index);
4358 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4359 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4360 map->sync_stream_index];
4365 /* handle attached files */
4366 for (i = 0; i < o->nb_attachments; i++) {
4368 uint8_t *attachment;
4372 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4373 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4377 if ((len = avio_size(pb)) <= 0) {
4378 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4382 if (!(attachment = av_malloc(len))) {
4383 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4387 avio_read(pb, attachment, len);
4389 ost = new_attachment_stream(o, oc);
4390 ost->stream_copy = 0;
4391 ost->source_index = -1;
4392 ost->attachment_filename = o->attachments[i];
4393 ost->st->codec->extradata = attachment;
4394 ost->st->codec->extradata_size = len;
4396 p = strrchr(o->attachments[i], '/');
4397 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4401 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4402 output_files[nb_output_files - 1].ctx = oc;
4403 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4404 output_files[nb_output_files - 1].recording_time = o->recording_time;
4405 output_files[nb_output_files - 1].start_time = o->start_time;
4406 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4407 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4409 /* check filename in case of an image number is expected */
4410 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4411 if (!av_filename_number_test(oc->filename)) {
4412 print_error(oc->filename, AVERROR(EINVAL));
4417 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4418 /* test if it already exists to avoid losing precious files */
4419 assert_file_overwrite(filename);
4422 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4423 &oc->interrupt_callback,
4424 &output_files[nb_output_files - 1].opts)) < 0) {
4425 print_error(filename, err);
4430 if (o->mux_preload) {
4432 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4433 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4435 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4437 if (loop_output >= 0) {
4438 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4439 oc->loop_output = loop_output;
4443 for (i = 0; i < o->nb_metadata_map; i++) {
4445 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4447 if (in_file_index < 0)
4449 if (in_file_index >= nb_input_files) {
4450 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4453 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4457 if (o->chapters_input_file >= nb_input_files) {
4458 if (o->chapters_input_file == INT_MAX) {
4459 /* copy chapters from the first input file that has them*/
4460 o->chapters_input_file = -1;
4461 for (i = 0; i < nb_input_files; i++)
4462 if (input_files[i].ctx->nb_chapters) {
4463 o->chapters_input_file = i;
4467 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4468 o->chapters_input_file);
4472 if (o->chapters_input_file >= 0)
4473 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4474 !o->metadata_chapters_manual);
4476 /* copy global metadata by default */
4477 if (!o->metadata_global_manual && nb_input_files){
4478 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4479 AV_DICT_DONT_OVERWRITE);
4480 if(o->recording_time != INT64_MAX)
4481 av_dict_set(&oc->metadata, "duration", NULL, 0);
4483 if (!o->metadata_streams_manual)
4484 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4486 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4488 ist = &input_streams[output_streams[i].source_index];
4489 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4492 /* process manually set metadata */
4493 for (i = 0; i < o->nb_metadata; i++) {
4496 const char *stream_spec;
4497 int index = 0, j, ret = 0;
4499 val = strchr(o->metadata[i].u.str, '=');
4501 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4502 o->metadata[i].u.str);
4507 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4509 for (j = 0; j < oc->nb_streams; j++) {
4510 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4511 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4515 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4523 if (index < 0 || index >= oc->nb_chapters) {
4524 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4527 m = &oc->chapters[index]->metadata;
4530 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4533 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4537 reset_options(o, 0);
4540 /* same option as mencoder */
4541 static int opt_pass(const char *opt, const char *arg)
4543 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4547 static int64_t getutime(void)
4550 struct rusage rusage;
4552 getrusage(RUSAGE_SELF, &rusage);
4553 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4554 #elif HAVE_GETPROCESSTIMES
4556 FILETIME c, e, k, u;
4557 proc = GetCurrentProcess();
4558 GetProcessTimes(proc, &c, &e, &k, &u);
4559 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4561 return av_gettime();
4565 static int64_t getmaxrss(void)
4567 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4568 struct rusage rusage;
4569 getrusage(RUSAGE_SELF, &rusage);
4570 return (int64_t)rusage.ru_maxrss * 1024;
4571 #elif HAVE_GETPROCESSMEMORYINFO
4573 PROCESS_MEMORY_COUNTERS memcounters;
4574 proc = GetCurrentProcess();
4575 memcounters.cb = sizeof(memcounters);
4576 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4577 return memcounters.PeakPagefileUsage;
4583 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4585 return parse_option(o, "q:a", arg, options);
4588 static void show_usage(void)
4590 printf("Hyper fast Audio and Video encoder\n");
4591 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4595 static int opt_help(const char *opt, const char *arg)
4597 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4598 av_log_set_callback(log_callback_help);
4600 show_help_options(options, "Main options:\n",
4601 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4602 show_help_options(options, "\nAdvanced options:\n",
4603 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4605 show_help_options(options, "\nVideo options:\n",
4606 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4608 show_help_options(options, "\nAdvanced Video options:\n",
4609 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4610 OPT_VIDEO | OPT_EXPERT);
4611 show_help_options(options, "\nAudio options:\n",
4612 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4614 show_help_options(options, "\nAdvanced Audio options:\n",
4615 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4616 OPT_AUDIO | OPT_EXPERT);
4617 show_help_options(options, "\nSubtitle options:\n",
4618 OPT_SUBTITLE | OPT_GRAB,
4620 show_help_options(options, "\nAudio/Video grab options:\n",
4624 show_help_children(avcodec_get_class(), flags);
4625 show_help_children(avformat_get_class(), flags);
4626 show_help_children(sws_get_class(), flags);
4631 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4633 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4634 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4636 if (!strncmp(arg, "pal-", 4)) {
4639 } else if (!strncmp(arg, "ntsc-", 5)) {
4642 } else if (!strncmp(arg, "film-", 5)) {
4646 /* Try to determine PAL/NTSC by peeking in the input files */
4647 if (nb_input_files) {
4649 for (j = 0; j < nb_input_files; j++) {
4650 for (i = 0; i < input_files[j].nb_streams; i++) {
4651 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4652 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4654 fr = c->time_base.den * 1000 / c->time_base.num;
4658 } else if ((fr == 29970) || (fr == 23976)) {
4663 if (norm != UNKNOWN)
4667 if (norm != UNKNOWN)
4668 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4671 if (norm == UNKNOWN) {
4672 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4673 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4674 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4678 if (!strcmp(arg, "vcd")) {
4679 opt_video_codec(o, "c:v", "mpeg1video");
4680 opt_audio_codec(o, "c:a", "mp2");
4681 parse_option(o, "f", "vcd", options);
4683 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4684 parse_option(o, "r", frame_rates[norm], options);
4685 opt_default("g", norm == PAL ? "15" : "18");
4687 opt_default("b:v", "1150000");
4688 opt_default("maxrate", "1150000");
4689 opt_default("minrate", "1150000");
4690 opt_default("bufsize", "327680"); // 40*1024*8;
4692 opt_default("b:a", "224000");
4693 parse_option(o, "ar", "44100", options);
4694 parse_option(o, "ac", "2", options);
4696 opt_default("packetsize", "2324");
4697 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4699 /* We have to offset the PTS, so that it is consistent with the SCR.
4700 SCR starts at 36000, but the first two packs contain only padding
4701 and the first pack from the other stream, respectively, may also have
4702 been written before.
4703 So the real data starts at SCR 36000+3*1200. */
4704 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4705 } else if (!strcmp(arg, "svcd")) {
4707 opt_video_codec(o, "c:v", "mpeg2video");
4708 opt_audio_codec(o, "c:a", "mp2");
4709 parse_option(o, "f", "svcd", options);
4711 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4712 parse_option(o, "r", frame_rates[norm], options);
4713 parse_option(o, "pix_fmt", "yuv420p", options);
4714 opt_default("g", norm == PAL ? "15" : "18");
4716 opt_default("b:v", "2040000");
4717 opt_default("maxrate", "2516000");
4718 opt_default("minrate", "0"); // 1145000;
4719 opt_default("bufsize", "1835008"); // 224*1024*8;
4720 opt_default("flags", "+scan_offset");
4723 opt_default("b:a", "224000");
4724 parse_option(o, "ar", "44100", options);
4726 opt_default("packetsize", "2324");
4728 } else if (!strcmp(arg, "dvd")) {
4730 opt_video_codec(o, "c:v", "mpeg2video");
4731 opt_audio_codec(o, "c:a", "ac3");
4732 parse_option(o, "f", "dvd", options);
4734 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4735 parse_option(o, "r", frame_rates[norm], options);
4736 parse_option(o, "pix_fmt", "yuv420p", options);
4737 opt_default("g", norm == PAL ? "15" : "18");
4739 opt_default("b:v", "6000000");
4740 opt_default("maxrate", "9000000");
4741 opt_default("minrate", "0"); // 1500000;
4742 opt_default("bufsize", "1835008"); // 224*1024*8;
4744 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4745 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4747 opt_default("b:a", "448000");
4748 parse_option(o, "ar", "48000", options);
4750 } else if (!strncmp(arg, "dv", 2)) {
4752 parse_option(o, "f", "dv", options);
4754 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4755 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4756 norm == PAL ? "yuv420p" : "yuv411p", options);
4757 parse_option(o, "r", frame_rates[norm], options);
4759 parse_option(o, "ar", "48000", options);
4760 parse_option(o, "ac", "2", options);
4763 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4764 return AVERROR(EINVAL);
4769 static int opt_vstats_file(const char *opt, const char *arg)
4771 av_free (vstats_filename);
4772 vstats_filename = av_strdup (arg);
4776 static int opt_vstats(const char *opt, const char *arg)
4779 time_t today2 = time(NULL);
4780 struct tm *today = localtime(&today2);
4782 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4784 return opt_vstats_file(opt, filename);
4787 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4789 return parse_option(o, "frames:v", arg, options);
4792 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4794 return parse_option(o, "frames:a", arg, options);
4797 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4799 return parse_option(o, "frames:d", arg, options);
4802 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4805 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4806 const char *codec_name = *opt == 'v' ? video_codec_name :
4807 *opt == 'a' ? audio_codec_name :
4808 subtitle_codec_name;
4810 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4811 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4812 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4814 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4819 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4820 if(line[0] == '#' && !e)
4822 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4824 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4827 if(!strcmp(tmp, "acodec")){
4828 opt_audio_codec(o, tmp, tmp2);
4829 }else if(!strcmp(tmp, "vcodec")){
4830 opt_video_codec(o, tmp, tmp2);
4831 }else if(!strcmp(tmp, "scodec")){
4832 opt_subtitle_codec(o, tmp, tmp2);
4833 }else if(!strcmp(tmp, "dcodec")){
4834 opt_data_codec(o, tmp, tmp2);
4835 }else if(opt_default(tmp, tmp2) < 0){
4836 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4846 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4850 static int opt_passlogfile(const char *opt, const char *arg)
4852 pass_logfilename_prefix = arg;
4853 #if CONFIG_LIBX264_ENCODER
4854 return opt_default("passlogfile", arg);
4860 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4862 char *s= av_malloc(strlen(opt)+2);
4863 snprintf(s, strlen(opt)+2, "%s:%c", opt+1, *opt);
4864 return parse_option(o, s, arg, options);
4867 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4869 if(!strcmp(opt, "b")){
4870 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4871 return parse_option(o, av_strdup("b:v"), arg, options);
4873 return opt_default(opt, arg);
4876 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4878 return parse_option(o, "filter:v", arg, options);
4881 static int opt_vsync(const char *opt, const char *arg)
4883 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
4884 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
4885 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4887 if (video_sync_method == VSYNC_AUTO)
4888 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4892 #define OFFSET(x) offsetof(OptionsContext, x)
4893 static const OptionDef options[] = {
4895 #include "cmdutils_common_opts.h"
4896 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4897 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4898 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4899 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4900 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4901 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4902 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4903 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4904 { "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]" },
4905 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4906 "outfile[,metadata]:infile[,metadata]" },
4907 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4908 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4909 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4910 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4911 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4912 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4913 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4914 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4915 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4916 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4917 "add timings for benchmarking" },
4918 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4919 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4920 "dump each input packet" },
4921 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4922 "when dumping packets, also dump the payload" },
4923 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4924 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4925 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4926 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4927 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4928 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4929 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4930 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4931 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
4932 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4933 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4934 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4935 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4936 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4937 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4938 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4939 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4941 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4943 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4944 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4945 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4948 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4949 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4950 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4951 { "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" },
4952 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4953 { "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" },
4954 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4955 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4956 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4957 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4958 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4959 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4960 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4961 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4962 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4963 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4964 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
4965 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4966 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
4967 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4968 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4969 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
4970 "use same quantizer as source (implies VBR)" },
4971 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4972 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4973 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4974 "deinterlace pictures" },
4975 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4976 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4977 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4979 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
4981 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
4982 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
4983 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
4984 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4985 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
4986 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4987 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
4988 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4989 { "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" },
4990 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
4993 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
4994 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
4995 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
4996 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
4997 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
4998 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4999 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5000 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5001 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5002 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
5004 /* subtitle options */
5005 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5006 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5007 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5010 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5011 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5012 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5015 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5016 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5018 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5019 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5020 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5022 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5023 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5024 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5025 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5026 /* data codec support */
5027 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5028 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5030 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5034 int main(int argc, char **argv)
5036 OptionsContext o = { 0 };
5039 reset_options(&o, 0);
5041 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5042 parse_loglevel(argc, argv, options);
5044 if(argc>1 && !strcmp(argv[1], "-d")){
5046 av_log_set_callback(log_callback_null);
5051 avcodec_register_all();
5053 avdevice_register_all();
5056 avfilter_register_all();
5059 avformat_network_init();
5061 show_banner(argc, argv, options);
5066 parse_options(&o, argc, argv, options, opt_output_file);
5068 if (nb_output_files <= 0 && nb_input_files == 0) {
5070 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5074 /* file converter / grab */
5075 if (nb_output_files <= 0) {
5076 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5080 if (nb_input_files == 0) {
5081 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5086 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
5088 ti = getutime() - ti;
5090 int maxrss = getmaxrss() / 1024;
5091 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);