2 * Copyright (c) 2000-2003 Fabrice Bellard
4 * This file is part of FFmpeg.
6 * FFmpeg is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * FFmpeg is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with FFmpeg; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 * multimedia converter based on the FFmpeg libraries
35 #include "libavformat/avformat.h"
36 #include "libavdevice/avdevice.h"
37 #include "libswscale/swscale.h"
38 #include "libavutil/opt.h"
39 #include "libavcodec/audioconvert.h"
40 #include "libavutil/audioconvert.h"
41 #include "libavutil/parseutils.h"
42 #include "libavutil/samplefmt.h"
43 #include "libavutil/colorspace.h"
44 #include "libavutil/fifo.h"
45 #include "libavutil/intreadwrite.h"
46 #include "libavutil/dict.h"
47 #include "libavutil/mathematics.h"
48 #include "libavutil/pixdesc.h"
49 #include "libavutil/avstring.h"
50 #include "libavutil/libm.h"
51 #include "libavutil/imgutils.h"
52 #include "libavformat/os_support.h"
53 #include "libswresample/swresample.h"
55 #include "libavformat/ffm.h" // not public API
58 # include "libavfilter/avcodec.h"
59 # include "libavfilter/avfilter.h"
60 # include "libavfilter/avfiltergraph.h"
61 # include "libavfilter/buffersink.h"
62 # include "libavfilter/buffersrc.h"
63 # include "libavfilter/vsrc_buffer.h"
66 #if HAVE_SYS_RESOURCE_H
67 #include <sys/types.h>
69 #include <sys/resource.h>
70 #elif HAVE_GETPROCESSTIMES
73 #if HAVE_GETPROCESSMEMORYINFO
79 #include <sys/select.h>
84 #include <sys/ioctl.h>
94 #include "libavutil/avassert.h"
97 #define VSYNC_PASSTHROUGH 0
101 const char program_name[] = "ffmpeg";
102 const int program_birth_year = 2000;
104 /* select an input stream for an output stream */
105 typedef struct StreamMap {
106 int disabled; /** 1 is this mapping is disabled by a negative map */
110 int sync_stream_index;
114 int file_idx, stream_idx, channel_idx; // input
115 int ofile_idx, ostream_idx; // output
119 * select an input file for an output file
121 typedef struct MetadataMap {
122 int file; ///< file index
123 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
124 int index; ///< stream/chapter/program number
127 static const OptionDef options[];
129 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
131 static int frame_bits_per_raw_sample = 0;
132 static int video_discard = 0;
133 static int same_quant = 0;
134 static int do_deinterlace = 0;
135 static int intra_dc_precision = 8;
136 static int loop_input = 0;
137 static int loop_output = AVFMT_NOOUTPUTLOOP;
138 static int qp_hist = 0;
139 static int intra_only = 0;
140 static const char *video_codec_name = NULL;
141 static const char *audio_codec_name = NULL;
142 static const char *subtitle_codec_name = NULL;
144 static int file_overwrite = 0;
145 static int no_file_overwrite = 0;
146 static int do_benchmark = 0;
147 static int do_hex_dump = 0;
148 static int do_pkt_dump = 0;
149 static int do_psnr = 0;
150 static int do_pass = 0;
151 static const char *pass_logfilename_prefix;
152 static int video_sync_method = VSYNC_AUTO;
153 static int audio_sync_method = 0;
154 static float audio_drift_threshold = 0.1;
155 static int copy_ts = 0;
156 static int copy_tb = -1;
157 static int opt_shortest = 0;
158 static char *vstats_filename;
159 static FILE *vstats_file;
161 static int audio_volume = 256;
163 static int exit_on_error = 0;
164 static int using_stdin = 0;
165 static int run_as_daemon = 0;
166 static volatile int received_nb_signals = 0;
167 static int64_t video_size = 0;
168 static int64_t audio_size = 0;
169 static int64_t extra_size = 0;
170 static int nb_frames_dup = 0;
171 static int nb_frames_drop = 0;
172 static int input_sync;
174 static float dts_delta_threshold = 10;
176 static int print_stats = 1;
178 static uint8_t *audio_buf;
179 static unsigned int allocated_audio_buf_size;
181 static uint8_t *input_tmp= NULL;
183 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
185 typedef struct FrameBuffer {
191 enum PixelFormat pix_fmt;
194 struct InputStream *ist;
195 struct FrameBuffer *next;
198 typedef struct InputStream {
201 int discard; /* true if stream data should be discarded */
202 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
204 AVFrame *decoded_frame;
205 AVFrame *filtered_frame;
207 int64_t start; /* time when read started */
208 int64_t next_pts; /* synthetic pts for cases where pkt.pts
210 int64_t pts; /* current pts */
212 int is_start; /* is 1 at the start and after a discontinuity */
213 int showed_multi_packet_warning;
216 /* a pool of free buffers for decoded data */
217 FrameBuffer *buffer_pool;
221 typedef struct InputFile {
222 AVFormatContext *ctx;
223 int eof_reached; /* true if eof reached */
224 int ist_index; /* index of first stream in input_streams */
225 int buffer_size; /* current total buffer size */
227 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
228 from ctx.nb_streams if new streams appear during av_read_frame() */
232 typedef struct OutputStream {
233 int file_index; /* file index */
234 int index; /* stream index in the output file */
235 int source_index; /* InputStream index */
236 AVStream *st; /* stream in the output file */
237 int encoding_needed; /* true if encoding needed for this stream */
239 /* input pts and corresponding output pts
241 struct InputStream *sync_ist; /* input stream to sync against */
242 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
243 AVBitStreamFilterContext *bitstream_filters;
246 AVFrame *output_frame;
250 AVFrame resample_frame; /* temporary frame for image resampling */
251 struct SwsContext *img_resample_ctx; /* for image resampling */
254 int resample_pix_fmt;
255 AVRational frame_rate;
259 float frame_aspect_ratio;
261 /* forced key frames */
262 int64_t *forced_kf_pts;
268 int audio_channels_map[SWR_CH_MAX]; ///< list of the channels id to pick from the source stream
269 int audio_channels_mapped; ///< number of channels in audio_channels_map
270 int resample_sample_fmt;
271 int resample_channels;
272 int resample_sample_rate;
273 float rematrix_volume;
274 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
277 struct SwrContext *swr;
280 AVFilterContext *output_video_filter;
281 AVFilterContext *input_video_filter;
282 AVFilterBufferRef *picref;
284 AVFilterGraph *graph;
289 int is_past_recording_time;
291 const char *attachment_filename;
292 int copy_initial_nonkeyframes;
298 /* init terminal so that we can grab keys */
299 static struct termios oldtty;
300 static int restore_tty;
303 typedef struct OutputFile {
304 AVFormatContext *ctx;
306 int ost_index; /* index of the first stream in output_streams */
307 int64_t recording_time; /* desired length of the resulting file in microseconds */
308 int64_t start_time; /* start time in microseconds */
309 uint64_t limit_filesize;
312 static InputStream *input_streams = NULL;
313 static int nb_input_streams = 0;
314 static InputFile *input_files = NULL;
315 static int nb_input_files = 0;
317 static OutputStream *output_streams = NULL;
318 static int nb_output_streams = 0;
319 static OutputFile *output_files = NULL;
320 static int nb_output_files = 0;
322 typedef struct OptionsContext {
323 /* input/output options */
327 SpecifierOpt *codec_names;
329 SpecifierOpt *audio_channels;
330 int nb_audio_channels;
331 SpecifierOpt *audio_sample_rate;
332 int nb_audio_sample_rate;
333 SpecifierOpt *rematrix_volume;
334 int nb_rematrix_volume;
335 SpecifierOpt *frame_rates;
337 SpecifierOpt *frame_sizes;
339 SpecifierOpt *frame_pix_fmts;
340 int nb_frame_pix_fmts;
343 int64_t input_ts_offset;
346 SpecifierOpt *ts_scale;
348 SpecifierOpt *dump_attachment;
349 int nb_dump_attachment;
352 StreamMap *stream_maps;
354 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
355 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
356 /* first item specifies output metadata, second is input */
357 MetadataMap (*meta_data_maps)[2];
358 int nb_meta_data_maps;
359 int metadata_global_manual;
360 int metadata_streams_manual;
361 int metadata_chapters_manual;
362 const char **attachments;
365 int chapters_input_file;
367 int64_t recording_time;
368 uint64_t limit_filesize;
374 int subtitle_disable;
377 /* indexed by output file stream index */
381 SpecifierOpt *metadata;
383 SpecifierOpt *max_frames;
385 SpecifierOpt *bitstream_filters;
386 int nb_bitstream_filters;
387 SpecifierOpt *codec_tags;
389 SpecifierOpt *sample_fmts;
391 SpecifierOpt *qscale;
393 SpecifierOpt *forced_key_frames;
394 int nb_forced_key_frames;
395 SpecifierOpt *force_fps;
397 SpecifierOpt *frame_aspect_ratios;
398 int nb_frame_aspect_ratios;
399 SpecifierOpt *rc_overrides;
401 SpecifierOpt *intra_matrices;
402 int nb_intra_matrices;
403 SpecifierOpt *inter_matrices;
404 int nb_inter_matrices;
405 SpecifierOpt *top_field_first;
406 int nb_top_field_first;
407 SpecifierOpt *metadata_map;
409 SpecifierOpt *presets;
411 SpecifierOpt *copy_initial_nonkeyframes;
412 int nb_copy_initial_nonkeyframes;
414 SpecifierOpt *filters;
419 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
422 for (i = 0; i < o->nb_ ## name; i++) {\
423 char *spec = o->name[i].specifier;\
424 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
425 outvar = o->name[i].u.type;\
431 static void reset_options(OptionsContext *o, int is_input)
433 const OptionDef *po = options;
434 OptionsContext bak= *o;
436 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
438 void *dst = (uint8_t*)o + po->u.off;
440 if (po->flags & OPT_SPEC) {
441 SpecifierOpt **so = dst;
442 int i, *count = (int*)(so + 1);
443 for (i = 0; i < *count; i++) {
444 av_freep(&(*so)[i].specifier);
445 if (po->flags & OPT_STRING)
446 av_freep(&(*so)[i].u.str);
450 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
455 av_freep(&o->stream_maps);
456 av_freep(&o->audio_channel_maps);
457 av_freep(&o->meta_data_maps);
458 av_freep(&o->streamid_map);
460 memset(o, 0, sizeof(*o));
462 if(is_input) o->recording_time = bak.recording_time;
463 else o->recording_time = INT64_MAX;
464 o->mux_max_delay = 0.7;
465 o->limit_filesize = UINT64_MAX;
466 o->chapters_input_file = INT_MAX;
472 static int alloc_buffer(AVCodecContext *s, InputStream *ist, FrameBuffer **pbuf)
474 FrameBuffer *buf = av_mallocz(sizeof(*buf));
476 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
477 int h_chroma_shift, v_chroma_shift;
478 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
479 int w = s->width, h = s->height;
482 return AVERROR(ENOMEM);
484 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
489 avcodec_align_dimensions(s, &w, &h);
490 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
491 s->pix_fmt, 32)) < 0) {
495 /* XXX this shouldn't be needed, but some tests break without this line
496 * those decoders are buggy and need to be fixed.
497 * the following tests fail:
498 * bethsoft-vid, cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
500 memset(buf->base[0], 128, ret);
502 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
503 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
504 const int h_shift = i==0 ? 0 : h_chroma_shift;
505 const int v_shift = i==0 ? 0 : v_chroma_shift;
506 if (s->flags & CODEC_FLAG_EMU_EDGE)
507 buf->data[i] = buf->base[i];
509 buf->data[i] = buf->base[i] +
510 FFALIGN((buf->linesize[i]*edge >> v_shift) +
511 (pixel_size*edge >> h_shift), 32);
515 buf->pix_fmt = s->pix_fmt;
522 static void free_buffer_pool(InputStream *ist)
524 FrameBuffer *buf = ist->buffer_pool;
526 ist->buffer_pool = buf->next;
527 av_freep(&buf->base[0]);
529 buf = ist->buffer_pool;
533 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
535 av_assert0(buf->refcount);
537 if (!buf->refcount) {
538 buf->next = ist->buffer_pool;
539 ist->buffer_pool = buf;
543 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
545 InputStream *ist = s->opaque;
549 if(av_image_check_size(s->width, s->height, 0, s))
552 if (!ist->buffer_pool && (ret = alloc_buffer(s, ist, &ist->buffer_pool)) < 0)
555 buf = ist->buffer_pool;
556 ist->buffer_pool = buf->next;
558 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
559 av_freep(&buf->base[0]);
562 if ((ret = alloc_buffer(s, ist, &buf)) < 0)
568 frame->type = FF_BUFFER_TYPE_USER;
569 frame->extended_data = frame->data;
570 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
572 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
573 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
574 frame->data[i] = buf->data[i];
575 frame->linesize[i] = buf->linesize[i];
581 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
583 InputStream *ist = s->opaque;
584 FrameBuffer *buf = frame->opaque;
587 if(frame->type!=FF_BUFFER_TYPE_USER)
588 return avcodec_default_release_buffer(s, frame);
590 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
591 frame->data[i] = NULL;
593 unref_buffer(ist, buf);
596 static void filter_release_buffer(AVFilterBuffer *fb)
598 FrameBuffer *buf = fb->priv;
600 unref_buffer(buf->ist, buf);
605 static int configure_video_filters(InputStream *ist, OutputStream *ost)
607 AVFilterContext *last_filter, *filter;
608 /** filter graph containing all filters including input & output */
609 AVCodecContext *codec = ost->st->codec;
610 AVCodecContext *icodec = ist->st->codec;
611 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
612 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
613 AVRational sample_aspect_ratio;
617 ost->graph = avfilter_graph_alloc();
619 if (ist->st->sample_aspect_ratio.num) {
620 sample_aspect_ratio = ist->st->sample_aspect_ratio;
622 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
624 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
625 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
626 sample_aspect_ratio.num, sample_aspect_ratio.den);
628 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
629 "src", args, NULL, ost->graph);
632 #if FF_API_OLD_VSINK_API
633 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
634 "out", NULL, pix_fmts, ost->graph);
636 buffersink_params->pixel_fmts = pix_fmts;
637 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
638 "out", NULL, buffersink_params, ost->graph);
640 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;
3692 av_log(NULL, AV_LOG_WARNING,
3693 "-loop_input is deprecated, use -loop 1\n"
3694 "Note, both loop options only work with -f image2\n"
3696 ic->loop_input = loop_input;
3699 /* open the input file with generic avformat function */
3700 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3702 print_error(filename, err);
3705 assert_avoptions(format_opts);
3707 /* apply forced codec ids */
3708 for (i = 0; i < ic->nb_streams; i++)
3709 choose_decoder(o, ic, ic->streams[i]);
3711 /* Set AVCodecContext options for avformat_find_stream_info */
3712 opts = setup_find_stream_info_opts(ic, codec_opts);
3713 orig_nb_streams = ic->nb_streams;
3715 /* If not enough info to get the stream parameters, we decode the
3716 first frames to get it. (used in mpeg case for example) */
3717 ret = avformat_find_stream_info(ic, opts);
3719 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3720 avformat_close_input(&ic);
3724 timestamp = o->start_time;
3725 /* add the stream start time */
3726 if (ic->start_time != AV_NOPTS_VALUE)
3727 timestamp += ic->start_time;
3729 /* if seeking requested, we execute it */
3730 if (o->start_time != 0) {
3731 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3733 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3734 filename, (double)timestamp / AV_TIME_BASE);
3738 /* update the current parameters so that they match the one of the input stream */
3739 add_input_streams(o, ic);
3741 /* dump the file content */
3742 av_dump_format(ic, nb_input_files, filename, 0);
3744 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3745 input_files[nb_input_files - 1].ctx = ic;
3746 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3747 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3748 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3749 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3751 for (i = 0; i < o->nb_dump_attachment; i++) {
3754 for (j = 0; j < ic->nb_streams; j++) {
3755 AVStream *st = ic->streams[j];
3757 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3758 dump_attachment(st, o->dump_attachment[i].u.str);
3762 for (i = 0; i < orig_nb_streams; i++)
3763 av_dict_free(&opts[i]);
3766 reset_options(o, 1);
3770 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3775 for (p = kf; *p; p++)
3778 ost->forced_kf_count = n;
3779 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3780 if (!ost->forced_kf_pts) {
3781 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3784 for (i = 0; i < n; i++) {
3785 p = i ? strchr(p, ',') + 1 : kf;
3786 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3790 static uint8_t *get_line(AVIOContext *s)
3796 if (avio_open_dyn_buf(&line) < 0) {
3797 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3801 while ((c = avio_r8(s)) && c != '\n')
3804 avio_close_dyn_buf(line, &buf);
3809 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3812 char filename[1000];
3813 const char *base[3] = { getenv("AVCONV_DATADIR"),
3818 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3822 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3823 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3824 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3827 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3828 i != 1 ? "" : "/.avconv", preset_name);
3829 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3835 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3837 char *codec_name = NULL;
3839 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3841 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3842 NULL, ost->st->codec->codec_type);
3843 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3844 } else if (!strcmp(codec_name, "copy"))
3845 ost->stream_copy = 1;
3847 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3848 ost->st->codec->codec_id = ost->enc->id;
3852 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
3855 AVStream *st = avformat_new_stream(oc, NULL);
3856 int idx = oc->nb_streams - 1, ret = 0;
3857 char *bsf = NULL, *next, *codec_tag = NULL;
3858 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3860 char *buf = NULL, *arg = NULL, *preset = NULL;
3861 AVIOContext *s = NULL;
3864 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3868 if (oc->nb_streams - 1 < o->nb_streamid_map)
3869 st->id = o->streamid_map[oc->nb_streams - 1];
3871 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3872 nb_output_streams + 1);
3873 ost = &output_streams[nb_output_streams - 1];
3874 ost->file_index = nb_output_files;
3877 st->codec->codec_type = type;
3878 choose_encoder(o, oc, ost);
3880 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3883 avcodec_get_context_defaults3(st->codec, ost->enc);
3884 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3886 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3887 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3890 if (!buf[0] || buf[0] == '#') {
3894 if (!(arg = strchr(buf, '='))) {
3895 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3899 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3901 } while (!s->eof_reached);
3905 av_log(NULL, AV_LOG_FATAL,
3906 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3907 preset, ost->file_index, ost->index);
3911 ost->max_frames = INT64_MAX;
3912 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3914 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3916 if (next = strchr(bsf, ','))
3918 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3919 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3923 bsfc_prev->next = bsfc;
3925 ost->bitstream_filters = bsfc;
3931 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3933 uint32_t tag = strtol(codec_tag, &next, 0);
3935 tag = AV_RL32(codec_tag);
3936 st->codec->codec_tag = tag;
3939 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3940 if (qscale >= 0 || same_quant) {
3941 st->codec->flags |= CODEC_FLAG_QSCALE;
3942 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3945 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3946 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3948 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3952 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3955 const char *p = str;
3962 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3969 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3973 AVCodecContext *video_enc;
3975 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3977 video_enc = st->codec;
3979 if (!ost->stream_copy) {
3980 const char *p = NULL;
3981 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3982 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3983 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3986 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3987 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3988 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3992 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3993 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3994 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3998 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3999 if (frame_aspect_ratio)
4000 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
4002 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4003 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4004 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4005 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4008 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4011 video_enc->gop_size = 0;
4012 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4014 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4015 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4018 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4020 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4022 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4023 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4026 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4029 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4030 for (i = 0; p; i++) {
4032 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4034 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4037 /* FIXME realloc failure */
4038 video_enc->rc_override =
4039 av_realloc(video_enc->rc_override,
4040 sizeof(RcOverride) * (i + 1));
4041 video_enc->rc_override[i].start_frame = start;
4042 video_enc->rc_override[i].end_frame = end;
4044 video_enc->rc_override[i].qscale = q;
4045 video_enc->rc_override[i].quality_factor = 1.0;
4048 video_enc->rc_override[i].qscale = 0;
4049 video_enc->rc_override[i].quality_factor = -q/100.0;
4054 video_enc->rc_override_count = i;
4055 if (!video_enc->rc_initial_buffer_occupancy)
4056 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4057 video_enc->intra_dc_precision = intra_dc_precision - 8;
4060 video_enc->flags|= CODEC_FLAG_PSNR;
4065 video_enc->flags |= CODEC_FLAG_PASS1;
4068 video_enc->flags |= CODEC_FLAG_PASS2;
4072 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4073 if (forced_key_frames)
4074 parse_forced_key_frames(forced_key_frames, ost);
4076 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4078 ost->top_field_first = -1;
4079 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4082 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4084 ost->avfilter = av_strdup(filters);
4087 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4093 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
4098 AVCodecContext *audio_enc;
4100 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
4103 audio_enc = st->codec;
4104 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4106 if (!ost->stream_copy) {
4107 char *sample_fmt = NULL;
4109 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4111 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4113 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4114 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4118 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4120 ost->rematrix_volume=1.0;
4121 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4124 /* check for channel mapping for this audio stream */
4125 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4126 AudioChannelMap *map = &o->audio_channel_maps[n];
4127 InputStream *ist = &input_streams[ost->source_index];
4128 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4129 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4130 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4131 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4132 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4134 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4135 ost->file_index, ost->st->index);
4142 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
4146 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
4147 if (!ost->stream_copy) {
4148 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4155 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
4157 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
4158 ost->stream_copy = 1;
4162 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
4166 AVCodecContext *subtitle_enc;
4168 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
4170 subtitle_enc = st->codec;
4172 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4177 /* arg format is "output-stream-index:streamid-value". */
4178 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4184 av_strlcpy(idx_str, arg, sizeof(idx_str));
4185 p = strchr(idx_str, ':');
4187 av_log(NULL, AV_LOG_FATAL,
4188 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4193 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4194 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4195 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4199 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4201 AVFormatContext *is = ifile->ctx;
4202 AVFormatContext *os = ofile->ctx;
4205 for (i = 0; i < is->nb_chapters; i++) {
4206 AVChapter *in_ch = is->chapters[i], *out_ch;
4207 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4208 AV_TIME_BASE_Q, in_ch->time_base);
4209 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4210 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4213 if (in_ch->end < ts_off)
4215 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4218 out_ch = av_mallocz(sizeof(AVChapter));
4220 return AVERROR(ENOMEM);
4222 out_ch->id = in_ch->id;
4223 out_ch->time_base = in_ch->time_base;
4224 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4225 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4228 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4231 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4233 return AVERROR(ENOMEM);
4234 os->chapters[os->nb_chapters - 1] = out_ch;
4239 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4242 AVFormatContext *ic = avformat_alloc_context();
4244 ic->interrupt_callback = int_cb;
4245 err = avformat_open_input(&ic, filename, NULL, NULL);
4248 /* copy stream format */
4249 for(i=0;i<ic->nb_streams;i++) {
4253 AVCodecContext *avctx;
4255 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4256 ost = new_output_stream(o, s, codec->type);
4261 // FIXME: a more elegant solution is needed
4262 memcpy(st, ic->streams[i], sizeof(AVStream));
4263 st->info = av_malloc(sizeof(*st->info));
4264 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4266 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4268 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4269 choose_sample_fmt(st, codec);
4270 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4271 choose_pixel_fmt(st, codec);
4274 avformat_close_input(&ic);
4278 static void opt_output_file(void *optctx, const char *filename)
4280 OptionsContext *o = optctx;
4281 AVFormatContext *oc;
4283 AVOutputFormat *file_oformat;
4287 if (!strcmp(filename, "-"))
4290 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4292 print_error(filename, err);
4295 file_oformat= oc->oformat;
4296 oc->interrupt_callback = int_cb;
4298 if (!strcmp(file_oformat->name, "ffm") &&
4299 av_strstart(filename, "http:", NULL)) {
4301 /* special case for files sent to ffserver: we get the stream
4302 parameters from ffserver */
4303 int err = read_ffserver_streams(o, oc, filename);
4305 print_error(filename, err);
4308 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4309 ost = &output_streams[j];
4310 for (i = 0; i < nb_input_streams; i++) {
4311 ist = &input_streams[i];
4312 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4314 ost->source_index= i;
4320 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));
4324 } else if (!o->nb_stream_maps) {
4325 /* pick the "best" stream of each type */
4326 #define NEW_STREAM(type, index)\
4328 ost = new_ ## type ## _stream(o, oc);\
4329 ost->source_index = index;\
4330 ost->sync_ist = &input_streams[index];\
4331 input_streams[index].discard = 0;\
4334 /* video: highest resolution */
4335 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4336 int area = 0, idx = -1;
4337 for (i = 0; i < nb_input_streams; i++) {
4338 ist = &input_streams[i];
4339 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4340 ist->st->codec->width * ist->st->codec->height > area) {
4341 area = ist->st->codec->width * ist->st->codec->height;
4345 NEW_STREAM(video, idx);
4348 /* audio: most channels */
4349 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4350 int channels = 0, idx = -1;
4351 for (i = 0; i < nb_input_streams; i++) {
4352 ist = &input_streams[i];
4353 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4354 ist->st->codec->channels > channels) {
4355 channels = ist->st->codec->channels;
4359 NEW_STREAM(audio, idx);
4362 /* subtitles: pick first */
4363 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4364 for (i = 0; i < nb_input_streams; i++)
4365 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4366 NEW_STREAM(subtitle, i);
4370 /* do something with data? */
4372 for (i = 0; i < o->nb_stream_maps; i++) {
4373 StreamMap *map = &o->stream_maps[i];
4378 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4379 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4381 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4383 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4385 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4388 switch (ist->st->codec->codec_type) {
4389 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
4390 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
4391 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
4392 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
4393 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
4395 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4396 map->file_index, map->stream_index);
4400 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
4401 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
4402 map->sync_stream_index];
4407 /* handle attached files */
4408 for (i = 0; i < o->nb_attachments; i++) {
4410 uint8_t *attachment;
4414 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4415 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4419 if ((len = avio_size(pb)) <= 0) {
4420 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4424 if (!(attachment = av_malloc(len))) {
4425 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4429 avio_read(pb, attachment, len);
4431 ost = new_attachment_stream(o, oc);
4432 ost->stream_copy = 0;
4433 ost->source_index = -1;
4434 ost->attachment_filename = o->attachments[i];
4435 ost->st->codec->extradata = attachment;
4436 ost->st->codec->extradata_size = len;
4438 p = strrchr(o->attachments[i], '/');
4439 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4443 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4444 output_files[nb_output_files - 1].ctx = oc;
4445 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4446 output_files[nb_output_files - 1].recording_time = o->recording_time;
4447 output_files[nb_output_files - 1].start_time = o->start_time;
4448 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4449 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4451 /* check filename in case of an image number is expected */
4452 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4453 if (!av_filename_number_test(oc->filename)) {
4454 print_error(oc->filename, AVERROR(EINVAL));
4459 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4460 /* test if it already exists to avoid losing precious files */
4461 assert_file_overwrite(filename);
4464 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4465 &oc->interrupt_callback,
4466 &output_files[nb_output_files - 1].opts)) < 0) {
4467 print_error(filename, err);
4472 if (o->mux_preload) {
4474 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4475 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4477 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4479 if (loop_output >= 0) {
4480 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
4481 oc->loop_output = loop_output;
4485 for (i = 0; i < o->nb_metadata_map; i++) {
4487 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4489 if (in_file_index < 0)
4491 if (in_file_index >= nb_input_files) {
4492 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4495 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, input_files[in_file_index].ctx, o);
4499 if (o->chapters_input_file >= nb_input_files) {
4500 if (o->chapters_input_file == INT_MAX) {
4501 /* copy chapters from the first input file that has them*/
4502 o->chapters_input_file = -1;
4503 for (i = 0; i < nb_input_files; i++)
4504 if (input_files[i].ctx->nb_chapters) {
4505 o->chapters_input_file = i;
4509 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4510 o->chapters_input_file);
4514 if (o->chapters_input_file >= 0)
4515 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4516 !o->metadata_chapters_manual);
4518 /* copy global metadata by default */
4519 if (!o->metadata_global_manual && nb_input_files){
4520 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4521 AV_DICT_DONT_OVERWRITE);
4522 if(o->recording_time != INT64_MAX)
4523 av_dict_set(&oc->metadata, "duration", NULL, 0);
4525 if (!o->metadata_streams_manual)
4526 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4528 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4530 ist = &input_streams[output_streams[i].source_index];
4531 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4534 /* process manually set metadata */
4535 for (i = 0; i < o->nb_metadata; i++) {
4538 const char *stream_spec;
4539 int index = 0, j, ret = 0;
4541 val = strchr(o->metadata[i].u.str, '=');
4543 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4544 o->metadata[i].u.str);
4549 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4551 for (j = 0; j < oc->nb_streams; j++) {
4552 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4553 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4557 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4565 if (index < 0 || index >= oc->nb_chapters) {
4566 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4569 m = &oc->chapters[index]->metadata;
4572 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4575 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4579 reset_options(o, 0);
4582 /* same option as mencoder */
4583 static int opt_pass(const char *opt, const char *arg)
4585 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4589 static int64_t getutime(void)
4592 struct rusage rusage;
4594 getrusage(RUSAGE_SELF, &rusage);
4595 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4596 #elif HAVE_GETPROCESSTIMES
4598 FILETIME c, e, k, u;
4599 proc = GetCurrentProcess();
4600 GetProcessTimes(proc, &c, &e, &k, &u);
4601 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4603 return av_gettime();
4607 static int64_t getmaxrss(void)
4609 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4610 struct rusage rusage;
4611 getrusage(RUSAGE_SELF, &rusage);
4612 return (int64_t)rusage.ru_maxrss * 1024;
4613 #elif HAVE_GETPROCESSMEMORYINFO
4615 PROCESS_MEMORY_COUNTERS memcounters;
4616 proc = GetCurrentProcess();
4617 memcounters.cb = sizeof(memcounters);
4618 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4619 return memcounters.PeakPagefileUsage;
4625 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4627 return parse_option(o, "q:a", arg, options);
4630 static void show_usage(void)
4632 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
4633 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4634 av_log(NULL, AV_LOG_INFO, "\n");
4637 static int opt_help(const char *opt, const char *arg)
4639 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4640 av_log_set_callback(log_callback_help);
4642 show_help_options(options, "Main options:\n",
4643 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4644 show_help_options(options, "\nAdvanced options:\n",
4645 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4647 show_help_options(options, "\nVideo options:\n",
4648 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4650 show_help_options(options, "\nAdvanced Video options:\n",
4651 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4652 OPT_VIDEO | OPT_EXPERT);
4653 show_help_options(options, "\nAudio options:\n",
4654 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4656 show_help_options(options, "\nAdvanced Audio options:\n",
4657 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4658 OPT_AUDIO | OPT_EXPERT);
4659 show_help_options(options, "\nSubtitle options:\n",
4660 OPT_SUBTITLE | OPT_GRAB,
4662 show_help_options(options, "\nAudio/Video grab options:\n",
4666 show_help_children(avcodec_get_class(), flags);
4667 show_help_children(avformat_get_class(), flags);
4668 show_help_children(sws_get_class(), flags);
4673 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4675 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4676 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4678 if (!strncmp(arg, "pal-", 4)) {
4681 } else if (!strncmp(arg, "ntsc-", 5)) {
4684 } else if (!strncmp(arg, "film-", 5)) {
4688 /* Try to determine PAL/NTSC by peeking in the input files */
4689 if (nb_input_files) {
4691 for (j = 0; j < nb_input_files; j++) {
4692 for (i = 0; i < input_files[j].nb_streams; i++) {
4693 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4694 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4696 fr = c->time_base.den * 1000 / c->time_base.num;
4700 } else if ((fr == 29970) || (fr == 23976)) {
4705 if (norm != UNKNOWN)
4709 if (norm != UNKNOWN)
4710 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4713 if (norm == UNKNOWN) {
4714 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4715 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4716 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4720 if (!strcmp(arg, "vcd")) {
4721 opt_video_codec(o, "c:v", "mpeg1video");
4722 opt_audio_codec(o, "c:a", "mp2");
4723 parse_option(o, "f", "vcd", options);
4725 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4726 parse_option(o, "r", frame_rates[norm], options);
4727 opt_default("g", norm == PAL ? "15" : "18");
4729 opt_default("b:v", "1150000");
4730 opt_default("maxrate", "1150000");
4731 opt_default("minrate", "1150000");
4732 opt_default("bufsize", "327680"); // 40*1024*8;
4734 opt_default("b:a", "224000");
4735 parse_option(o, "ar", "44100", options);
4736 parse_option(o, "ac", "2", options);
4738 opt_default("packetsize", "2324");
4739 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4741 /* We have to offset the PTS, so that it is consistent with the SCR.
4742 SCR starts at 36000, but the first two packs contain only padding
4743 and the first pack from the other stream, respectively, may also have
4744 been written before.
4745 So the real data starts at SCR 36000+3*1200. */
4746 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4747 } else if (!strcmp(arg, "svcd")) {
4749 opt_video_codec(o, "c:v", "mpeg2video");
4750 opt_audio_codec(o, "c:a", "mp2");
4751 parse_option(o, "f", "svcd", options);
4753 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4754 parse_option(o, "r", frame_rates[norm], options);
4755 parse_option(o, "pix_fmt", "yuv420p", options);
4756 opt_default("g", norm == PAL ? "15" : "18");
4758 opt_default("b:v", "2040000");
4759 opt_default("maxrate", "2516000");
4760 opt_default("minrate", "0"); // 1145000;
4761 opt_default("bufsize", "1835008"); // 224*1024*8;
4762 opt_default("flags", "+scan_offset");
4765 opt_default("b:a", "224000");
4766 parse_option(o, "ar", "44100", options);
4768 opt_default("packetsize", "2324");
4770 } else if (!strcmp(arg, "dvd")) {
4772 opt_video_codec(o, "c:v", "mpeg2video");
4773 opt_audio_codec(o, "c:a", "ac3");
4774 parse_option(o, "f", "dvd", options);
4776 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4777 parse_option(o, "r", frame_rates[norm], options);
4778 parse_option(o, "pix_fmt", "yuv420p", options);
4779 opt_default("g", norm == PAL ? "15" : "18");
4781 opt_default("b:v", "6000000");
4782 opt_default("maxrate", "9000000");
4783 opt_default("minrate", "0"); // 1500000;
4784 opt_default("bufsize", "1835008"); // 224*1024*8;
4786 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4787 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4789 opt_default("b:a", "448000");
4790 parse_option(o, "ar", "48000", options);
4792 } else if (!strncmp(arg, "dv", 2)) {
4794 parse_option(o, "f", "dv", options);
4796 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4797 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4798 norm == PAL ? "yuv420p" : "yuv411p", options);
4799 parse_option(o, "r", frame_rates[norm], options);
4801 parse_option(o, "ar", "48000", options);
4802 parse_option(o, "ac", "2", options);
4805 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4806 return AVERROR(EINVAL);
4811 static int opt_vstats_file(const char *opt, const char *arg)
4813 av_free (vstats_filename);
4814 vstats_filename = av_strdup (arg);
4818 static int opt_vstats(const char *opt, const char *arg)
4821 time_t today2 = time(NULL);
4822 struct tm *today = localtime(&today2);
4824 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4826 return opt_vstats_file(opt, filename);
4829 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4831 return parse_option(o, "frames:v", arg, options);
4834 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4836 return parse_option(o, "frames:a", arg, options);
4839 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4841 return parse_option(o, "frames:d", arg, options);
4844 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4847 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4848 const char *codec_name = *opt == 'v' ? video_codec_name :
4849 *opt == 'a' ? audio_codec_name :
4850 subtitle_codec_name;
4852 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4853 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4854 av_log(0, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4856 av_log(0, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4861 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4862 if(line[0] == '#' && !e)
4864 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4866 av_log(0, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4869 if(!strcmp(tmp, "acodec")){
4870 opt_audio_codec(o, tmp, tmp2);
4871 }else if(!strcmp(tmp, "vcodec")){
4872 opt_video_codec(o, tmp, tmp2);
4873 }else if(!strcmp(tmp, "scodec")){
4874 opt_subtitle_codec(o, tmp, tmp2);
4875 }else if(!strcmp(tmp, "dcodec")){
4876 opt_data_codec(o, tmp, tmp2);
4877 }else if(opt_default(tmp, tmp2) < 0){
4878 av_log(0, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4888 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4892 static int opt_passlogfile(const char *opt, const char *arg)
4894 pass_logfilename_prefix = arg;
4895 #if CONFIG_LIBX264_ENCODER
4896 return opt_default("passlogfile", arg);
4902 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4904 char *s = av_asprintf("%s:%c", opt + 1, *opt);
4905 int ret = parse_option(o, s, arg, options);
4910 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4912 if(!strcmp(opt, "b")){
4913 av_log(0,AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4914 return parse_option(o, "b:v", arg, options);
4916 return opt_default(opt, arg);
4919 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
4921 return parse_option(o, "filter:v", arg, options);
4924 static int opt_vsync(const char *opt, const char *arg)
4926 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
4927 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
4928 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
4930 if (video_sync_method == VSYNC_AUTO)
4931 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
4935 #define OFFSET(x) offsetof(OptionsContext, x)
4936 static const OptionDef options[] = {
4938 #include "cmdutils_common_opts.h"
4939 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
4940 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
4941 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4942 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
4943 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4944 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
4945 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
4946 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
4947 { "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]" },
4948 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
4949 "outfile[,metadata]:infile[,metadata]" },
4950 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
4951 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4952 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
4953 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
4954 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
4955 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
4956 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4957 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
4958 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
4959 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4960 "add timings for benchmarking" },
4961 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4962 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4963 "dump each input packet" },
4964 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4965 "when dumping packets, also dump the payload" },
4966 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
4967 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4968 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4969 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4970 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
4971 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4972 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4973 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4974 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "source" },
4975 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4976 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4977 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4978 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
4979 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
4980 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
4981 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4982 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
4984 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
4986 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
4987 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
4988 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
4991 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
4992 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4993 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
4994 { "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" },
4995 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
4996 { "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" },
4997 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4998 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4999 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5000 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5001 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5002 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5003 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5004 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5005 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5006 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
5007 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5008 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5009 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5010 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5011 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5012 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5013 "use same quantizer as source (implies VBR)" },
5014 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5015 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5016 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
5017 "deinterlace pictures" },
5018 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5019 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5020 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5022 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5024 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5025 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5026 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5027 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5028 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5029 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5030 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5031 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5032 { "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" },
5033 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5036 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5037 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5038 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5039 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5040 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5041 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5042 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5043 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5044 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5045 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
5047 /* subtitle options */
5048 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5049 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5050 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5053 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5054 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5055 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5058 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5059 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5061 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5062 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5063 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5065 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5066 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5067 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5068 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5069 /* data codec support */
5070 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5071 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5073 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5077 int main(int argc, char **argv)
5079 OptionsContext o = { 0 };
5082 reset_options(&o, 0);
5084 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5085 parse_loglevel(argc, argv, options);
5087 if(argc>1 && !strcmp(argv[1], "-d")){
5089 av_log_set_callback(log_callback_null);
5094 avcodec_register_all();
5096 avdevice_register_all();
5099 avfilter_register_all();
5102 avformat_network_init();
5104 show_banner(argc, argv, options);
5109 parse_options(&o, argc, argv, options, opt_output_file);
5111 if (nb_output_files <= 0 && nb_input_files == 0) {
5113 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5117 /* file converter / grab */
5118 if (nb_output_files <= 0) {
5119 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5123 if (nb_input_files == 0) {
5124 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5129 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
5131 ti = getutime() - ti;
5133 int maxrss = getmaxrss() / 1024;
5134 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);