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 qp_hist = 0;
137 static int intra_only = 0;
138 static const char *video_codec_name = NULL;
139 static const char *audio_codec_name = NULL;
140 static const char *subtitle_codec_name = NULL;
142 static int file_overwrite = 0;
143 static int no_file_overwrite = 0;
144 static int do_benchmark = 0;
145 static int do_hex_dump = 0;
146 static int do_pkt_dump = 0;
147 static int do_psnr = 0;
148 static int do_pass = 0;
149 static const char *pass_logfilename_prefix;
150 static int video_sync_method = VSYNC_AUTO;
151 static int audio_sync_method = 0;
152 static float audio_drift_threshold = 0.1;
153 static int copy_ts = 0;
154 static int copy_tb = -1;
155 static int opt_shortest = 0;
156 static char *vstats_filename;
157 static FILE *vstats_file;
159 static int audio_volume = 256;
161 static int exit_on_error = 0;
162 static int using_stdin = 0;
163 static int run_as_daemon = 0;
164 static volatile int received_nb_signals = 0;
165 static int64_t video_size = 0;
166 static int64_t audio_size = 0;
167 static int64_t extra_size = 0;
168 static int nb_frames_dup = 0;
169 static int nb_frames_drop = 0;
170 static int input_sync;
172 static float dts_delta_threshold = 10;
174 static int print_stats = 1;
176 static uint8_t *audio_buf;
177 static unsigned int allocated_audio_buf_size;
179 static uint8_t *input_tmp= NULL;
181 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
183 typedef struct FrameBuffer {
189 enum PixelFormat pix_fmt;
192 struct InputStream *ist;
193 struct FrameBuffer *next;
196 typedef struct InputStream {
199 int discard; /* true if stream data should be discarded */
200 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
202 AVFrame *decoded_frame;
203 AVFrame *filtered_frame;
205 int64_t start; /* time when read started */
206 int64_t next_pts; /* synthetic pts for cases where pkt.pts
208 int64_t pts; /* current pts */
210 int is_start; /* is 1 at the start and after a discontinuity */
211 int showed_multi_packet_warning;
214 /* a pool of free buffers for decoded data */
215 FrameBuffer *buffer_pool;
219 typedef struct InputFile {
220 AVFormatContext *ctx;
221 int eof_reached; /* true if eof reached */
222 int ist_index; /* index of first stream in input_streams */
223 int buffer_size; /* current total buffer size */
225 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
226 from ctx.nb_streams if new streams appear during av_read_frame() */
230 typedef struct OutputStream {
231 int file_index; /* file index */
232 int index; /* stream index in the output file */
233 int source_index; /* InputStream index */
234 AVStream *st; /* stream in the output file */
235 int encoding_needed; /* true if encoding needed for this stream */
237 /* input pts and corresponding output pts
239 struct InputStream *sync_ist; /* input stream to sync against */
240 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
241 AVBitStreamFilterContext *bitstream_filters;
244 AVFrame *output_frame;
248 AVFrame resample_frame; /* temporary frame for image resampling */
249 struct SwsContext *img_resample_ctx; /* for image resampling */
252 int resample_pix_fmt;
253 AVRational frame_rate;
257 float frame_aspect_ratio;
259 /* forced key frames */
260 int64_t *forced_kf_pts;
266 int audio_channels_map[SWR_CH_MAX]; ///< list of the channels id to pick from the source stream
267 int audio_channels_mapped; ///< number of channels in audio_channels_map
268 int resample_sample_fmt;
269 int resample_channels;
270 int resample_sample_rate;
271 float rematrix_volume;
272 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
275 struct SwrContext *swr;
278 AVFilterContext *output_video_filter;
279 AVFilterContext *input_video_filter;
280 AVFilterBufferRef *picref;
282 AVFilterGraph *graph;
287 int is_past_recording_time;
289 const char *attachment_filename;
290 int copy_initial_nonkeyframes;
296 /* init terminal so that we can grab keys */
297 static struct termios oldtty;
298 static int restore_tty;
301 typedef struct OutputFile {
302 AVFormatContext *ctx;
304 int ost_index; /* index of the first stream in output_streams */
305 int64_t recording_time; /* desired length of the resulting file in microseconds */
306 int64_t start_time; /* start time in microseconds */
307 uint64_t limit_filesize;
310 static InputStream *input_streams = NULL;
311 static int nb_input_streams = 0;
312 static InputFile *input_files = NULL;
313 static int nb_input_files = 0;
315 static OutputStream *output_streams = NULL;
316 static int nb_output_streams = 0;
317 static OutputFile *output_files = NULL;
318 static int nb_output_files = 0;
320 typedef struct OptionsContext {
321 /* input/output options */
325 SpecifierOpt *codec_names;
327 SpecifierOpt *audio_channels;
328 int nb_audio_channels;
329 SpecifierOpt *audio_sample_rate;
330 int nb_audio_sample_rate;
331 SpecifierOpt *rematrix_volume;
332 int nb_rematrix_volume;
333 SpecifierOpt *frame_rates;
335 SpecifierOpt *frame_sizes;
337 SpecifierOpt *frame_pix_fmts;
338 int nb_frame_pix_fmts;
341 int64_t input_ts_offset;
344 SpecifierOpt *ts_scale;
346 SpecifierOpt *dump_attachment;
347 int nb_dump_attachment;
350 StreamMap *stream_maps;
352 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
353 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
354 /* first item specifies output metadata, second is input */
355 MetadataMap (*meta_data_maps)[2];
356 int nb_meta_data_maps;
357 int metadata_global_manual;
358 int metadata_streams_manual;
359 int metadata_chapters_manual;
360 const char **attachments;
363 int chapters_input_file;
365 int64_t recording_time;
366 uint64_t limit_filesize;
372 int subtitle_disable;
375 /* indexed by output file stream index */
379 SpecifierOpt *metadata;
381 SpecifierOpt *max_frames;
383 SpecifierOpt *bitstream_filters;
384 int nb_bitstream_filters;
385 SpecifierOpt *codec_tags;
387 SpecifierOpt *sample_fmts;
389 SpecifierOpt *qscale;
391 SpecifierOpt *forced_key_frames;
392 int nb_forced_key_frames;
393 SpecifierOpt *force_fps;
395 SpecifierOpt *frame_aspect_ratios;
396 int nb_frame_aspect_ratios;
397 SpecifierOpt *rc_overrides;
399 SpecifierOpt *intra_matrices;
400 int nb_intra_matrices;
401 SpecifierOpt *inter_matrices;
402 int nb_inter_matrices;
403 SpecifierOpt *top_field_first;
404 int nb_top_field_first;
405 SpecifierOpt *metadata_map;
407 SpecifierOpt *presets;
409 SpecifierOpt *copy_initial_nonkeyframes;
410 int nb_copy_initial_nonkeyframes;
412 SpecifierOpt *filters;
417 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
420 for (i = 0; i < o->nb_ ## name; i++) {\
421 char *spec = o->name[i].specifier;\
422 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
423 outvar = o->name[i].u.type;\
429 static void reset_options(OptionsContext *o, int is_input)
431 const OptionDef *po = options;
432 OptionsContext bak= *o;
434 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
436 void *dst = (uint8_t*)o + po->u.off;
438 if (po->flags & OPT_SPEC) {
439 SpecifierOpt **so = dst;
440 int i, *count = (int*)(so + 1);
441 for (i = 0; i < *count; i++) {
442 av_freep(&(*so)[i].specifier);
443 if (po->flags & OPT_STRING)
444 av_freep(&(*so)[i].u.str);
448 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
453 av_freep(&o->stream_maps);
454 av_freep(&o->audio_channel_maps);
455 av_freep(&o->meta_data_maps);
456 av_freep(&o->streamid_map);
458 memset(o, 0, sizeof(*o));
460 if(is_input) o->recording_time = bak.recording_time;
461 else o->recording_time = INT64_MAX;
462 o->mux_max_delay = 0.7;
463 o->limit_filesize = UINT64_MAX;
464 o->chapters_input_file = INT_MAX;
470 static int alloc_buffer(AVCodecContext *s, InputStream *ist, FrameBuffer **pbuf)
472 FrameBuffer *buf = av_mallocz(sizeof(*buf));
474 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
475 int h_chroma_shift, v_chroma_shift;
476 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
477 int w = s->width, h = s->height;
480 return AVERROR(ENOMEM);
482 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
487 avcodec_align_dimensions(s, &w, &h);
488 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
489 s->pix_fmt, 32)) < 0) {
493 /* XXX this shouldn't be needed, but some tests break without this line
494 * those decoders are buggy and need to be fixed.
495 * the following tests fail:
496 * bethsoft-vid, cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
498 memset(buf->base[0], 128, ret);
500 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
501 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
502 const int h_shift = i==0 ? 0 : h_chroma_shift;
503 const int v_shift = i==0 ? 0 : v_chroma_shift;
504 if (s->flags & CODEC_FLAG_EMU_EDGE)
505 buf->data[i] = buf->base[i];
507 buf->data[i] = buf->base[i] +
508 FFALIGN((buf->linesize[i]*edge >> v_shift) +
509 (pixel_size*edge >> h_shift), 32);
513 buf->pix_fmt = s->pix_fmt;
520 static void free_buffer_pool(InputStream *ist)
522 FrameBuffer *buf = ist->buffer_pool;
524 ist->buffer_pool = buf->next;
525 av_freep(&buf->base[0]);
527 buf = ist->buffer_pool;
531 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
533 av_assert0(buf->refcount);
535 if (!buf->refcount) {
536 buf->next = ist->buffer_pool;
537 ist->buffer_pool = buf;
541 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
543 InputStream *ist = s->opaque;
547 if(av_image_check_size(s->width, s->height, 0, s))
550 if (!ist->buffer_pool && (ret = alloc_buffer(s, 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(s, 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);
631 #if FF_API_OLD_VSINK_API
632 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
633 "out", NULL, pix_fmts, ost->graph);
635 buffersink_params->pixel_fmts = pix_fmts;
636 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
637 "out", NULL, buffersink_params, ost->graph);
639 av_freep(&buffersink_params);
643 last_filter = ost->input_video_filter;
645 if (codec->width != icodec->width || codec->height != icodec->height) {
646 snprintf(args, 255, "%d:%d:flags=0x%X",
649 (unsigned)ost->sws_flags);
650 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
651 NULL, args, NULL, ost->graph)) < 0)
653 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
655 last_filter = filter;
658 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
659 ost->graph->scale_sws_opts = av_strdup(args);
662 AVFilterInOut *outputs = avfilter_inout_alloc();
663 AVFilterInOut *inputs = avfilter_inout_alloc();
665 outputs->name = av_strdup("in");
666 outputs->filter_ctx = last_filter;
667 outputs->pad_idx = 0;
668 outputs->next = NULL;
670 inputs->name = av_strdup("out");
671 inputs->filter_ctx = ost->output_video_filter;
675 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
677 av_freep(&ost->avfilter);
679 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
683 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
686 codec->width = ost->output_video_filter->inputs[0]->w;
687 codec->height = ost->output_video_filter->inputs[0]->h;
688 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
689 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
690 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
691 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
695 #endif /* CONFIG_AVFILTER */
697 static void term_exit(void)
699 av_log(NULL, AV_LOG_QUIET, "%s", "");
702 tcsetattr (0, TCSANOW, &oldtty);
706 static volatile int received_sigterm = 0;
708 static void sigterm_handler(int sig)
710 received_sigterm = sig;
711 received_nb_signals++;
713 if(received_nb_signals > 3)
717 static void term_init(void)
723 if (tcgetattr (0, &tty) == 0) {
728 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
729 |INLCR|IGNCR|ICRNL|IXON);
730 tty.c_oflag |= OPOST;
731 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
732 tty.c_cflag &= ~(CSIZE|PARENB);
737 tcsetattr (0, TCSANOW, &tty);
739 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
742 avformat_network_deinit();
744 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
745 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
747 signal(SIGXCPU, sigterm_handler);
751 /* read a key without blocking */
752 static int read_key(void)
764 n = select(1, &rfds, NULL, NULL, &tv);
773 # if HAVE_PEEKNAMEDPIPE
775 static HANDLE input_handle;
778 input_handle = GetStdHandle(STD_INPUT_HANDLE);
779 is_pipe = !GetConsoleMode(input_handle, &dw);
782 if (stdin->_cnt > 0) {
787 /* When running under a GUI, you will end here. */
788 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
805 static int decode_interrupt_cb(void *ctx)
807 return received_nb_signals > 1;
810 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
812 void av_noreturn exit_program(int ret)
817 for (i = 0; i < nb_output_files; i++) {
818 AVFormatContext *s = output_files[i].ctx;
819 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
821 avformat_free_context(s);
822 av_dict_free(&output_files[i].opts);
824 for (i = 0; i < nb_output_streams; i++) {
825 AVBitStreamFilterContext *bsfc = output_streams[i].bitstream_filters;
827 AVBitStreamFilterContext *next = bsfc->next;
828 av_bitstream_filter_close(bsfc);
831 output_streams[i].bitstream_filters = NULL;
833 if (output_streams[i].output_frame) {
834 AVFrame *frame = output_streams[i].output_frame;
835 if (frame->extended_data != frame->data)
836 av_freep(&frame->extended_data);
840 for (i = 0; i < nb_input_files; i++) {
841 avformat_close_input(&input_files[i].ctx);
843 for (i = 0; i < nb_input_streams; i++) {
844 av_freep(&input_streams[i].decoded_frame);
845 av_freep(&input_streams[i].filtered_frame);
846 av_dict_free(&input_streams[i].opts);
847 free_buffer_pool(&input_streams[i]);
852 av_free(vstats_filename);
854 av_freep(&input_streams);
855 av_freep(&input_files);
856 av_freep(&output_streams);
857 av_freep(&output_files);
861 allocated_audio_buf_size = 0;
866 avformat_network_deinit();
868 av_freep(&input_tmp);
870 if (received_sigterm) {
871 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
872 (int) received_sigterm);
876 exit(ret); /* not all OS-es handle main() return value */
879 static void assert_avoptions(AVDictionary *m)
881 AVDictionaryEntry *t;
882 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
883 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
888 static void assert_codec_experimental(AVCodecContext *c, int encoder)
890 const char *codec_string = encoder ? "encoder" : "decoder";
892 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
893 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
894 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
895 "results.\nAdd '-strict experimental' if you want to use it.\n",
896 codec_string, c->codec->name);
897 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
898 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
899 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
900 codec_string, codec->name);
905 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
907 if (codec && codec->sample_fmts) {
908 const enum AVSampleFormat *p = codec->sample_fmts;
909 for (; *p != -1; p++) {
910 if (*p == st->codec->sample_fmt)
914 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
915 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
916 if(av_get_sample_fmt_name(st->codec->sample_fmt))
917 av_log(NULL, AV_LOG_WARNING,
918 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
919 av_get_sample_fmt_name(st->codec->sample_fmt),
921 av_get_sample_fmt_name(codec->sample_fmts[0]));
922 st->codec->sample_fmt = codec->sample_fmts[0];
927 static void choose_sample_rate(AVStream *st, AVCodec *codec)
929 if (codec && codec->supported_samplerates) {
930 const int *p = codec->supported_samplerates;
932 int best_dist = INT_MAX;
934 int dist = abs(st->codec->sample_rate - *p);
935 if (dist < best_dist) {
941 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
943 st->codec->sample_rate = best;
947 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
949 if (codec && codec->pix_fmts) {
950 const enum PixelFormat *p = codec->pix_fmts;
951 int has_alpha= av_pix_fmt_descriptors[st->codec->pix_fmt].nb_components % 2 == 0;
952 enum PixelFormat best= PIX_FMT_NONE;
953 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
954 if (st->codec->codec_id == CODEC_ID_MJPEG) {
955 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
956 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
957 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
958 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
961 for (; *p != PIX_FMT_NONE; p++) {
962 best= avcodec_find_best_pix_fmt2(best, *p, st->codec->pix_fmt, has_alpha, NULL);
963 if (*p == st->codec->pix_fmt)
966 if (*p == PIX_FMT_NONE) {
967 if (st->codec->pix_fmt != PIX_FMT_NONE)
968 av_log(NULL, AV_LOG_WARNING,
969 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
970 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
972 av_pix_fmt_descriptors[best].name);
973 st->codec->pix_fmt = best;
978 static double get_sync_ipts(const OutputStream *ost)
980 const InputStream *ist = ost->sync_ist;
981 OutputFile *of = &output_files[ost->file_index];
982 return (double)(ist->pts - of->start_time) / AV_TIME_BASE;
985 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
987 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
988 AVCodecContext *avctx = ost->st->codec;
992 * Audio encoders may split the packets -- #frames in != #packets out.
993 * But there is no reordering, so we can limit the number of output packets
994 * by simply dropping them here.
995 * Counting encoded video frames needs to be done separately because of
996 * reordering, see do_video_out()
998 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
999 if (ost->frame_number >= ost->max_frames)
1001 ost->frame_number++;
1005 AVPacket new_pkt = *pkt;
1006 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1007 &new_pkt.data, &new_pkt.size,
1008 pkt->data, pkt->size,
1009 pkt->flags & AV_PKT_FLAG_KEY);
1011 av_free_packet(pkt);
1012 new_pkt.destruct = av_destruct_packet;
1014 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1015 bsfc->filter->name, pkt->stream_index,
1016 avctx->codec ? avctx->codec->name : "copy");
1026 ret = av_interleaved_write_frame(s, pkt);
1028 print_error("av_interleaved_write_frame()", ret);
1033 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1035 int fill_char = 0x00;
1036 if (sample_fmt == AV_SAMPLE_FMT_U8)
1038 memset(buf, fill_char, size);
1041 static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,
1042 const uint8_t *buf, int buf_size)
1044 AVCodecContext *enc = ost->st->codec;
1045 AVFrame *frame = NULL;
1047 int ret, got_packet;
1049 av_init_packet(&pkt);
1054 if (!ost->output_frame) {
1055 ost->output_frame = avcodec_alloc_frame();
1056 if (!ost->output_frame) {
1057 av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");
1061 frame = ost->output_frame;
1062 if (frame->extended_data != frame->data)
1063 av_freep(&frame->extended_data);
1064 avcodec_get_frame_defaults(frame);
1066 frame->nb_samples = buf_size /
1067 (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
1068 if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,
1069 buf, buf_size, 1)) < 0) {
1070 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1076 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1077 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1084 pkt.stream_index = ost->index;
1085 if (pkt.pts != AV_NOPTS_VALUE)
1086 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1087 if (pkt.duration > 0)
1088 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1090 write_frame(s, &pkt, ost);
1092 audio_size += pkt.size;
1094 av_free_packet(&pkt);
1098 ost->sync_opts += frame->nb_samples;
1103 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1104 InputStream *ist, AVFrame *decoded_frame)
1107 int64_t audio_buf_size, size_out;
1109 int frame_bytes, resample_changed;
1110 AVCodecContext *enc = ost->st->codec;
1111 AVCodecContext *dec = ist->st->codec;
1112 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1113 int isize = av_get_bytes_per_sample(dec->sample_fmt);
1114 uint8_t *buf = decoded_frame->data[0];
1115 int size = decoded_frame->nb_samples * dec->channels * isize;
1116 int64_t allocated_for_size = size;
1119 audio_buf_size = (allocated_for_size + isize * dec->channels - 1) / (isize * dec->channels);
1120 audio_buf_size = (audio_buf_size * enc->sample_rate + dec->sample_rate) / dec->sample_rate;
1121 audio_buf_size = audio_buf_size * 2 + 10000; // safety factors for the deprecated resampling API
1122 audio_buf_size = FFMAX(audio_buf_size, enc->frame_size);
1123 audio_buf_size *= osize * enc->channels;
1125 if (audio_buf_size > INT_MAX) {
1126 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
1130 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
1132 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1136 if (enc->channels != dec->channels
1137 || enc->sample_fmt != dec->sample_fmt
1138 || enc->sample_rate!= dec->sample_rate
1140 ost->audio_resample = 1;
1142 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1143 ost->resample_channels != dec->channels ||
1144 ost->resample_sample_rate != dec->sample_rate;
1146 if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
1147 if (resample_changed) {
1148 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",
1149 ist->file_index, ist->st->index,
1150 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
1151 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
1152 ost->resample_sample_fmt = dec->sample_fmt;
1153 ost->resample_channels = dec->channels;
1154 ost->resample_sample_rate = dec->sample_rate;
1155 swr_free(&ost->swr);
1157 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1158 if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
1159 ost->resample_sample_fmt == enc->sample_fmt &&
1160 ost->resample_channels == enc->channels &&
1161 ost->resample_sample_rate == enc->sample_rate) {
1163 ost->audio_resample = 0;
1165 ost->swr = swr_alloc_set_opts(ost->swr,
1166 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
1167 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
1169 if (ost->audio_channels_mapped)
1170 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
1171 av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
1172 if (ost->audio_channels_mapped) {
1173 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
1174 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
1176 if (av_opt_set_int(ost->swr, "ich", dec->channels, 0) < 0) {
1177 av_log(NULL, AV_LOG_FATAL, "Unsupported number of input channels\n");
1180 if (av_opt_set_int(ost->swr, "och", enc->channels, 0) < 0) {
1181 av_log(NULL, AV_LOG_FATAL, "Unsupported number of output channels\n");
1184 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
1185 if(ost->swr && swr_init(ost->swr) < 0){
1186 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
1187 swr_free(&ost->swr);
1191 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1192 dec->channels, dec->sample_rate,
1193 enc->channels, enc->sample_rate);
1199 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1201 if (audio_sync_method) {
1202 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts -
1203 av_fifo_size(ost->fifo) / (enc->channels * osize);
1204 int idelta = delta * dec->sample_rate / enc->sample_rate;
1205 int byte_delta = idelta * isize * dec->channels;
1207 // FIXME resample delay
1208 if (fabs(delta) > 50) {
1209 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1210 if (byte_delta < 0) {
1211 byte_delta = FFMAX(byte_delta, -size);
1214 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1215 -byte_delta / (isize * dec->channels));
1220 input_tmp = av_realloc(input_tmp, byte_delta + size);
1222 if (byte_delta > allocated_for_size - size) {
1223 allocated_for_size = byte_delta + (int64_t)size;
1228 generate_silence(input_tmp, dec->sample_fmt, byte_delta);
1229 memcpy(input_tmp + byte_delta, buf, size);
1232 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1234 } else if (audio_sync_method > 1) {
1235 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1236 av_assert0(ost->audio_resample);
1237 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1238 delta, comp, enc->sample_rate);
1239 // 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));
1240 swr_set_compensation(ost->swr, comp, enc->sample_rate);
1244 ost->sync_opts = lrintf(get_sync_ipts(ost) * enc->sample_rate) -
1245 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1247 if (ost->audio_resample) {
1249 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, audio_buf_size / (enc->channels * osize),
1250 (const uint8_t*[]){buf }, size / (dec->channels * isize));
1251 size_out = size_out * enc->channels * osize;
1257 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1259 /* now encode as many frames as possible */
1260 if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1261 /* output resampled raw samples */
1262 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1263 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1266 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1268 frame_bytes = enc->frame_size * osize * enc->channels;
1270 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1271 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1272 encode_audio_frame(s, ost, audio_buf, frame_bytes);
1275 encode_audio_frame(s, ost, buftmp, size_out);
1279 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1281 AVCodecContext *dec;
1282 AVPicture *picture2;
1283 AVPicture picture_tmp;
1286 dec = ist->st->codec;
1288 /* deinterlace : must be done before any resize */
1289 if (do_deinterlace) {
1292 /* create temporary picture */
1293 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1294 buf = av_malloc(size);
1298 picture2 = &picture_tmp;
1299 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1301 if (avpicture_deinterlace(picture2, picture,
1302 dec->pix_fmt, dec->width, dec->height) < 0) {
1303 /* if error, do not deinterlace */
1304 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1313 if (picture != picture2)
1314 *picture = *picture2;
1318 static void do_subtitle_out(AVFormatContext *s,
1324 static uint8_t *subtitle_out = NULL;
1325 int subtitle_out_max_size = 1024 * 1024;
1326 int subtitle_out_size, nb, i;
1327 AVCodecContext *enc;
1330 if (pts == AV_NOPTS_VALUE) {
1331 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1337 enc = ost->st->codec;
1339 if (!subtitle_out) {
1340 subtitle_out = av_malloc(subtitle_out_max_size);
1343 /* Note: DVB subtitle need one packet to draw them and one other
1344 packet to clear them */
1345 /* XXX: signal it in the codec context ? */
1346 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1351 for (i = 0; i < nb; i++) {
1352 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1353 // start_display_time is required to be 0
1354 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1355 sub->end_display_time -= sub->start_display_time;
1356 sub->start_display_time = 0;
1357 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1358 subtitle_out_max_size, sub);
1359 if (subtitle_out_size < 0) {
1360 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1364 av_init_packet(&pkt);
1365 pkt.stream_index = ost->index;
1366 pkt.data = subtitle_out;
1367 pkt.size = subtitle_out_size;
1368 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1369 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1370 /* XXX: the pts correction is handled here. Maybe handling
1371 it in the codec would be better */
1373 pkt.pts += 90 * sub->start_display_time;
1375 pkt.pts += 90 * sub->end_display_time;
1377 write_frame(s, &pkt, ost);
1381 static int bit_buffer_size = 1024 * 256;
1382 static uint8_t *bit_buffer = NULL;
1384 static void do_video_resample(OutputStream *ost,
1386 AVFrame *in_picture,
1387 AVFrame **out_picture)
1390 *out_picture = in_picture;
1392 AVCodecContext *dec = ist->st->codec;
1393 AVCodecContext *enc = ost->st->codec;
1394 int resample_changed = ost->resample_width != in_picture->width ||
1395 ost->resample_height != in_picture->height ||
1396 ost->resample_pix_fmt != in_picture->format;
1398 *out_picture = in_picture;
1399 if (resample_changed) {
1400 av_log(NULL, AV_LOG_INFO,
1401 "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s / frm size:%dx%d fmt:%s\n",
1402 ist->file_index, ist->st->index,
1403 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1404 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt),
1405 in_picture->width, in_picture->height, av_get_pix_fmt_name(in_picture->format));
1406 ost->resample_width = in_picture->width;
1407 ost->resample_height = in_picture->height;
1408 ost->resample_pix_fmt = in_picture->format;
1411 ost->video_resample = in_picture->width != enc->width ||
1412 in_picture->height != enc->height ||
1413 in_picture->format != enc->pix_fmt;
1415 if (ost->video_resample) {
1416 *out_picture = &ost->resample_frame;
1417 if (!ost->img_resample_ctx || resample_changed) {
1418 /* initialize the destination picture */
1419 if (!ost->resample_frame.data[0]) {
1420 avcodec_get_frame_defaults(&ost->resample_frame);
1421 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1422 enc->width, enc->height)) {
1423 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1427 /* initialize a new scaler context */
1428 sws_freeContext(ost->img_resample_ctx);
1429 ost->img_resample_ctx = sws_getContext(in_picture->width, in_picture->height, in_picture->format,
1430 enc->width, enc->height, enc->pix_fmt,
1431 ost->sws_flags, NULL, NULL, NULL);
1432 if (ost->img_resample_ctx == NULL) {
1433 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1437 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1438 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1444 static void do_video_out(AVFormatContext *s,
1447 AVFrame *in_picture,
1448 int *frame_size, float quality)
1450 int nb_frames, i, ret, format_video_sync;
1451 AVFrame *final_picture;
1452 AVCodecContext *enc;
1454 double duration = 0;
1456 enc = ost->st->codec;
1458 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1459 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1460 if(ist->st->avg_frame_rate.num)
1461 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1463 duration /= av_q2d(enc->time_base);
1466 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1468 /* by default, we output a single frame */
1473 format_video_sync = video_sync_method;
1474 if (format_video_sync == VSYNC_AUTO)
1475 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1477 if (format_video_sync != VSYNC_PASSTHROUGH) {
1478 double vdelta = sync_ipts - ost->sync_opts + duration;
1479 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1482 else if (format_video_sync == VSYNC_VFR) {
1483 if (vdelta <= -0.6) {
1485 } else if (vdelta > 0.6)
1486 ost->sync_opts = lrintf(sync_ipts);
1487 } else if (vdelta > 1.1)
1488 nb_frames = lrintf(vdelta);
1489 //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);
1490 if (nb_frames == 0) {
1492 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1493 } else if (nb_frames > 1) {
1494 nb_frames_dup += nb_frames - 1;
1495 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1498 ost->sync_opts = lrintf(sync_ipts);
1500 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1504 do_video_resample(ost, ist, in_picture, &final_picture);
1506 /* duplicates frame if needed */
1507 for (i = 0; i < nb_frames; i++) {
1509 av_init_packet(&pkt);
1510 pkt.stream_index = ost->index;
1512 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1513 enc->codec->id == CODEC_ID_RAWVIDEO) {
1514 /* raw pictures are written as AVPicture structure to
1515 avoid any copies. We support temporarily the older
1517 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1518 enc->coded_frame->top_field_first = in_picture->top_field_first;
1519 pkt.data = (uint8_t *)final_picture;
1520 pkt.size = sizeof(AVPicture);
1521 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1522 pkt.flags |= AV_PKT_FLAG_KEY;
1524 write_frame(s, &pkt, ost);
1526 AVFrame big_picture;
1528 big_picture = *final_picture;
1529 /* better than nothing: use input picture interlaced
1531 big_picture.interlaced_frame = in_picture->interlaced_frame;
1532 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1533 if (ost->top_field_first == -1)
1534 big_picture.top_field_first = in_picture->top_field_first;
1536 big_picture.top_field_first = !!ost->top_field_first;
1539 /* handles same_quant here. This is not correct because it may
1540 not be a global option */
1541 big_picture.quality = quality;
1542 if (!enc->me_threshold)
1543 big_picture.pict_type = 0;
1544 // big_picture.pts = AV_NOPTS_VALUE;
1545 big_picture.pts = ost->sync_opts;
1546 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1547 // av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1548 if (ost->forced_kf_index < ost->forced_kf_count &&
1549 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1550 big_picture.pict_type = AV_PICTURE_TYPE_I;
1551 ost->forced_kf_index++;
1553 ret = avcodec_encode_video(enc,
1554 bit_buffer, bit_buffer_size,
1557 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1562 pkt.data = bit_buffer;
1564 if (enc->coded_frame->pts != AV_NOPTS_VALUE)
1565 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1566 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1567 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1568 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1570 if (enc->coded_frame->key_frame)
1571 pkt.flags |= AV_PKT_FLAG_KEY;
1572 write_frame(s, &pkt, ost);
1575 // fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1576 // enc->frame_number-1, ret, enc->pict_type);
1577 /* if two pass, output log */
1578 if (ost->logfile && enc->stats_out) {
1579 fprintf(ost->logfile, "%s", enc->stats_out);
1585 * For video, number of frames in == number of packets out.
1586 * But there may be reordering, so we can't throw away frames on encoder
1587 * flush, we need to limit them here, before they go into encoder.
1589 ost->frame_number++;
1593 static double psnr(double d)
1595 return -10.0 * log(d) / log(10.0);
1598 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1601 AVCodecContext *enc;
1603 double ti1, bitrate, avg_bitrate;
1605 /* this is executed just the first time do_video_stats is called */
1607 vstats_file = fopen(vstats_filename, "w");
1614 enc = ost->st->codec;
1615 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1616 frame_number = ost->frame_number;
1617 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1618 if (enc->flags&CODEC_FLAG_PSNR)
1619 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1621 fprintf(vstats_file,"f_size= %6d ", frame_size);
1622 /* compute pts value */
1623 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1627 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1628 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1629 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1630 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1631 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1635 static void print_report(OutputFile *output_files,
1636 OutputStream *ost_table, int nb_ostreams,
1637 int is_last_report, int64_t timer_start, int64_t cur_time)
1641 AVFormatContext *oc;
1643 AVCodecContext *enc;
1644 int frame_number, vid, i;
1646 int64_t pts = INT64_MAX;
1647 static int64_t last_time = -1;
1648 static int qp_histogram[52];
1649 int hours, mins, secs, us;
1651 if (!print_stats && !is_last_report)
1654 if (!is_last_report) {
1655 if (last_time == -1) {
1656 last_time = cur_time;
1659 if ((cur_time - last_time) < 500000)
1661 last_time = cur_time;
1665 oc = output_files[0].ctx;
1667 total_size = avio_size(oc->pb);
1668 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
1669 total_size = avio_tell(oc->pb);
1676 for (i = 0; i < nb_ostreams; i++) {
1678 ost = &ost_table[i];
1679 enc = ost->st->codec;
1680 if (!ost->stream_copy && enc->coded_frame)
1681 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1682 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1683 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1685 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1686 float t = (cur_time-timer_start) / 1000000.0;
1688 frame_number = ost->frame_number;
1689 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1690 frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
1692 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1696 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1698 for (j = 0; j < 32; j++)
1699 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1701 if (enc->flags&CODEC_FLAG_PSNR) {
1703 double error, error_sum = 0;
1704 double scale, scale_sum = 0;
1705 char type[3] = { 'Y','U','V' };
1706 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1707 for (j = 0; j < 3; j++) {
1708 if (is_last_report) {
1709 error = enc->error[j];
1710 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1712 error = enc->coded_frame->error[j];
1713 scale = enc->width * enc->height * 255.0 * 255.0;
1719 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1721 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1725 /* compute min output value */
1726 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1727 ost->st->time_base, AV_TIME_BASE_Q));
1730 secs = pts / AV_TIME_BASE;
1731 us = pts % AV_TIME_BASE;
1737 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1739 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1740 "size=%8.0fkB time=", total_size / 1024.0);
1741 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1742 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1743 (100 * us) / AV_TIME_BASE);
1744 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1745 "bitrate=%6.1fkbits/s", bitrate);
1747 if (nb_frames_dup || nb_frames_drop)
1748 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1749 nb_frames_dup, nb_frames_drop);
1751 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1755 if (is_last_report) {
1756 int64_t raw= audio_size + video_size + extra_size;
1757 av_log(NULL, AV_LOG_INFO, "\n");
1758 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1759 video_size / 1024.0,
1760 audio_size / 1024.0,
1761 extra_size / 1024.0,
1762 100.0 * (total_size - raw) / raw
1764 if(video_size + audio_size + extra_size == 0){
1765 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1770 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1774 for (i = 0; i < nb_ostreams; i++) {
1775 OutputStream *ost = &ost_table[i];
1776 AVCodecContext *enc = ost->st->codec;
1777 AVFormatContext *os = output_files[ost->file_index].ctx;
1778 int stop_encoding = 0;
1780 if (!ost->encoding_needed)
1783 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1785 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1791 av_init_packet(&pkt);
1795 switch (ost->st->codec->codec_type) {
1796 case AVMEDIA_TYPE_AUDIO:
1797 fifo_bytes = av_fifo_size(ost->fifo);
1798 if (fifo_bytes > 0) {
1799 /* encode any samples remaining in fifo */
1800 int frame_bytes = fifo_bytes;
1802 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1804 /* pad last frame with silence if needed */
1805 if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
1806 frame_bytes = enc->frame_size * enc->channels *
1807 av_get_bytes_per_sample(enc->sample_fmt);
1808 if (allocated_audio_buf_size < frame_bytes)
1810 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1812 encode_audio_frame(os, ost, audio_buf, frame_bytes);
1814 /* flush encoder with NULL frames until it is done
1815 returning packets */
1816 if (encode_audio_frame(os, ost, NULL, 0) == 0) {
1822 case AVMEDIA_TYPE_VIDEO:
1823 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1825 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1829 if (enc->coded_frame && enc->coded_frame->key_frame)
1830 pkt.flags |= AV_PKT_FLAG_KEY;
1831 if (ost->logfile && enc->stats_out) {
1832 fprintf(ost->logfile, "%s", enc->stats_out);
1838 pkt.stream_index = ost->index;
1839 pkt.data = bit_buffer;
1841 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1842 pkt.pts = av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1843 write_frame(os, &pkt, ost);
1855 * Check whether a packet from ist should be written into ost at this time
1857 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1859 OutputFile *of = &output_files[ost->file_index];
1860 int ist_index = ist - input_streams;
1862 if (ost->source_index != ist_index)
1865 if (of->start_time && ist->pts < of->start_time)
1868 if (of->recording_time != INT64_MAX &&
1869 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1870 (AVRational){ 1, 1000000 }) >= 0) {
1871 ost->is_past_recording_time = 1;
1878 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1880 OutputFile *of = &output_files[ost->file_index];
1881 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1885 av_init_packet(&opkt);
1887 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1888 !ost->copy_initial_nonkeyframes)
1891 /* force the input stream PTS */
1892 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1893 audio_size += pkt->size;
1894 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1895 video_size += pkt->size;
1899 opkt.stream_index = ost->index;
1900 if (pkt->pts != AV_NOPTS_VALUE)
1901 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1903 opkt.pts = AV_NOPTS_VALUE;
1905 if (pkt->dts == AV_NOPTS_VALUE)
1906 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1908 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1909 opkt.dts -= ost_tb_start_time;
1911 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1912 opkt.flags = pkt->flags;
1914 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1915 if ( ost->st->codec->codec_id != CODEC_ID_H264
1916 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1917 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1919 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1920 opkt.destruct = av_destruct_packet;
1922 opkt.data = pkt->data;
1923 opkt.size = pkt->size;
1925 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1926 /* store AVPicture in AVPacket, as expected by the output format */
1927 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1928 opkt.data = (uint8_t *)&pict;
1929 opkt.size = sizeof(AVPicture);
1930 opkt.flags |= AV_PKT_FLAG_KEY;
1933 write_frame(of->ctx, &opkt, ost);
1934 ost->st->codec->frame_number++;
1935 av_free_packet(&opkt);
1938 static void rate_emu_sleep(InputStream *ist)
1940 if (input_files[ist->file_index].rate_emu) {
1941 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1942 int64_t now = av_gettime() - ist->start;
1948 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1950 AVFrame *decoded_frame;
1951 AVCodecContext *avctx = ist->st->codec;
1952 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1955 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1956 return AVERROR(ENOMEM);
1958 avcodec_get_frame_defaults(ist->decoded_frame);
1959 decoded_frame = ist->decoded_frame;
1961 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1967 /* no audio frame */
1971 /* if the decoder provides a pts, use it instead of the last packet pts.
1972 the decoder could be delaying output by a packet or more. */
1973 if (decoded_frame->pts != AV_NOPTS_VALUE)
1974 ist->next_pts = decoded_frame->pts;
1976 /* increment next_pts to use for the case where the input stream does not
1977 have timestamps or there are multiple frames in the packet */
1978 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
1981 // preprocess audio (volume)
1982 if (audio_volume != 256) {
1983 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
1984 void *samples = decoded_frame->data[0];
1985 switch (avctx->sample_fmt) {
1986 case AV_SAMPLE_FMT_U8:
1988 uint8_t *volp = samples;
1989 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1990 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
1991 *volp++ = av_clip_uint8(v);
1995 case AV_SAMPLE_FMT_S16:
1997 int16_t *volp = samples;
1998 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
1999 int v = ((*volp) * audio_volume + 128) >> 8;
2000 *volp++ = av_clip_int16(v);
2004 case AV_SAMPLE_FMT_S32:
2006 int32_t *volp = samples;
2007 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2008 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
2009 *volp++ = av_clipl_int32(v);
2013 case AV_SAMPLE_FMT_FLT:
2015 float *volp = samples;
2016 float scale = audio_volume / 256.f;
2017 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2022 case AV_SAMPLE_FMT_DBL:
2024 double *volp = samples;
2025 double scale = audio_volume / 256.;
2026 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2032 av_log(NULL, AV_LOG_FATAL,
2033 "Audio volume adjustment on sample format %s is not supported.\n",
2034 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
2039 rate_emu_sleep(ist);
2041 for (i = 0; i < nb_output_streams; i++) {
2042 OutputStream *ost = &output_streams[i];
2044 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2046 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
2052 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts, int64_t *pkt_dts)
2054 AVFrame *decoded_frame, *filtered_frame = NULL;
2055 void *buffer_to_free = NULL;
2059 int frame_available = 1;
2062 int64_t *best_effort_timestamp;
2063 AVRational *frame_sample_aspect;
2065 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2066 return AVERROR(ENOMEM);
2068 avcodec_get_frame_defaults(ist->decoded_frame);
2069 decoded_frame = ist->decoded_frame;
2070 pkt->pts = *pkt_pts;
2071 pkt->dts = *pkt_dts;
2072 *pkt_pts = AV_NOPTS_VALUE;
2074 if (pkt->duration) {
2075 duration = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2076 } else if(ist->st->codec->time_base.num != 0) {
2077 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2078 duration = ((int64_t)AV_TIME_BASE *
2079 ist->st->codec->time_base.num * ticks) /
2080 ist->st->codec->time_base.den;
2083 if(*pkt_dts != AV_NOPTS_VALUE && duration) {
2084 *pkt_dts += duration;
2086 *pkt_dts = AV_NOPTS_VALUE;
2088 ret = avcodec_decode_video2(ist->st->codec,
2089 decoded_frame, got_output, pkt);
2093 quality = same_quant ? decoded_frame->quality : 0;
2095 /* no picture yet */
2099 best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
2100 if(*best_effort_timestamp != AV_NOPTS_VALUE)
2101 ist->next_pts = ist->pts = *best_effort_timestamp;
2103 ist->next_pts += duration;
2106 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2109 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2110 for(i=0;i<nb_output_streams;i++) {
2111 OutputStream *ost = ost = &output_streams[i];
2112 if(check_output_constraints(ist, ost) && ost->encoding_needed){
2113 if (!frame_sample_aspect->num)
2114 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2115 decoded_frame->pts = ist->pts;
2116 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER) {
2117 FrameBuffer *buf = decoded_frame->opaque;
2118 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2119 decoded_frame->data, decoded_frame->linesize,
2120 AV_PERM_READ | AV_PERM_PRESERVE,
2121 ist->st->codec->width, ist->st->codec->height,
2122 ist->st->codec->pix_fmt);
2124 avfilter_copy_frame_props(fb, decoded_frame);
2126 fb->buf->priv = buf;
2127 fb->buf->free = filter_release_buffer;
2130 av_buffersrc_buffer(ost->input_video_filter, fb);
2132 if((av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE)) < 0){
2133 av_log(0, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2140 rate_emu_sleep(ist);
2142 for (i = 0; i < nb_output_streams; i++) {
2143 OutputStream *ost = &output_streams[i];
2146 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2150 if (ost->input_video_filter) {
2151 frame_available = av_buffersink_poll_frame(ost->output_video_filter);
2153 while (frame_available) {
2154 if (ost->output_video_filter) {
2155 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
2156 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0){
2157 av_log(0, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");
2160 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2161 av_free(buffer_to_free);
2162 return AVERROR(ENOMEM);
2164 avcodec_get_frame_defaults(ist->filtered_frame);
2165 filtered_frame = ist->filtered_frame;
2166 *filtered_frame= *decoded_frame; //for me_threshold
2168 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
2169 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2172 if (ost->picref->video && !ost->frame_aspect_ratio)
2173 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
2175 filtered_frame = decoded_frame;
2178 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame, &frame_size,
2179 same_quant ? quality : ost->st->codec->global_quality);
2180 if (vstats_filename && frame_size)
2181 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
2184 frame_available = ost->output_video_filter && av_buffersink_poll_frame(ost->output_video_filter);
2185 avfilter_unref_buffer(ost->picref);
2190 av_free(buffer_to_free);
2194 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2196 AVSubtitle subtitle;
2197 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2198 &subtitle, got_output, pkt);
2204 rate_emu_sleep(ist);
2206 for (i = 0; i < nb_output_streams; i++) {
2207 OutputStream *ost = &output_streams[i];
2209 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2212 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2215 avsubtitle_free(&subtitle);
2219 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2220 static int output_packet(InputStream *ist,
2221 OutputStream *ost_table, int nb_ostreams,
2222 const AVPacket *pkt)
2226 int64_t pkt_dts = AV_NOPTS_VALUE;
2227 int64_t pkt_pts = AV_NOPTS_VALUE;
2231 if (ist->next_pts == AV_NOPTS_VALUE)
2232 ist->next_pts = ist->pts;
2236 av_init_packet(&avpkt);
2244 if (pkt->dts != AV_NOPTS_VALUE) {
2245 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2246 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2247 pkt_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2249 if(pkt->pts != AV_NOPTS_VALUE)
2250 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2252 // while we have more to decode or while the decoder did output something on EOF
2253 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2256 ist->pts = ist->next_pts;
2258 if (avpkt.size && avpkt.size != pkt->size) {
2259 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2260 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2261 ist->showed_multi_packet_warning = 1;
2264 switch (ist->st->codec->codec_type) {
2265 case AVMEDIA_TYPE_AUDIO:
2266 ret = transcode_audio (ist, &avpkt, &got_output);
2268 case AVMEDIA_TYPE_VIDEO:
2269 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts, &pkt_dts);
2271 case AVMEDIA_TYPE_SUBTITLE:
2272 ret = transcode_subtitles(ist, &avpkt, &got_output);
2282 avpkt.pts= AV_NOPTS_VALUE;
2284 // touch data and size only if not EOF
2286 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2296 /* handle stream copy */
2297 if (!ist->decoding_needed) {
2298 rate_emu_sleep(ist);
2299 ist->pts = ist->next_pts;
2300 switch (ist->st->codec->codec_type) {
2301 case AVMEDIA_TYPE_AUDIO:
2302 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2303 ist->st->codec->sample_rate;
2305 case AVMEDIA_TYPE_VIDEO:
2306 if (pkt->duration) {
2307 ist->next_pts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2308 } else if(ist->st->codec->time_base.num != 0) {
2309 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2310 ist->next_pts += ((int64_t)AV_TIME_BASE *
2311 ist->st->codec->time_base.num * ticks) /
2312 ist->st->codec->time_base.den;
2317 for (i = 0; pkt && i < nb_ostreams; i++) {
2318 OutputStream *ost = &ost_table[i];
2320 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2323 do_streamcopy(ist, ost, pkt);
2329 static void print_sdp(OutputFile *output_files, int n)
2333 AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2337 for (i = 0; i < n; i++)
2338 avc[i] = output_files[i].ctx;
2340 av_sdp_create(avc, n, sdp, sizeof(sdp));
2341 printf("SDP:\n%s\n", sdp);
2346 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2347 char *error, int error_len)
2349 InputStream *ist = &input_streams[ist_index];
2350 if (ist->decoding_needed) {
2351 AVCodec *codec = ist->dec;
2353 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2354 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2355 return AVERROR(EINVAL);
2358 ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
2359 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2360 ist->st->codec->get_buffer = codec_get_buffer;
2361 ist->st->codec->release_buffer = codec_release_buffer;
2362 ist->st->codec->opaque = ist;
2365 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2366 av_dict_set(&ist->opts, "threads", "auto", 0);
2367 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2368 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2369 ist->file_index, ist->st->index);
2370 return AVERROR(EINVAL);
2372 assert_codec_experimental(ist->st->codec, 0);
2373 assert_avoptions(ist->opts);
2376 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;
2377 ist->next_pts = AV_NOPTS_VALUE;
2383 static int transcode_init(OutputFile *output_files, int nb_output_files,
2384 InputFile *input_files, int nb_input_files)
2386 int ret = 0, i, j, k;
2387 AVFormatContext *oc;
2388 AVCodecContext *codec, *icodec;
2394 /* init framerate emulation */
2395 for (i = 0; i < nb_input_files; i++) {
2396 InputFile *ifile = &input_files[i];
2397 if (ifile->rate_emu)
2398 for (j = 0; j < ifile->nb_streams; j++)
2399 input_streams[j + ifile->ist_index].start = av_gettime();
2402 /* output stream init */
2403 for (i = 0; i < nb_output_files; i++) {
2404 oc = output_files[i].ctx;
2405 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2406 av_dump_format(oc, i, oc->filename, 1);
2407 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2408 return AVERROR(EINVAL);
2412 /* for each output stream, we compute the right encoding parameters */
2413 for (i = 0; i < nb_output_streams; i++) {
2414 ost = &output_streams[i];
2415 oc = output_files[ost->file_index].ctx;
2416 ist = &input_streams[ost->source_index];
2418 if (ost->attachment_filename)
2421 codec = ost->st->codec;
2422 icodec = ist->st->codec;
2424 ost->st->disposition = ist->st->disposition;
2425 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2426 codec->chroma_sample_location = icodec->chroma_sample_location;
2428 if (ost->stream_copy) {
2429 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2431 if (extra_size > INT_MAX) {
2432 return AVERROR(EINVAL);
2435 /* if stream_copy is selected, no need to decode or encode */
2436 codec->codec_id = icodec->codec_id;
2437 codec->codec_type = icodec->codec_type;
2439 if (!codec->codec_tag) {
2440 if (!oc->oformat->codec_tag ||
2441 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2442 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2443 codec->codec_tag = icodec->codec_tag;
2446 codec->bit_rate = icodec->bit_rate;
2447 codec->rc_max_rate = icodec->rc_max_rate;
2448 codec->rc_buffer_size = icodec->rc_buffer_size;
2449 codec->field_order = icodec->field_order;
2450 codec->extradata = av_mallocz(extra_size);
2451 if (!codec->extradata) {
2452 return AVERROR(ENOMEM);
2454 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2455 codec->extradata_size= icodec->extradata_size;
2457 codec->time_base = ist->st->time_base;
2458 if(!strcmp(oc->oformat->name, "avi")) {
2459 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2460 && av_q2d(ist->st->time_base) < 1.0/500
2462 codec->time_base = icodec->time_base;
2463 codec->time_base.num *= icodec->ticks_per_frame;
2464 codec->time_base.den *= 2;
2466 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2467 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2468 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2470 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2471 && av_q2d(ist->st->time_base) < 1.0/500
2473 codec->time_base = icodec->time_base;
2474 codec->time_base.num *= icodec->ticks_per_frame;
2477 av_reduce(&codec->time_base.num, &codec->time_base.den,
2478 codec->time_base.num, codec->time_base.den, INT_MAX);
2480 switch (codec->codec_type) {
2481 case AVMEDIA_TYPE_AUDIO:
2482 if (audio_volume != 256) {
2483 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2486 codec->channel_layout = icodec->channel_layout;
2487 codec->sample_rate = icodec->sample_rate;
2488 codec->channels = icodec->channels;
2489 codec->frame_size = icodec->frame_size;
2490 codec->audio_service_type = icodec->audio_service_type;
2491 codec->block_align = icodec->block_align;
2493 case AVMEDIA_TYPE_VIDEO:
2494 codec->pix_fmt = icodec->pix_fmt;
2495 codec->width = icodec->width;
2496 codec->height = icodec->height;
2497 codec->has_b_frames = icodec->has_b_frames;
2498 if (!codec->sample_aspect_ratio.num) {
2499 codec->sample_aspect_ratio =
2500 ost->st->sample_aspect_ratio =
2501 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2502 ist->st->codec->sample_aspect_ratio.num ?
2503 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2505 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2507 case AVMEDIA_TYPE_SUBTITLE:
2508 codec->width = icodec->width;
2509 codec->height = icodec->height;
2511 case AVMEDIA_TYPE_DATA:
2512 case AVMEDIA_TYPE_ATTACHMENT:
2519 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2521 ist->decoding_needed = 1;
2522 ost->encoding_needed = 1;
2524 switch (codec->codec_type) {
2525 case AVMEDIA_TYPE_AUDIO:
2526 ost->fifo = av_fifo_alloc(1024);
2528 return AVERROR(ENOMEM);
2530 if (!codec->sample_rate)
2531 codec->sample_rate = icodec->sample_rate;
2532 choose_sample_rate(ost->st, ost->enc);
2533 codec->time_base = (AVRational){ 1, codec->sample_rate };
2535 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2536 codec->sample_fmt = icodec->sample_fmt;
2537 choose_sample_fmt(ost->st, ost->enc);
2539 if (ost->audio_channels_mapped) {
2540 /* the requested output channel is set to the number of
2541 * -map_channel only if no -ac are specified */
2542 if (!codec->channels) {
2543 codec->channels = ost->audio_channels_mapped;
2544 codec->channel_layout = av_get_default_channel_layout(codec->channels);
2545 if (!codec->channel_layout) {
2546 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2550 /* fill unused channel mapping with -1 (which means a muted
2551 * channel in case the number of output channels is bigger
2552 * than the number of mapped channel) */
2553 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2554 ost->audio_channels_map[j] = -1;
2555 } else if (!codec->channels) {
2556 codec->channels = icodec->channels;
2557 codec->channel_layout = icodec->channel_layout;
2559 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2560 codec->channel_layout = 0;
2562 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2563 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2564 || codec->channel_layout != icodec->channel_layout;
2565 icodec->request_channels = codec->channels;
2566 ost->resample_sample_fmt = icodec->sample_fmt;
2567 ost->resample_sample_rate = icodec->sample_rate;
2568 ost->resample_channels = icodec->channels;
2570 case AVMEDIA_TYPE_VIDEO:
2571 if (codec->pix_fmt == PIX_FMT_NONE)
2572 codec->pix_fmt = icodec->pix_fmt;
2573 choose_pixel_fmt(ost->st, ost->enc);
2575 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2576 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2580 if (!codec->width || !codec->height) {
2581 codec->width = icodec->width;
2582 codec->height = icodec->height;
2585 ost->video_resample = codec->width != icodec->width ||
2586 codec->height != icodec->height ||
2587 codec->pix_fmt != icodec->pix_fmt;
2588 if (ost->video_resample) {
2589 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
2592 ost->resample_height = icodec->height;
2593 ost->resample_width = icodec->width;
2594 ost->resample_pix_fmt = icodec->pix_fmt;
2596 if (!ost->frame_rate.num)
2597 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2598 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2599 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2600 ost->frame_rate = ost->enc->supported_framerates[idx];
2602 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2603 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method
2604 && (video_sync_method==1 || (video_sync_method<0 && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2605 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2606 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2608 for (j = 0; j < ost->forced_kf_count; j++)
2609 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2614 if (configure_video_filters(ist, ost)) {
2615 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2620 case AVMEDIA_TYPE_SUBTITLE:
2627 if (codec->codec_id != CODEC_ID_H264 &&
2628 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2629 char logfilename[1024];
2632 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2633 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2635 if (codec->flags & CODEC_FLAG_PASS2) {
2637 size_t logbuffer_size;
2638 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2639 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2643 codec->stats_in = logbuffer;
2645 if (codec->flags & CODEC_FLAG_PASS1) {
2646 f = fopen(logfilename, "wb");
2648 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2649 logfilename, strerror(errno));
2656 if (codec->codec_type == AVMEDIA_TYPE_VIDEO) {
2657 /* maximum video buffer size is 8-bytes per pixel, plus DPX header size (1664)*/
2658 int size = codec->width * codec->height;
2659 bit_buffer_size = FFMAX(bit_buffer_size, 9*size + 10000);
2664 bit_buffer = av_malloc(bit_buffer_size);
2666 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2668 return AVERROR(ENOMEM);
2671 /* open each encoder */
2672 for (i = 0; i < nb_output_streams; i++) {
2673 ost = &output_streams[i];
2674 if (ost->encoding_needed) {
2675 AVCodec *codec = ost->enc;
2676 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2678 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2679 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2680 ret = AVERROR(EINVAL);
2683 if (dec->subtitle_header) {
2684 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2685 if (!ost->st->codec->subtitle_header) {
2686 ret = AVERROR(ENOMEM);
2689 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2690 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2692 if (!av_dict_get(ost->opts, "threads", NULL, 0))
2693 av_dict_set(&ost->opts, "threads", "auto", 0);
2694 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2695 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2696 ost->file_index, ost->index);
2697 ret = AVERROR(EINVAL);
2700 assert_codec_experimental(ost->st->codec, 1);
2701 assert_avoptions(ost->opts);
2702 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2703 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2704 " It takes bits/s as argument, not kbits/s\n");
2705 extra_size += ost->st->codec->extradata_size;
2707 if (ost->st->codec->me_threshold)
2708 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2712 /* init input streams */
2713 for (i = 0; i < nb_input_streams; i++)
2714 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2717 /* discard unused programs */
2718 for (i = 0; i < nb_input_files; i++) {
2719 InputFile *ifile = &input_files[i];
2720 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2721 AVProgram *p = ifile->ctx->programs[j];
2722 int discard = AVDISCARD_ALL;
2724 for (k = 0; k < p->nb_stream_indexes; k++)
2725 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2726 discard = AVDISCARD_DEFAULT;
2729 p->discard = discard;
2733 /* open files and write file headers */
2734 for (i = 0; i < nb_output_files; i++) {
2735 oc = output_files[i].ctx;
2736 oc->interrupt_callback = int_cb;
2737 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2738 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2739 ret = AVERROR(EINVAL);
2742 // assert_avoptions(output_files[i].opts);
2743 if (strcmp(oc->oformat->name, "rtp")) {
2749 /* dump the file output parameters - cannot be done before in case
2751 for (i = 0; i < nb_output_files; i++) {
2752 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2755 /* dump the stream mapping */
2756 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2757 for (i = 0; i < nb_output_streams; i++) {
2758 ost = &output_streams[i];
2760 if (ost->attachment_filename) {
2761 /* an attached file */
2762 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2763 ost->attachment_filename, ost->file_index, ost->index);
2766 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2767 input_streams[ost->source_index].file_index,
2768 input_streams[ost->source_index].st->index,
2771 if (ost->audio_channels_mapped) {
2772 av_log(NULL, AV_LOG_INFO, " [ch:");
2773 for (j = 0; j < ost->audio_channels_mapped; j++)
2774 if (ost->audio_channels_map[j] == -1)
2775 av_log(NULL, AV_LOG_INFO, " M");
2777 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2778 av_log(NULL, AV_LOG_INFO, "]");
2780 if (ost->sync_ist != &input_streams[ost->source_index])
2781 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2782 ost->sync_ist->file_index,
2783 ost->sync_ist->st->index);
2784 if (ost->stream_copy)
2785 av_log(NULL, AV_LOG_INFO, " (copy)");
2787 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2788 input_streams[ost->source_index].dec->name : "?",
2789 ost->enc ? ost->enc->name : "?");
2790 av_log(NULL, AV_LOG_INFO, "\n");
2794 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2799 print_sdp(output_files, nb_output_files);
2806 * The following code is the main loop of the file converter
2808 static int transcode(OutputFile *output_files, int nb_output_files,
2809 InputFile *input_files, int nb_input_files)
2812 AVFormatContext *is, *os;
2816 int no_packet_count = 0;
2817 int64_t timer_start;
2820 if (!(no_packet = av_mallocz(nb_input_files)))
2823 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2828 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2831 timer_start = av_gettime();
2833 for (; received_sigterm == 0;) {
2834 int file_index, ist_index;
2838 int64_t cur_time= av_gettime();
2840 ipts_min = INT64_MAX;
2842 /* if 'q' pressed, exits */
2844 static int64_t last_time;
2845 if (received_nb_signals)
2847 /* read_key() returns 0 on EOF */
2848 if(cur_time - last_time >= 100000 && !run_as_daemon){
2850 last_time = cur_time;
2855 if (key == '+') av_log_set_level(av_log_get_level()+10);
2856 if (key == '-') av_log_set_level(av_log_get_level()-10);
2857 if (key == 's') qp_hist ^= 1;
2860 do_hex_dump = do_pkt_dump = 0;
2861 } else if(do_pkt_dump){
2865 av_log_set_level(AV_LOG_DEBUG);
2868 if (key == 'c' || key == 'C'){
2869 char buf[4096], target[64], command[256], arg[256] = {0};
2872 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2874 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2879 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2880 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2881 target, time, command, arg);
2882 for (i = 0; i < nb_output_streams; i++) {
2883 ost = &output_streams[i];
2886 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2887 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2888 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2890 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2895 av_log(NULL, AV_LOG_ERROR,
2896 "Parse error, at least 3 arguments were expected, "
2897 "only %d given in string '%s'\n", n, buf);
2901 if (key == 'd' || key == 'D'){
2904 debug = input_streams[0].st->codec->debug<<1;
2905 if(!debug) debug = 1;
2906 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2909 if(scanf("%d", &debug)!=1)
2910 fprintf(stderr,"error parsing debug value\n");
2911 for(i=0;i<nb_input_streams;i++) {
2912 input_streams[i].st->codec->debug = debug;
2914 for(i=0;i<nb_output_streams;i++) {
2915 ost = &output_streams[i];
2916 ost->st->codec->debug = debug;
2918 if(debug) av_log_set_level(AV_LOG_DEBUG);
2919 fprintf(stderr,"debug=%d\n", debug);
2922 fprintf(stderr, "key function\n"
2923 "? show this help\n"
2924 "+ increase verbosity\n"
2925 "- decrease verbosity\n"
2926 "c Send command to filtergraph\n"
2927 "D cycle through available debug modes\n"
2928 "h dump packets/hex press to cycle through the 3 states\n"
2930 "s Show QP histogram\n"
2935 /* select the stream that we must read now by looking at the
2936 smallest output pts */
2938 for (i = 0; i < nb_output_streams; i++) {
2942 ost = &output_streams[i];
2943 of = &output_files[ost->file_index];
2944 os = output_files[ost->file_index].ctx;
2945 ist = &input_streams[ost->source_index];
2946 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2947 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2949 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2951 if (!input_files[ist->file_index].eof_reached) {
2952 if (ipts < ipts_min) {
2955 file_index = ist->file_index;
2957 if (opts < opts_min) {
2959 if (!input_sync) file_index = ist->file_index;
2962 if (ost->frame_number >= ost->max_frames) {
2964 for (j = 0; j < of->ctx->nb_streams; j++)
2965 output_streams[of->ost_index + j].is_past_recording_time = 1;
2969 /* if none, if is finished */
2970 if (file_index < 0) {
2971 if (no_packet_count) {
2972 no_packet_count = 0;
2973 memset(no_packet, 0, nb_input_files);
2980 /* read a frame from it and output it in the fifo */
2981 is = input_files[file_index].ctx;
2982 ret = av_read_frame(is, &pkt);
2983 if (ret == AVERROR(EAGAIN)) {
2984 no_packet[file_index] = 1;
2989 input_files[file_index].eof_reached = 1;
2996 no_packet_count = 0;
2997 memset(no_packet, 0, nb_input_files);
3000 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3001 is->streams[pkt.stream_index]);
3003 /* the following test is needed in case new streams appear
3004 dynamically in stream : we ignore them */
3005 if (pkt.stream_index >= input_files[file_index].nb_streams)
3006 goto discard_packet;
3007 ist_index = input_files[file_index].ist_index + pkt.stream_index;
3008 ist = &input_streams[ist_index];
3010 goto discard_packet;
3012 if (pkt.dts != AV_NOPTS_VALUE)
3013 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3014 if (pkt.pts != AV_NOPTS_VALUE)
3015 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3017 if (pkt.pts != AV_NOPTS_VALUE)
3018 pkt.pts *= ist->ts_scale;
3019 if (pkt.dts != AV_NOPTS_VALUE)
3020 pkt.dts *= ist->ts_scale;
3022 //fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n",
3024 // pkt.dts, input_files[ist->file_index].ts_offset,
3025 // ist->st->codec->codec_type);
3026 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
3027 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
3028 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3029 int64_t delta = pkt_dts - ist->next_pts;
3030 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3031 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3032 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3033 pkt_dts+1<ist->pts)&& !copy_ts){
3034 input_files[ist->file_index].ts_offset -= delta;
3035 av_log(NULL, AV_LOG_DEBUG,
3036 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3037 delta, input_files[ist->file_index].ts_offset);
3038 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3039 if (pkt.pts != AV_NOPTS_VALUE)
3040 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3044 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3045 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
3047 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3048 ist->file_index, ist->st->index);
3051 av_free_packet(&pkt);
3056 av_free_packet(&pkt);
3058 /* dump report by using the output first video and audio streams */
3059 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
3062 /* at the end of stream, we must flush the decoder buffers */
3063 for (i = 0; i < nb_input_streams; i++) {
3064 ist = &input_streams[i];
3065 if (ist->decoding_needed) {
3066 output_packet(ist, output_streams, nb_output_streams, NULL);
3069 flush_encoders(output_streams, nb_output_streams);
3073 /* write the trailer if needed and close file */
3074 for (i = 0; i < nb_output_files; i++) {
3075 os = output_files[i].ctx;
3076 av_write_trailer(os);
3079 /* dump report by using the first video and audio streams */
3080 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
3082 /* close each encoder */
3083 for (i = 0; i < nb_output_streams; i++) {
3084 ost = &output_streams[i];
3085 if (ost->encoding_needed) {
3086 av_freep(&ost->st->codec->stats_in);
3087 avcodec_close(ost->st->codec);
3090 avfilter_graph_free(&ost->graph);
3094 /* close each decoder */
3095 for (i = 0; i < nb_input_streams; i++) {
3096 ist = &input_streams[i];
3097 if (ist->decoding_needed) {
3098 avcodec_close(ist->st->codec);
3106 av_freep(&bit_buffer);
3107 av_freep(&no_packet);
3109 if (output_streams) {
3110 for (i = 0; i < nb_output_streams; i++) {
3111 ost = &output_streams[i];
3113 if (ost->stream_copy)
3114 av_freep(&ost->st->codec->extradata);
3116 fclose(ost->logfile);
3117 ost->logfile = NULL;
3119 av_fifo_free(ost->fifo); /* works even if fifo is not
3120 initialized but set to zero */
3121 av_freep(&ost->st->codec->subtitle_header);
3122 av_free(ost->resample_frame.data[0]);
3123 av_free(ost->forced_kf_pts);
3124 if (ost->video_resample)
3125 sws_freeContext(ost->img_resample_ctx);
3126 swr_free(&ost->swr);
3127 av_dict_free(&ost->opts);
3134 static int opt_frame_crop(const char *opt, const char *arg)
3136 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3137 return AVERROR(EINVAL);
3140 static int opt_pad(const char *opt, const char *arg)
3142 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3146 static double parse_frame_aspect_ratio(const char *arg)
3153 p = strchr(arg, ':');
3155 x = strtol(arg, &end, 10);
3157 y = strtol(end + 1, &end, 10);
3159 ar = (double)x / (double)y;
3161 ar = strtod(arg, NULL);
3164 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
3170 static int opt_video_channel(const char *opt, const char *arg)
3172 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3173 return opt_default("channel", arg);
3176 static int opt_video_standard(const char *opt, const char *arg)
3178 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3179 return opt_default("standard", arg);
3182 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3184 audio_codec_name = arg;
3185 return parse_option(o, "codec:a", arg, options);
3188 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3190 video_codec_name = arg;
3191 return parse_option(o, "codec:v", arg, options);
3194 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3196 subtitle_codec_name = arg;
3197 return parse_option(o, "codec:s", arg, options);
3200 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3202 return parse_option(o, "codec:d", arg, options);
3205 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3207 StreamMap *m = NULL;
3208 int i, negative = 0, file_idx;
3209 int sync_file_idx = -1, sync_stream_idx = 0;
3217 map = av_strdup(arg);
3219 /* parse sync stream first, just pick first matching stream */
3220 if (sync = strchr(map, ',')) {
3222 sync_file_idx = strtol(sync + 1, &sync, 0);
3223 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3224 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3229 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
3230 if (check_stream_specifier(input_files[sync_file_idx].ctx,
3231 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
3232 sync_stream_idx = i;
3235 if (i == input_files[sync_file_idx].nb_streams) {
3236 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3237 "match any streams.\n", arg);
3243 file_idx = strtol(map, &p, 0);
3244 if (file_idx >= nb_input_files || file_idx < 0) {
3245 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3249 /* disable some already defined maps */
3250 for (i = 0; i < o->nb_stream_maps; i++) {
3251 m = &o->stream_maps[i];
3252 if (file_idx == m->file_index &&
3253 check_stream_specifier(input_files[m->file_index].ctx,
3254 input_files[m->file_index].ctx->streams[m->stream_index],
3255 *p == ':' ? p + 1 : p) > 0)
3259 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3260 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3261 *p == ':' ? p + 1 : p) <= 0)
3263 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3264 &o->nb_stream_maps, o->nb_stream_maps + 1);
3265 m = &o->stream_maps[o->nb_stream_maps - 1];
3267 m->file_index = file_idx;
3268 m->stream_index = i;
3270 if (sync_file_idx >= 0) {
3271 m->sync_file_index = sync_file_idx;
3272 m->sync_stream_index = sync_stream_idx;
3274 m->sync_file_index = file_idx;
3275 m->sync_stream_index = i;
3280 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3288 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3290 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3291 &o->nb_attachments, o->nb_attachments + 1);
3292 o->attachments[o->nb_attachments - 1] = arg;
3296 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3302 o->audio_channel_maps =
3303 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3304 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3305 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3307 /* muted channel syntax */
3308 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3309 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3310 m->file_idx = m->stream_idx = -1;
3312 m->ofile_idx = m->ostream_idx = -1;
3317 n = sscanf(arg, "%d.%d.%d:%d.%d",
3318 &m->file_idx, &m->stream_idx, &m->channel_idx,
3319 &m->ofile_idx, &m->ostream_idx);
3321 if (n != 3 && n != 5) {
3322 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3323 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3327 if (n != 5) // only file.stream.channel specified
3328 m->ofile_idx = m->ostream_idx = -1;
3331 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3332 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3336 if (m->stream_idx < 0 ||
3337 m->stream_idx >= input_files[m->file_idx].nb_streams) {
3338 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3339 m->file_idx, m->stream_idx);
3342 st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3343 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3344 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3345 m->file_idx, m->stream_idx);
3348 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3349 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3350 m->file_idx, m->stream_idx, m->channel_idx);
3357 * Parse a metadata specifier in arg.
3358 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3359 * @param index for type c/p, chapter/program index is written here
3360 * @param stream_spec for type s, the stream specifier is written here
3362 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3370 if (*(++arg) && *arg != ':') {
3371 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3374 *stream_spec = *arg == ':' ? arg + 1 : "";
3378 if (*(++arg) == ':')
3379 *index = strtol(++arg, NULL, 0);
3382 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3389 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3391 AVDictionary **meta_in = NULL;
3392 AVDictionary **meta_out = NULL;
3394 char type_in, type_out;
3395 const char *istream_spec = NULL, *ostream_spec = NULL;
3396 int idx_in = 0, idx_out = 0;
3398 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3399 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3401 if (type_in == 'g' || type_out == 'g')
3402 o->metadata_global_manual = 1;
3403 if (type_in == 's' || type_out == 's')
3404 o->metadata_streams_manual = 1;
3405 if (type_in == 'c' || type_out == 'c')
3406 o->metadata_chapters_manual = 1;
3408 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3409 if ((index) < 0 || (index) >= (nb_elems)) {\
3410 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3415 #define SET_DICT(type, meta, context, index)\
3418 meta = &context->metadata;\
3421 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3422 meta = &context->chapters[index]->metadata;\
3425 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3426 meta = &context->programs[index]->metadata;\
3430 SET_DICT(type_in, meta_in, ic, idx_in);
3431 SET_DICT(type_out, meta_out, oc, idx_out);
3433 /* for input streams choose first matching stream */
3434 if (type_in == 's') {
3435 for (i = 0; i < ic->nb_streams; i++) {
3436 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3437 meta_in = &ic->streams[i]->metadata;
3443 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3448 if (type_out == 's') {
3449 for (i = 0; i < oc->nb_streams; i++) {
3450 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3451 meta_out = &oc->streams[i]->metadata;
3452 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3457 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3462 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3465 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3466 struct tm time = *gmtime((time_t*)&recording_timestamp);
3467 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3468 parse_option(o, "metadata", buf, options);
3470 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3471 "tag instead.\n", opt);
3475 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3477 const char *codec_string = encoder ? "encoder" : "decoder";
3481 avcodec_find_encoder_by_name(name) :
3482 avcodec_find_decoder_by_name(name);
3484 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3487 if (codec->type != type) {
3488 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3494 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3496 char *codec_name = NULL;
3498 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3500 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3501 st->codec->codec_id = codec->id;
3504 return avcodec_find_decoder(st->codec->codec_id);
3508 * Add all the streams from the given input file to the global
3509 * list of input streams.
3511 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3514 char *next, *codec_tag = NULL;
3516 for (i = 0; i < ic->nb_streams; i++) {
3517 AVStream *st = ic->streams[i];
3518 AVCodecContext *dec = st->codec;
3521 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3522 ist = &input_streams[nb_input_streams - 1];
3524 ist->file_index = nb_input_files;
3526 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3528 ist->ts_scale = 1.0;
3529 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3531 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3533 uint32_t tag = strtol(codec_tag, &next, 0);
3535 tag = AV_RL32(codec_tag);
3536 st->codec->codec_tag = tag;
3539 ist->dec = choose_decoder(o, ic, st);
3541 switch (dec->codec_type) {
3542 case AVMEDIA_TYPE_AUDIO:
3544 ist->dec = avcodec_find_decoder(dec->codec_id);
3545 if (o->audio_disable)
3546 st->discard = AVDISCARD_ALL;
3548 case AVMEDIA_TYPE_VIDEO:
3550 ist->dec = avcodec_find_decoder(dec->codec_id);
3552 dec->flags |= CODEC_FLAG_EMU_EDGE;
3555 if (o->video_disable)
3556 st->discard = AVDISCARD_ALL;
3557 else if (video_discard)
3558 st->discard = video_discard;
3560 case AVMEDIA_TYPE_DATA:
3561 if (o->data_disable)
3562 st->discard= AVDISCARD_ALL;
3564 case AVMEDIA_TYPE_SUBTITLE:
3566 ist->dec = avcodec_find_decoder(dec->codec_id);
3567 if(o->subtitle_disable)
3568 st->discard = AVDISCARD_ALL;
3570 case AVMEDIA_TYPE_ATTACHMENT:
3571 case AVMEDIA_TYPE_UNKNOWN:
3579 static void assert_file_overwrite(const char *filename)
3581 if ((!file_overwrite || no_file_overwrite) &&
3582 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3583 av_strstart(filename, "file:", NULL))) {
3584 if (avio_check(filename, 0) == 0) {
3585 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3586 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3589 signal(SIGINT, SIG_DFL);
3590 if (!read_yesno()) {
3591 av_log(0, AV_LOG_FATAL, "Not overwriting - exiting\n");
3597 av_log(0, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3604 static void dump_attachment(AVStream *st, const char *filename)
3607 AVIOContext *out = NULL;
3608 AVDictionaryEntry *e;
3610 if (!st->codec->extradata_size) {
3611 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3612 nb_input_files - 1, st->index);
3615 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3616 filename = e->value;
3618 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3619 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3623 assert_file_overwrite(filename);
3625 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3626 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3631 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3636 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3638 AVFormatContext *ic;
3639 AVInputFormat *file_iformat = NULL;
3643 AVDictionary **opts;
3644 int orig_nb_streams; // number of streams before avformat_find_stream_info
3647 if (!(file_iformat = av_find_input_format(o->format))) {
3648 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3653 if (!strcmp(filename, "-"))
3656 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3657 !strcmp(filename, "/dev/stdin");
3659 /* get default parameters from command line */
3660 ic = avformat_alloc_context();
3662 print_error(filename, AVERROR(ENOMEM));
3665 if (o->nb_audio_sample_rate) {
3666 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3667 av_dict_set(&format_opts, "sample_rate", buf, 0);
3669 if (o->nb_audio_channels) {
3670 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3671 av_dict_set(&format_opts, "channels", buf, 0);
3673 if (o->nb_frame_rates) {
3674 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3676 if (o->nb_frame_sizes) {
3677 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3679 if (o->nb_frame_pix_fmts)
3680 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3682 ic->video_codec_id = video_codec_name ?
3683 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3684 ic->audio_codec_id = audio_codec_name ?
3685 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3686 ic->subtitle_codec_id= subtitle_codec_name ?
3687 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3688 ic->flags |= AVFMT_FLAG_NONBLOCK;
3689 ic->interrupt_callback = int_cb;
3691 /* open the input file with generic avformat function */
3692 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3694 print_error(filename, err);
3697 assert_avoptions(format_opts);
3699 /* apply forced codec ids */
3700 for (i = 0; i < ic->nb_streams; i++)
3701 choose_decoder(o, ic, ic->streams[i]);
3703 /* Set AVCodecContext options for avformat_find_stream_info */
3704 opts = setup_find_stream_info_opts(ic, codec_opts);
3705 orig_nb_streams = ic->nb_streams;
3707 /* If not enough info to get the stream parameters, we decode the
3708 first frames to get it. (used in mpeg case for example) */
3709 ret = avformat_find_stream_info(ic, opts);
3711 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3712 avformat_close_input(&ic);
3716 timestamp = o->start_time;
3717 /* add the stream start time */
3718 if (ic->start_time != AV_NOPTS_VALUE)
3719 timestamp += ic->start_time;
3721 /* if seeking requested, we execute it */
3722 if (o->start_time != 0) {
3723 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3725 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3726 filename, (double)timestamp / AV_TIME_BASE);
3730 /* update the current parameters so that they match the one of the input stream */
3731 add_input_streams(o, ic);
3733 /* dump the file content */
3734 av_dump_format(ic, nb_input_files, filename, 0);
3736 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3737 input_files[nb_input_files - 1].ctx = ic;
3738 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3739 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3740 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3741 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3743 for (i = 0; i < o->nb_dump_attachment; i++) {
3746 for (j = 0; j < ic->nb_streams; j++) {
3747 AVStream *st = ic->streams[j];
3749 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3750 dump_attachment(st, o->dump_attachment[i].u.str);
3754 for (i = 0; i < orig_nb_streams; i++)
3755 av_dict_free(&opts[i]);
3758 reset_options(o, 1);
3762 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3767 for (p = kf; *p; p++)
3770 ost->forced_kf_count = n;
3771 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3772 if (!ost->forced_kf_pts) {
3773 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3776 for (i = 0; i < n; i++) {
3777 p = i ? strchr(p, ',') + 1 : kf;
3778 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3782 static uint8_t *get_line(AVIOContext *s)
3788 if (avio_open_dyn_buf(&line) < 0) {
3789 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3793 while ((c = avio_r8(s)) && c != '\n')
3796 avio_close_dyn_buf(line, &buf);
3801 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3804 char filename[1000];
3805 const char *base[3] = { getenv("AVCONV_DATADIR"),
3810 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3814 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3815 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3816 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3819 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3820 i != 1 ? "" : "/.avconv", preset_name);
3821 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3827 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3829 char *codec_name = NULL;
3831 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3833 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3834 NULL, ost->st->codec->codec_type);
3835 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3836 } else if (!strcmp(codec_name, "copy"))
3837 ost->stream_copy = 1;
3839 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3840 ost->st->codec->codec_id = ost->enc->id;
3844 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3847 AVStream *st = avformat_new_stream(oc, NULL);
3848 int idx = oc->nb_streams - 1, ret = 0;
3849 char *bsf = NULL, *next, *codec_tag = NULL;
3850 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3852 char *buf = NULL, *arg = NULL, *preset = NULL;
3853 AVIOContext *s = NULL;
3856 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3860 if (oc->nb_streams - 1 < o->nb_streamid_map)
3861 st->id = o->streamid_map[oc->nb_streams - 1];
3863 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3864 nb_output_streams + 1);
3865 ost = &output_streams[nb_output_streams - 1];
3866 ost->file_index = nb_output_files;
3869 st->codec->codec_type = type;
3870 choose_encoder(o, oc, ost);
3872 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3875 avcodec_get_context_defaults3(st->codec, ost->enc);
3876 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3878 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3879 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3882 if (!buf[0] || buf[0] == '#') {
3886 if (!(arg = strchr(buf, '='))) {
3887 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3891 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3893 } while (!s->eof_reached);
3897 av_log(NULL, AV_LOG_FATAL,
3898 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3899 preset, ost->file_index, ost->index);
3903 ost->max_frames = INT64_MAX;
3904 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3906 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3908 if (next = strchr(bsf, ','))
3910 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3911 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3915 bsfc_prev->next = bsfc;
3917 ost->bitstream_filters = bsfc;
3923 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3925 uint32_t tag = strtol(codec_tag, &next, 0);
3927 tag = AV_RL32(codec_tag);
3928 st->codec->codec_tag = tag;
3931 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3932 if (qscale >= 0 || same_quant) {
3933 st->codec->flags |= CODEC_FLAG_QSCALE;
3934 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3937 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3938 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3940 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3944 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3947 const char *p = str;
3954 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3961 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3965 AVCodecContext *video_enc;
3967 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3969 video_enc = st->codec;
3971 if (!ost->stream_copy) {
3972 const char *p = NULL;
3973 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3974 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3975 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3978 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3979 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3980 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3984 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3985 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3986 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3990 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3991 if (frame_aspect_ratio)
3992 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3994 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3995 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3996 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3997 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4000 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4003 video_enc->gop_size = 0;
4004 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4006 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4007 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4010 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4012 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4014 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4015 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4018 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4021 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4022 for (i = 0; p; i++) {
4024 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4026 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4029 /* FIXME realloc failure */
4030 video_enc->rc_override =
4031 av_realloc(video_enc->rc_override,
4032 sizeof(RcOverride) * (i + 1));
4033 video_enc->rc_override[i].start_frame = start;
4034 video_enc->rc_override[i].end_frame = end;
4036 video_enc->rc_override[i].qscale = q;
4037 video_enc->rc_override[i].quality_factor = 1.0;
4040 video_enc->rc_override[i].qscale = 0;
4041 video_enc->rc_override[i].quality_factor = -q/100.0;
4046 video_enc->rc_override_count = i;
4047 if (!video_enc->rc_initial_buffer_occupancy)
4048 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4049 video_enc->intra_dc_precision = intra_dc_precision - 8;
4052 video_enc->flags|= CODEC_FLAG_PSNR;
4057 video_enc->flags |= CODEC_FLAG_PASS1;
4060 video_enc->flags |= CODEC_FLAG_PASS2;
4064 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4065 if (forced_key_frames)
4066 parse_forced_key_frames(forced_key_frames, ost);
4068 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4070 ost->top_field_first = -1;
4071 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4074 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4076 ost->avfilter = av_strdup(filters);
4079 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4085 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
4090 AVCodecContext *audio_enc;
4092 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
4095 audio_enc = st->codec;
4096 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4098 if (!ost->stream_copy) {
4099 char *sample_fmt = NULL;
4101 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4103 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4105 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4106 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4110 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4112 ost->rematrix_volume=1.0;
4113 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4116 /* check for channel mapping for this audio stream */
4117 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4118 AudioChannelMap *map = &o->audio_channel_maps[n];
4119 InputStream *ist = &input_streams[ost->source_index];
4120 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4121 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4122 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4123 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4124 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4126 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4127 ost->file_index, ost->st->index);
4134 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
4138 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
4139 if (!ost->stream_copy) {
4140 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4147 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
4149 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
4150 ost->stream_copy = 1;
4154 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
4158 AVCodecContext *subtitle_enc;
4160 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
4162 subtitle_enc = st->codec;
4164 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4169 /* arg format is "output-stream-index:streamid-value". */
4170 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4176 av_strlcpy(idx_str, arg, sizeof(idx_str));
4177 p = strchr(idx_str, ':');
4179 av_log(NULL, AV_LOG_FATAL,
4180 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4185 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4186 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4187 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4191 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4193 AVFormatContext *is = ifile->ctx;
4194 AVFormatContext *os = ofile->ctx;
4197 for (i = 0; i < is->nb_chapters; i++) {
4198 AVChapter *in_ch = is->chapters[i], *out_ch;
4199 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4200 AV_TIME_BASE_Q, in_ch->time_base);
4201 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4202 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4205 if (in_ch->end < ts_off)
4207 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4210 out_ch = av_mallocz(sizeof(AVChapter));
4212 return AVERROR(ENOMEM);
4214 out_ch->id = in_ch->id;
4215 out_ch->time_base = in_ch->time_base;
4216 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4217 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4220 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4223 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4225 return AVERROR(ENOMEM);
4226 os->chapters[os->nb_chapters - 1] = out_ch;
4231 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4234 AVFormatContext *ic = avformat_alloc_context();
4236 ic->interrupt_callback = int_cb;
4237 err = avformat_open_input(&ic, filename, NULL, NULL);
4240 /* copy stream format */
4241 for(i=0;i<ic->nb_streams;i++) {
4245 AVCodecContext *avctx;
4247 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4248 ost = new_output_stream(o, s, codec->type);
4253 // FIXME: a more elegant solution is needed
4254 memcpy(st, ic->streams[i], sizeof(AVStream));
4255 st->info = av_malloc(sizeof(*st->info));
4256 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4258 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4260 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4261 choose_sample_fmt(st, codec);
4262 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4263 choose_pixel_fmt(st, codec);
4266 avformat_close_input(&ic);
4270 static void opt_output_file(void *optctx, const char *filename)
4272 OptionsContext *o = optctx;
4273 AVFormatContext *oc;
4275 AVOutputFormat *file_oformat;
4279 if (!strcmp(filename, "-"))
4282 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4284 print_error(filename, err);
4287 file_oformat= oc->oformat;
4288 oc->interrupt_callback = int_cb;
4290 if (!strcmp(file_oformat->name, "ffm") &&
4291 av_strstart(filename, "http:", NULL)) {
4293 /* special case for files sent to ffserver: we get the stream
4294 parameters from ffserver */
4295 int err = read_ffserver_streams(o, oc, filename);
4297 print_error(filename, err);
4300 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4301 ost = &output_streams[j];
4302 for (i = 0; i < nb_input_streams; i++) {
4303 ist = &input_streams[i];
4304 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4306 ost->source_index= i;
4312 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));
4316 } else if (!o->nb_stream_maps) {
4317 /* pick the "best" stream of each type */
4318 #define NEW_STREAM(type, index)\
4320 ost = new_ ## type ## _stream(o, oc);\
4321 ost->source_index = index;\
4322 ost->sync_ist = &input_streams[index];\
4323 input_streams[index].discard = 0;\
4326 /* video: highest resolution */
4327 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4328 int area = 0, idx = -1;
4329 for (i = 0; i < nb_input_streams; i++) {
4330 ist = &input_streams[i];
4331 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4332 ist->st->codec->width * ist->st->codec->height > area) {
4333 area = ist->st->codec->width * ist->st->codec->height;
4337 NEW_STREAM(video, idx);
4340 /* audio: most channels */
4341 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4342 int channels = 0, idx = -1;
4343 for (i = 0; i < nb_input_streams; i++) {
4344 ist = &input_streams[i];
4345 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4346 ist->st->codec->channels > channels) {
4347 channels = ist->st->codec->channels;
4351 NEW_STREAM(audio, idx);
4354 /* subtitles: pick first */
4355 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4356 for (i = 0; i < nb_input_streams; i++)
4357 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4358 NEW_STREAM(subtitle, i);
4362 /* do something with data? */
4364 for (i = 0; i < o->nb_stream_maps; i++) {
4365 StreamMap *map = &o->stream_maps[i];
4370 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4371 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4373 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4375 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4377 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4380 switch (ist->st->codec->codec_type) {
4381 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4382 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4383 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4384 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4385 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4387 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4388 map->file_index, map->stream_index);
4392 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4393 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4394 map->sync_stream_index];
4399 /* handle attached files */
4400 for (i = 0; i < o->nb_attachments; i++) {
4402 uint8_t *attachment;
4406 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4407 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4411 if ((len = avio_size(pb)) <= 0) {
4412 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4416 if (!(attachment = av_malloc(len))) {
4417 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4421 avio_read(pb, attachment, len);
4423 ost = new_attachment_stream(o, oc);
4424 ost->stream_copy = 0;
4425 ost->source_index = -1;
4426 ost->attachment_filename = o->attachments[i];
4427 ost->st->codec->extradata = attachment;
4428 ost->st->codec->extradata_size = len;
4430 p = strrchr(o->attachments[i], '/');
4431 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4435 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4436 output_files[nb_output_files - 1].ctx = oc;
4437 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4438 output_files[nb_output_files - 1].recording_time = o->recording_time;
4439 output_files[nb_output_files - 1].start_time = o->start_time;
4440 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4441 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4443 /* check filename in case of an image number is expected */
4444 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4445 if (!av_filename_number_test(oc->filename)) {
4446 print_error(oc->filename, AVERROR(EINVAL));
4451 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4452 /* test if it already exists to avoid losing precious files */
4453 assert_file_overwrite(filename);
4456 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4457 &oc->interrupt_callback,
4458 &output_files[nb_output_files - 1].opts)) < 0) {
4459 print_error(filename, err);
4464 if (o->mux_preload) {
4466 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4467 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4469 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4472 for (i = 0; i < o->nb_metadata_map; i++) {
4474 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4476 if (in_file_index < 0)
4478 if (in_file_index >= nb_input_files) {
4479 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4482 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4486 if (o->chapters_input_file >= nb_input_files) {
4487 if (o->chapters_input_file == INT_MAX) {
4488 /* copy chapters from the first input file that has them*/
4489 o->chapters_input_file = -1;
4490 for (i = 0; i < nb_input_files; i++)
4491 if (input_files[i].ctx->nb_chapters) {
4492 o->chapters_input_file = i;
4496 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4497 o->chapters_input_file);
4501 if (o->chapters_input_file >= 0)
4502 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4503 !o->metadata_chapters_manual);
4505 /* copy global metadata by default */
4506 if (!o->metadata_global_manual && nb_input_files){
4507 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4508 AV_DICT_DONT_OVERWRITE);
4509 if(o->recording_time != INT64_MAX)
4510 av_dict_set(&oc->metadata, "duration", NULL, 0);
4512 if (!o->metadata_streams_manual)
4513 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4515 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4517 ist = &input_streams[output_streams[i].source_index];
4518 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4521 /* process manually set metadata */
4522 for (i = 0; i < o->nb_metadata; i++) {
4525 const char *stream_spec;
4526 int index = 0, j, ret = 0;
4528 val = strchr(o->metadata[i].u.str, '=');
4530 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4531 o->metadata[i].u.str);
4536 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4538 for (j = 0; j < oc->nb_streams; j++) {
4539 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4540 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4544 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4552 if (index < 0 || index >= oc->nb_chapters) {
4553 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4556 m = &oc->chapters[index]->metadata;
4559 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4562 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4566 reset_options(o, 0);
4569 /* same option as mencoder */
4570 static int opt_pass(const char *opt, const char *arg)
4572 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4576 static int64_t getutime(void)
4579 struct rusage rusage;
4581 getrusage(RUSAGE_SELF, &rusage);
4582 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4583 #elif HAVE_GETPROCESSTIMES
4585 FILETIME c, e, k, u;
4586 proc = GetCurrentProcess();
4587 GetProcessTimes(proc, &c, &e, &k, &u);
4588 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4590 return av_gettime();
4594 static int64_t getmaxrss(void)
4596 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4597 struct rusage rusage;
4598 getrusage(RUSAGE_SELF, &rusage);
4599 return (int64_t)rusage.ru_maxrss * 1024;
4600 #elif HAVE_GETPROCESSMEMORYINFO
4602 PROCESS_MEMORY_COUNTERS memcounters;
4603 proc = GetCurrentProcess();
4604 memcounters.cb = sizeof(memcounters);
4605 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4606 return memcounters.PeakPagefileUsage;
4612 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4614 return parse_option(o, "q:a", arg, options);
4617 static void show_usage(void)
4619 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
4620 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4621 av_log(NULL, AV_LOG_INFO, "\n");
4624 static int opt_help(const char *opt, const char *arg)
4626 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4627 av_log_set_callback(log_callback_help);
4629 show_help_options(options, "Main options:\n",
4630 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4631 show_help_options(options, "\nAdvanced options:\n",
4632 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4634 show_help_options(options, "\nVideo options:\n",
4635 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4637 show_help_options(options, "\nAdvanced Video options:\n",
4638 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4639 OPT_VIDEO | OPT_EXPERT);
4640 show_help_options(options, "\nAudio options:\n",
4641 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4643 show_help_options(options, "\nAdvanced Audio options:\n",
4644 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4645 OPT_AUDIO | OPT_EXPERT);
4646 show_help_options(options, "\nSubtitle options:\n",
4647 OPT_SUBTITLE | OPT_GRAB,
4649 show_help_options(options, "\nAudio/Video grab options:\n",
4653 show_help_children(avcodec_get_class(), flags);
4654 show_help_children(avformat_get_class(), flags);
4655 show_help_children(sws_get_class(), flags);
4660 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4662 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4663 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4665 if (!strncmp(arg, "pal-", 4)) {
4668 } else if (!strncmp(arg, "ntsc-", 5)) {
4671 } else if (!strncmp(arg, "film-", 5)) {
4675 /* Try to determine PAL/NTSC by peeking in the input files */
4676 if (nb_input_files) {
4678 for (j = 0; j < nb_input_files; j++) {
4679 for (i = 0; i < input_files[j].nb_streams; i++) {
4680 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4681 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4683 fr = c->time_base.den * 1000 / c->time_base.num;
4687 } else if ((fr == 29970) || (fr == 23976)) {
4692 if (norm != UNKNOWN)
4696 if (norm != UNKNOWN)
4697 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4700 if (norm == UNKNOWN) {
4701 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4702 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4703 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4707 if (!strcmp(arg, "vcd")) {
4708 opt_video_codec(o, "c:v", "mpeg1video");
4709 opt_audio_codec(o, "c:a", "mp2");
4710 parse_option(o, "f", "vcd", options);
4712 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4713 parse_option(o, "r", frame_rates[norm], options);
4714 opt_default("g", norm == PAL ? "15" : "18");
4716 opt_default("b:v", "1150000");
4717 opt_default("maxrate", "1150000");
4718 opt_default("minrate", "1150000");
4719 opt_default("bufsize", "327680"); // 40*1024*8;
4721 opt_default("b:a", "224000");
4722 parse_option(o, "ar", "44100", options);
4723 parse_option(o, "ac", "2", options);
4725 opt_default("packetsize", "2324");
4726 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4728 /* We have to offset the PTS, so that it is consistent with the SCR.
4729 SCR starts at 36000, but the first two packs contain only padding
4730 and the first pack from the other stream, respectively, may also have
4731 been written before.
4732 So the real data starts at SCR 36000+3*1200. */
4733 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4734 } else if (!strcmp(arg, "svcd")) {
4736 opt_video_codec(o, "c:v", "mpeg2video");
4737 opt_audio_codec(o, "c:a", "mp2");
4738 parse_option(o, "f", "svcd", options);
4740 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4741 parse_option(o, "r", frame_rates[norm], options);
4742 parse_option(o, "pix_fmt", "yuv420p", options);
4743 opt_default("g", norm == PAL ? "15" : "18");
4745 opt_default("b:v", "2040000");
4746 opt_default("maxrate", "2516000");
4747 opt_default("minrate", "0"); // 1145000;
4748 opt_default("bufsize", "1835008"); // 224*1024*8;
4749 opt_default("flags", "+scan_offset");
4752 opt_default("b:a", "224000");
4753 parse_option(o, "ar", "44100", options);
4755 opt_default("packetsize", "2324");
4757 } else if (!strcmp(arg, "dvd")) {
4759 opt_video_codec(o, "c:v", "mpeg2video");
4760 opt_audio_codec(o, "c:a", "ac3");
4761 parse_option(o, "f", "dvd", options);
4763 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4764 parse_option(o, "r", frame_rates[norm], options);
4765 parse_option(o, "pix_fmt", "yuv420p", options);
4766 opt_default("g", norm == PAL ? "15" : "18");
4768 opt_default("b:v", "6000000");
4769 opt_default("maxrate", "9000000");
4770 opt_default("minrate", "0"); // 1500000;
4771 opt_default("bufsize", "1835008"); // 224*1024*8;
4773 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4774 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4776 opt_default("b:a", "448000");
4777 parse_option(o, "ar", "48000", options);
4779 } else if (!strncmp(arg, "dv", 2)) {
4781 parse_option(o, "f", "dv", options);
4783 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4784 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4785 norm == PAL ? "yuv420p" : "yuv411p", options);
4786 parse_option(o, "r", frame_rates[norm], options);
4788 parse_option(o, "ar", "48000", options);
4789 parse_option(o, "ac", "2", options);
4792 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4793 return AVERROR(EINVAL);
4798 static int opt_vstats_file(const char *opt, const char *arg)
4800 av_free (vstats_filename);
4801 vstats_filename = av_strdup (arg);
4805 static int opt_vstats(const char *opt, const char *arg)
4808 time_t today2 = time(NULL);
4809 struct tm *today = localtime(&today2);
4811 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4813 return opt_vstats_file(opt, filename);
4816 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4818 return parse_option(o, "frames:v", arg, options);
4821 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4823 return parse_option(o, "frames:a", arg, options);
4826 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4828 return parse_option(o, "frames:d", arg, options);
4831 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4834 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4835 const char *codec_name = *opt == 'v' ? video_codec_name :
4836 *opt == 'a' ? audio_codec_name :
4837 subtitle_codec_name;
4839 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4840 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4841 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4843 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4848 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4849 if(line[0] == '#' && !e)
4851 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4853 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4856 if(!strcmp(tmp, "acodec")){
4857 opt_audio_codec(o, tmp, tmp2);
4858 }else if(!strcmp(tmp, "vcodec")){
4859 opt_video_codec(o, tmp, tmp2);
4860 }else if(!strcmp(tmp, "scodec")){
4861 opt_subtitle_codec(o, tmp, tmp2);
4862 }else if(!strcmp(tmp, "dcodec")){
4863 opt_data_codec(o, tmp, tmp2);
4864 }else if(opt_default(tmp, tmp2) < 0){
4865 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4875 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4879 static int opt_passlogfile(const char *opt, const char *arg)
4881 pass_logfilename_prefix = arg;
4882 #if CONFIG_LIBX264_ENCODER
4883 return opt_default("passlogfile", arg);
4889 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4891 char *s = av_asprintf("%s:%c", opt + 1, *opt);
4892 int ret = parse_option(o, s, arg, options);
4897 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4899 if(!strcmp(opt, "b")){
4900 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4901 return parse_option(o, "b:v", arg, options);
4903 return opt_default(opt, arg);
4906 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
4910 if(!strcmp(opt, "qscale")){
4911 av_log(0,AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
4912 return parse_option(o, "q:v", arg, options);
4914 s = av_asprintf("q%s", opt + 6);
4915 ret = parse_option(o, s, arg, options);
4920 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4922 return parse_option(o, "filter:v", arg, options);
4925 static int opt_vsync(const char *opt, const char *arg)
4927 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
4928 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
4929 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4931 if (video_sync_method == VSYNC_AUTO)
4932 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4936 #define OFFSET(x) offsetof(OptionsContext, x)
4937 static const OptionDef options[] = {
4939 #include "cmdutils_common_opts.h"
4940 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4941 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4942 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4943 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4944 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4945 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4946 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4947 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4948 { "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]" },
4949 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4950 "outfile[,metadata]:infile[,metadata]" },
4951 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4952 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4953 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4954 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4955 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4956 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4957 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4958 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4959 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4960 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4961 "add timings for benchmarking" },
4962 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4963 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4964 "dump each input packet" },
4965 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4966 "when dumping packets, also dump the payload" },
4967 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4968 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4969 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4970 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4971 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4972 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4973 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
4974 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4975 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4976 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4977 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4978 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4979 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4980 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4981 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
4983 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4985 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4986 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4987 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4990 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4991 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4992 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4993 { "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" },
4994 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4995 { "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" },
4996 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4997 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4998 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4999 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5000 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5001 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5002 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5003 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5004 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5005 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
5006 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5007 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5008 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5009 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5010 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5011 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5012 "use same quantizer as source (implies VBR)" },
5013 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5014 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5015 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
5016 "deinterlace pictures" },
5017 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5018 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5019 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5021 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5023 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5024 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5025 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5026 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5027 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5028 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5029 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5030 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5031 { "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" },
5032 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5035 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5036 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5037 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5038 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5039 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5040 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5041 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5042 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5043 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5044 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
5046 /* subtitle options */
5047 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5048 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5049 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5052 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5053 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5054 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5057 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5058 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5060 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5061 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5062 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5064 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5065 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5066 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5067 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5068 /* data codec support */
5069 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5070 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5072 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5076 int main(int argc, char **argv)
5078 OptionsContext o = { 0 };
5081 reset_options(&o, 0);
5083 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5084 parse_loglevel(argc, argv, options);
5086 if(argc>1 && !strcmp(argv[1], "-d")){
5088 av_log_set_callback(log_callback_null);
5093 avcodec_register_all();
5095 avdevice_register_all();
5098 avfilter_register_all();
5101 avformat_network_init();
5103 show_banner(argc, argv, options);
5108 parse_options(&o, argc, argv, options, opt_output_file);
5110 if (nb_output_files <= 0 && nb_input_files == 0) {
5112 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5116 /* file converter / grab */
5117 if (nb_output_files <= 0) {
5118 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5122 if (nb_input_files == 0) {
5123 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5128 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
5130 ti = getutime() - ti;
5132 int maxrss = getmaxrss() / 1024;
5133 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);