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 "libavutil/timestamp.h"
53 #include "libavformat/os_support.h"
54 #include "libswresample/swresample.h"
56 #include "libavformat/ffm.h" // not public API
59 # include "libavfilter/avcodec.h"
60 # include "libavfilter/avfilter.h"
61 # include "libavfilter/avfiltergraph.h"
62 # include "libavfilter/buffersink.h"
63 # include "libavfilter/buffersrc.h"
64 # include "libavfilter/vsrc_buffer.h"
67 #if HAVE_SYS_RESOURCE_H
68 #include <sys/types.h>
70 #include <sys/resource.h>
71 #elif HAVE_GETPROCESSTIMES
74 #if HAVE_GETPROCESSMEMORYINFO
80 #include <sys/select.h>
85 #include <sys/ioctl.h>
95 #include "libavutil/avassert.h"
98 #define VSYNC_PASSTHROUGH 0
101 #define VSYNC_DROP 0xff
103 const char program_name[] = "ffmpeg";
104 const int program_birth_year = 2000;
106 /* select an input stream for an output stream */
107 typedef struct StreamMap {
108 int disabled; /** 1 is this mapping is disabled by a negative map */
112 int sync_stream_index;
116 int file_idx, stream_idx, channel_idx; // input
117 int ofile_idx, ostream_idx; // output
120 static const OptionDef options[];
122 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
124 static int frame_bits_per_raw_sample = 0;
125 static int video_discard = 0;
126 static int same_quant = 0;
127 static int do_deinterlace = 0;
128 static int intra_dc_precision = 8;
129 static int qp_hist = 0;
130 static int intra_only = 0;
131 static const char *video_codec_name = NULL;
132 static const char *audio_codec_name = NULL;
133 static const char *subtitle_codec_name = NULL;
135 static int file_overwrite = 0;
136 static int no_file_overwrite = 0;
137 static int do_benchmark = 0;
138 static int do_hex_dump = 0;
139 static int do_pkt_dump = 0;
140 static int do_psnr = 0;
141 static int do_pass = 0;
142 static const char *pass_logfilename_prefix;
143 static int video_sync_method = VSYNC_AUTO;
144 static int audio_sync_method = 0;
145 static float audio_drift_threshold = 0.1;
146 static int copy_ts = 0;
147 static int copy_tb = -1;
148 static int opt_shortest = 0;
149 static char *vstats_filename;
150 static FILE *vstats_file;
152 static int audio_volume = 256;
154 static int exit_on_error = 0;
155 static int using_stdin = 0;
156 static int run_as_daemon = 0;
157 static volatile int received_nb_signals = 0;
158 static int64_t video_size = 0;
159 static int64_t audio_size = 0;
160 static int64_t extra_size = 0;
161 static int nb_frames_dup = 0;
162 static int nb_frames_drop = 0;
163 static int input_sync;
165 static float dts_delta_threshold = 10;
166 static float dts_error_threshold = 3600*30;
168 static int print_stats = 1;
169 static int debug_ts = 0;
171 static uint8_t *audio_buf;
172 static unsigned int allocated_audio_buf_size;
173 static uint8_t *async_buf;
174 static unsigned int allocated_async_buf_size;
176 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
178 typedef struct FrameBuffer {
184 enum PixelFormat pix_fmt;
187 struct InputStream *ist;
188 struct FrameBuffer *next;
191 typedef struct InputStream {
194 int discard; /* true if stream data should be discarded */
195 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
197 AVFrame *decoded_frame;
198 AVFrame *filtered_frame;
200 int64_t start; /* time when read started */
201 /* predicted dts of the next packet read for this stream or (when there are
202 * several frames in a packet) of the next frame in current packet */
204 /* dts of the last packet read for this stream */
207 int64_t next_pts; ///< synthetic pts for the next decode frame
208 int64_t pts; ///< current pts of the decoded frame
210 int is_start; /* is 1 at the start and after a discontinuity */
211 int showed_multi_packet_warning;
214 /* a pool of free buffers for decoded data */
215 FrameBuffer *buffer_pool;
219 typedef struct InputFile {
220 AVFormatContext *ctx;
221 int eof_reached; /* true if eof reached */
222 int ist_index; /* index of first stream in input_streams */
223 int buffer_size; /* current total buffer size */
225 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
226 from ctx.nb_streams if new streams appear during av_read_frame() */
230 typedef struct OutputStream {
231 int file_index; /* file index */
232 int index; /* stream index in the output file */
233 int source_index; /* InputStream index */
234 AVStream *st; /* stream in the output file */
235 int encoding_needed; /* true if encoding needed for this stream */
237 /* input pts and corresponding output pts
239 struct InputStream *sync_ist; /* input stream to sync against */
240 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
241 AVBitStreamFilterContext *bitstream_filters;
244 AVFrame *output_frame;
248 AVFrame resample_frame; /* temporary frame for image resampling */
249 struct SwsContext *img_resample_ctx; /* for image resampling */
252 int resample_pix_fmt;
253 AVRational frame_rate;
257 float frame_aspect_ratio;
259 /* forced key frames */
260 int64_t *forced_kf_pts;
266 int audio_channels_map[SWR_CH_MAX]; ///< list of the channels id to pick from the source stream
267 int audio_channels_mapped; ///< number of channels in audio_channels_map
268 int resample_sample_fmt;
269 int resample_channels;
270 int resample_sample_rate;
271 float rematrix_volume;
272 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
278 AVFilterContext *output_video_filter;
279 AVFilterContext *input_video_filter;
280 AVFilterBufferRef *picref;
282 AVFilterGraph *graph;
287 int is_past_recording_time;
289 const char *attachment_filename;
290 int copy_initial_nonkeyframes;
296 /* init terminal so that we can grab keys */
297 static struct termios oldtty;
298 static int restore_tty;
301 typedef struct OutputFile {
302 AVFormatContext *ctx;
304 int ost_index; /* index of the first stream in output_streams */
305 int64_t recording_time; /* desired length of the resulting file in microseconds */
306 int64_t start_time; /* start time in microseconds */
307 uint64_t limit_filesize; /* filesize limit expressed in bytes */
310 static InputStream *input_streams = NULL;
311 static int nb_input_streams = 0;
312 static InputFile *input_files = NULL;
313 static int nb_input_files = 0;
315 static OutputStream *output_streams = NULL;
316 static int nb_output_streams = 0;
317 static OutputFile *output_files = NULL;
318 static int nb_output_files = 0;
320 typedef struct OptionsContext {
321 /* input/output options */
325 SpecifierOpt *codec_names;
327 SpecifierOpt *audio_channels;
328 int nb_audio_channels;
329 SpecifierOpt *audio_sample_rate;
330 int nb_audio_sample_rate;
331 SpecifierOpt *rematrix_volume;
332 int nb_rematrix_volume;
333 SpecifierOpt *frame_rates;
335 SpecifierOpt *frame_sizes;
337 SpecifierOpt *frame_pix_fmts;
338 int nb_frame_pix_fmts;
341 int64_t input_ts_offset;
344 SpecifierOpt *ts_scale;
346 SpecifierOpt *dump_attachment;
347 int nb_dump_attachment;
350 StreamMap *stream_maps;
352 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
353 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
354 int metadata_global_manual;
355 int metadata_streams_manual;
356 int metadata_chapters_manual;
357 const char **attachments;
360 int chapters_input_file;
362 int64_t recording_time;
363 uint64_t limit_filesize;
369 int subtitle_disable;
372 /* indexed by output file stream index */
376 SpecifierOpt *metadata;
378 SpecifierOpt *max_frames;
380 SpecifierOpt *bitstream_filters;
381 int nb_bitstream_filters;
382 SpecifierOpt *codec_tags;
384 SpecifierOpt *sample_fmts;
386 SpecifierOpt *qscale;
388 SpecifierOpt *forced_key_frames;
389 int nb_forced_key_frames;
390 SpecifierOpt *force_fps;
392 SpecifierOpt *frame_aspect_ratios;
393 int nb_frame_aspect_ratios;
394 SpecifierOpt *rc_overrides;
396 SpecifierOpt *intra_matrices;
397 int nb_intra_matrices;
398 SpecifierOpt *inter_matrices;
399 int nb_inter_matrices;
400 SpecifierOpt *top_field_first;
401 int nb_top_field_first;
402 SpecifierOpt *metadata_map;
404 SpecifierOpt *presets;
406 SpecifierOpt *copy_initial_nonkeyframes;
407 int nb_copy_initial_nonkeyframes;
409 SpecifierOpt *filters;
414 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
417 for (i = 0; i < o->nb_ ## name; i++) {\
418 char *spec = o->name[i].specifier;\
419 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
420 outvar = o->name[i].u.type;\
426 static void reset_options(OptionsContext *o, int is_input)
428 const OptionDef *po = options;
429 OptionsContext bak= *o;
431 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
433 void *dst = (uint8_t*)o + po->u.off;
435 if (po->flags & OPT_SPEC) {
436 SpecifierOpt **so = dst;
437 int i, *count = (int*)(so + 1);
438 for (i = 0; i < *count; i++) {
439 av_freep(&(*so)[i].specifier);
440 if (po->flags & OPT_STRING)
441 av_freep(&(*so)[i].u.str);
445 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
450 av_freep(&o->stream_maps);
451 av_freep(&o->audio_channel_maps);
452 av_freep(&o->streamid_map);
454 memset(o, 0, sizeof(*o));
456 if(is_input) o->recording_time = bak.recording_time;
457 else o->recording_time = INT64_MAX;
458 o->mux_max_delay = 0.7;
459 o->limit_filesize = UINT64_MAX;
460 o->chapters_input_file = INT_MAX;
466 static int alloc_buffer(InputStream *ist, AVCodecContext *s, FrameBuffer **pbuf)
468 FrameBuffer *buf = av_mallocz(sizeof(*buf));
470 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
471 int h_chroma_shift, v_chroma_shift;
472 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
473 int w = s->width, h = s->height;
476 return AVERROR(ENOMEM);
478 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
483 avcodec_align_dimensions(s, &w, &h);
484 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
485 s->pix_fmt, 32)) < 0) {
489 /* XXX this shouldn't be needed, but some tests break without this line
490 * those decoders are buggy and need to be fixed.
491 * the following tests fail:
492 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
494 memset(buf->base[0], 128, ret);
496 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
497 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
498 const int h_shift = i==0 ? 0 : h_chroma_shift;
499 const int v_shift = i==0 ? 0 : v_chroma_shift;
500 if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1])
501 buf->data[i] = buf->base[i];
503 buf->data[i] = buf->base[i] +
504 FFALIGN((buf->linesize[i]*edge >> v_shift) +
505 (pixel_size*edge >> h_shift), 32);
509 buf->pix_fmt = s->pix_fmt;
516 static void free_buffer_pool(InputStream *ist)
518 FrameBuffer *buf = ist->buffer_pool;
520 ist->buffer_pool = buf->next;
521 av_freep(&buf->base[0]);
523 buf = ist->buffer_pool;
527 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
529 av_assert0(buf->refcount);
531 if (!buf->refcount) {
532 buf->next = ist->buffer_pool;
533 ist->buffer_pool = buf;
537 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
539 InputStream *ist = s->opaque;
543 if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0)
546 if (!ist->buffer_pool && (ret = alloc_buffer(ist, s, &ist->buffer_pool)) < 0)
549 buf = ist->buffer_pool;
550 ist->buffer_pool = buf->next;
552 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
553 av_freep(&buf->base[0]);
555 if ((ret = alloc_buffer(ist, s, &buf)) < 0)
561 frame->type = FF_BUFFER_TYPE_USER;
562 frame->extended_data = frame->data;
563 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
564 frame->width = buf->w;
565 frame->height = buf->h;
566 frame->format = buf->pix_fmt;
567 frame->sample_aspect_ratio = s->sample_aspect_ratio;
569 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
570 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
571 frame->data[i] = buf->data[i];
572 frame->linesize[i] = buf->linesize[i];
578 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
580 InputStream *ist = s->opaque;
581 FrameBuffer *buf = frame->opaque;
584 if(frame->type!=FF_BUFFER_TYPE_USER)
585 return avcodec_default_release_buffer(s, frame);
587 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
588 frame->data[i] = NULL;
590 unref_buffer(ist, buf);
593 static void filter_release_buffer(AVFilterBuffer *fb)
595 FrameBuffer *buf = fb->priv;
597 unref_buffer(buf->ist, buf);
602 static int configure_video_filters(InputStream *ist, OutputStream *ost)
604 AVFilterContext *last_filter, *filter;
605 /** filter graph containing all filters including input & output */
606 AVCodecContext *codec = ost->st->codec;
607 AVCodecContext *icodec = ist->st->codec;
608 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
609 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
610 AVRational sample_aspect_ratio;
614 ost->graph = avfilter_graph_alloc();
616 return AVERROR(ENOMEM);
618 if (ist->st->sample_aspect_ratio.num) {
619 sample_aspect_ratio = ist->st->sample_aspect_ratio;
621 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
623 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,
624 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
625 sample_aspect_ratio.num, sample_aspect_ratio.den, SWS_BILINEAR + ((icodec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
627 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
628 "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);
644 last_filter = ost->input_video_filter;
646 if (codec->width != icodec->width || codec->height != icodec->height) {
647 snprintf(args, 255, "%d:%d:flags=0x%X",
650 (unsigned)ost->sws_flags);
651 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
652 NULL, args, NULL, ost->graph)) < 0)
654 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
656 last_filter = filter;
659 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
660 ost->graph->scale_sws_opts = av_strdup(args);
663 AVFilterInOut *outputs = avfilter_inout_alloc();
664 AVFilterInOut *inputs = avfilter_inout_alloc();
666 outputs->name = av_strdup("in");
667 outputs->filter_ctx = last_filter;
668 outputs->pad_idx = 0;
669 outputs->next = NULL;
671 inputs->name = av_strdup("out");
672 inputs->filter_ctx = ost->output_video_filter;
676 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
678 av_freep(&ost->avfilter);
680 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
684 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
687 codec->width = ost->output_video_filter->inputs[0]->w;
688 codec->height = ost->output_video_filter->inputs[0]->h;
689 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
690 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
691 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
692 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
696 #endif /* CONFIG_AVFILTER */
698 static void term_exit(void)
700 av_log(NULL, AV_LOG_QUIET, "%s", "");
703 tcsetattr (0, TCSANOW, &oldtty);
707 static volatile int received_sigterm = 0;
709 static void sigterm_handler(int sig)
711 received_sigterm = sig;
712 received_nb_signals++;
714 if(received_nb_signals > 3)
718 static void term_init(void)
724 if (tcgetattr (0, &tty) == 0) {
729 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
730 |INLCR|IGNCR|ICRNL|IXON);
731 tty.c_oflag |= OPOST;
732 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
733 tty.c_cflag &= ~(CSIZE|PARENB);
738 tcsetattr (0, TCSANOW, &tty);
740 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
743 avformat_network_deinit();
745 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
746 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
748 signal(SIGXCPU, sigterm_handler);
752 /* read a key without blocking */
753 static int read_key(void)
765 n = select(1, &rfds, NULL, NULL, &tv);
774 # if HAVE_PEEKNAMEDPIPE
776 static HANDLE input_handle;
779 input_handle = GetStdHandle(STD_INPUT_HANDLE);
780 is_pipe = !GetConsoleMode(input_handle, &dw);
783 if (stdin->_cnt > 0) {
788 /* When running under a GUI, you will end here. */
789 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
806 static int decode_interrupt_cb(void *ctx)
808 return received_nb_signals > 1;
811 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
813 void av_noreturn exit_program(int ret)
818 for (i = 0; i < nb_output_files; i++) {
819 AVFormatContext *s = output_files[i].ctx;
820 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
822 avformat_free_context(s);
823 av_dict_free(&output_files[i].opts);
825 for (i = 0; i < nb_output_streams; i++) {
826 AVBitStreamFilterContext *bsfc = output_streams[i].bitstream_filters;
828 AVBitStreamFilterContext *next = bsfc->next;
829 av_bitstream_filter_close(bsfc);
832 output_streams[i].bitstream_filters = NULL;
834 if (output_streams[i].output_frame) {
835 AVFrame *frame = output_streams[i].output_frame;
836 if (frame->extended_data != frame->data)
837 av_freep(&frame->extended_data);
841 for (i = 0; i < nb_input_files; i++) {
842 avformat_close_input(&input_files[i].ctx);
844 for (i = 0; i < nb_input_streams; i++) {
845 av_freep(&input_streams[i].decoded_frame);
846 av_freep(&input_streams[i].filtered_frame);
847 av_dict_free(&input_streams[i].opts);
848 free_buffer_pool(&input_streams[i]);
853 av_free(vstats_filename);
855 av_freep(&input_streams);
856 av_freep(&input_files);
857 av_freep(&output_streams);
858 av_freep(&output_files);
861 av_freep(&audio_buf);
862 allocated_audio_buf_size = 0;
863 av_freep(&async_buf);
864 allocated_async_buf_size = 0;
869 avformat_network_deinit();
871 if (received_sigterm) {
872 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
873 (int) received_sigterm);
877 exit(ret); /* not all OS-es handle main() return value */
880 static void assert_avoptions(AVDictionary *m)
882 AVDictionaryEntry *t;
883 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
884 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
889 static void assert_codec_experimental(AVCodecContext *c, int encoder)
891 const char *codec_string = encoder ? "encoder" : "decoder";
893 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
894 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
895 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
896 "results.\nAdd '-strict experimental' if you want to use it.\n",
897 codec_string, c->codec->name);
898 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
899 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
900 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
901 codec_string, codec->name);
906 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
908 if (codec && codec->sample_fmts) {
909 const enum AVSampleFormat *p = codec->sample_fmts;
910 for (; *p != -1; p++) {
911 if (*p == st->codec->sample_fmt)
915 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
916 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
917 if(av_get_sample_fmt_name(st->codec->sample_fmt))
918 av_log(NULL, AV_LOG_WARNING,
919 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
920 av_get_sample_fmt_name(st->codec->sample_fmt),
922 av_get_sample_fmt_name(codec->sample_fmts[0]));
923 st->codec->sample_fmt = codec->sample_fmts[0];
928 static void choose_sample_rate(AVStream *st, AVCodec *codec)
930 if (codec && codec->supported_samplerates) {
931 const int *p = codec->supported_samplerates;
933 int best_dist = INT_MAX;
935 int dist = abs(st->codec->sample_rate - *p);
936 if (dist < best_dist) {
943 const int *sample_rates = codec->supported_samplerates;
944 av_log(st->codec, AV_LOG_WARNING,
945 "Requested sampling rate (%dHz) unsupported, using %dHz instead\n"
946 "Available sampling rates for %s:",
947 st->codec->sample_rate, best, codec->name);
948 for (i = 0; sample_rates[i]; i++) {
949 if (!sample_rates[i + 1]) av_log(st->codec, AV_LOG_WARNING, " and");
950 else if (i) av_log(st->codec, AV_LOG_WARNING, ",");
951 av_log(st->codec, AV_LOG_WARNING, " %d", sample_rates[i]);
953 av_log(st->codec, AV_LOG_WARNING, ".\n");
955 st->codec->sample_rate = best;
959 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
961 if (codec && codec->pix_fmts) {
962 const enum PixelFormat *p = codec->pix_fmts;
963 int has_alpha= av_pix_fmt_descriptors[st->codec->pix_fmt].nb_components % 2 == 0;
964 enum PixelFormat best= PIX_FMT_NONE;
965 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
966 if (st->codec->codec_id == CODEC_ID_MJPEG) {
967 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
968 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
969 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
970 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
973 for (; *p != PIX_FMT_NONE; p++) {
974 best= avcodec_find_best_pix_fmt2(best, *p, st->codec->pix_fmt, has_alpha, NULL);
975 if (*p == st->codec->pix_fmt)
978 if (*p == PIX_FMT_NONE) {
979 if (st->codec->pix_fmt != PIX_FMT_NONE)
980 av_log(NULL, AV_LOG_WARNING,
981 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
982 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
984 av_pix_fmt_descriptors[best].name);
985 st->codec->pix_fmt = best;
991 get_sync_ipts(const OutputStream *ost, int64_t pts)
993 OutputFile *of = &output_files[ost->file_index];
994 return (double)(pts - of->start_time) / AV_TIME_BASE;
997 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
999 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1000 AVCodecContext *avctx = ost->st->codec;
1003 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1004 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1005 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1008 * Audio encoders may split the packets -- #frames in != #packets out.
1009 * But there is no reordering, so we can limit the number of output packets
1010 * by simply dropping them here.
1011 * Counting encoded video frames needs to be done separately because of
1012 * reordering, see do_video_out()
1014 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1015 if (ost->frame_number >= ost->max_frames) {
1016 av_free_packet(pkt);
1019 ost->frame_number++;
1023 AVPacket new_pkt = *pkt;
1024 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1025 &new_pkt.data, &new_pkt.size,
1026 pkt->data, pkt->size,
1027 pkt->flags & AV_PKT_FLAG_KEY);
1029 av_free_packet(pkt);
1030 new_pkt.destruct = av_destruct_packet;
1032 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1033 bsfc->filter->name, pkt->stream_index,
1034 avctx->codec ? avctx->codec->name : "copy");
1044 pkt->stream_index = ost->index;
1045 ret = av_interleaved_write_frame(s, pkt);
1047 print_error("av_interleaved_write_frame()", ret);
1052 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1054 int fill_char = 0x00;
1055 if (sample_fmt == AV_SAMPLE_FMT_U8)
1057 memset(buf, fill_char, size);
1060 static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,
1061 const uint8_t *buf, int buf_size)
1063 AVCodecContext *enc = ost->st->codec;
1064 AVFrame *frame = NULL;
1066 int ret, got_packet;
1068 av_init_packet(&pkt);
1072 if (buf && buf_size) {
1073 if (!ost->output_frame) {
1074 ost->output_frame = avcodec_alloc_frame();
1075 if (!ost->output_frame) {
1076 av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");
1080 frame = ost->output_frame;
1081 if (frame->extended_data != frame->data)
1082 av_freep(&frame->extended_data);
1083 avcodec_get_frame_defaults(frame);
1085 frame->nb_samples = buf_size /
1086 (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
1087 if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,
1088 buf, buf_size, 1)) < 0) {
1089 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_fill_audio_frame)\n");
1093 frame->pts = ost->sync_opts;
1094 ost->sync_opts += frame->nb_samples;
1098 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1099 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1106 if (pkt.pts != AV_NOPTS_VALUE)
1107 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1108 if (pkt.dts != AV_NOPTS_VALUE)
1109 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1110 if (pkt.duration > 0)
1111 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1113 write_frame(s, &pkt, ost);
1115 audio_size += pkt.size;
1117 av_free_packet(&pkt);
1121 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1122 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1123 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1124 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1130 static int alloc_audio_output_buf(AVCodecContext *dec, AVCodecContext *enc,
1133 int64_t audio_buf_samples;
1136 /* calculate required number of samples to allocate */
1137 audio_buf_samples = ((int64_t)nb_samples * enc->sample_rate + dec->sample_rate) /
1139 audio_buf_samples = 4 * audio_buf_samples + 10000; // safety factors for resampling
1140 audio_buf_samples = FFMAX(audio_buf_samples, enc->frame_size);
1141 if (audio_buf_samples > INT_MAX)
1142 return AVERROR(EINVAL);
1144 audio_buf_size = av_samples_get_buffer_size(NULL, enc->channels,
1146 enc->sample_fmt, 32);
1147 if (audio_buf_size < 0)
1148 return audio_buf_size;
1150 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
1152 return AVERROR(ENOMEM);
1157 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1158 InputStream *ist, AVFrame *decoded_frame)
1163 int frame_bytes, resample_changed;
1164 AVCodecContext *enc = ost->st->codec;
1165 AVCodecContext *dec = ist->st->codec;
1166 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1167 int isize = av_get_bytes_per_sample(dec->sample_fmt);
1168 uint8_t *buf[AV_NUM_DATA_POINTERS];
1169 int size = decoded_frame->nb_samples * dec->channels * isize;
1170 int planes = av_sample_fmt_is_planar(dec->sample_fmt) ? dec->channels : 1;
1173 av_assert0(planes <= AV_NUM_DATA_POINTERS);
1175 for(i=0; i<planes; i++)
1176 buf[i]= decoded_frame->data[i];
1178 if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples) < 0) {
1179 av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1183 if (enc->channels != dec->channels
1184 || enc->sample_fmt != dec->sample_fmt
1185 || enc->sample_rate!= dec->sample_rate
1187 ost->audio_resample = 1;
1189 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1190 ost->resample_channels != dec->channels ||
1191 ost->resample_sample_rate != dec->sample_rate;
1193 if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
1194 if (resample_changed) {
1195 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",
1196 ist->file_index, ist->st->index,
1197 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
1198 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
1199 ost->resample_sample_fmt = dec->sample_fmt;
1200 ost->resample_channels = dec->channels;
1201 ost->resample_sample_rate = dec->sample_rate;
1202 swr_free(&ost->swr);
1204 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1205 if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
1206 ost->resample_sample_fmt == enc->sample_fmt &&
1207 ost->resample_channels == enc->channels &&
1208 ost->resample_sample_rate == enc->sample_rate) {
1210 ost->audio_resample = 0;
1212 ost->swr = swr_alloc_set_opts(ost->swr,
1213 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
1214 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
1216 if (ost->audio_channels_mapped)
1217 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
1218 av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
1219 if (ost->audio_channels_mapped) {
1220 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
1221 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
1223 if (av_opt_set_int(ost->swr, "ich", dec->channels, 0) < 0) {
1224 av_log(NULL, AV_LOG_FATAL, "Unsupported number of input channels\n");
1227 if (av_opt_set_int(ost->swr, "och", enc->channels, 0) < 0) {
1228 av_log(NULL, AV_LOG_FATAL, "Unsupported number of output channels\n");
1231 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
1232 if(ost->swr && swr_init(ost->swr) < 0){
1233 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
1234 swr_free(&ost->swr);
1238 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1239 dec->channels, dec->sample_rate,
1240 enc->channels, enc->sample_rate);
1246 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1248 if (audio_sync_method > 0) {
1249 double delta = get_sync_ipts(ost, ist->pts) * enc->sample_rate - ost->sync_opts -
1250 av_fifo_size(ost->fifo) / (enc->channels * osize);
1251 int idelta = delta * dec->sample_rate / enc->sample_rate;
1252 int byte_delta = idelta * isize * dec->channels;
1254 // FIXME resample delay
1255 if (fabs(delta) > 50) {
1256 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1257 if (byte_delta < 0) {
1258 byte_delta = FFMAX(byte_delta, -size);
1260 for (i=0; i<planes; i++)
1261 buf[i] -= byte_delta/planes;
1262 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1263 -byte_delta / (isize * dec->channels));
1268 av_fast_malloc(&async_buf, &allocated_async_buf_size,
1271 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1275 if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples + idelta) < 0) {
1276 av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1281 for (i=0; i<planes; i++) {
1282 uint8_t *t = async_buf + i*((byte_delta + size)/planes);
1283 generate_silence(t, dec->sample_fmt, byte_delta/planes);
1284 memcpy(t + byte_delta/planes, buf[i], size/planes);
1288 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1290 } else if (audio_sync_method > 1) {
1291 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1292 av_assert0(ost->audio_resample);
1293 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1294 delta, comp, enc->sample_rate);
1295 // 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));
1296 swr_set_compensation(ost->swr, comp, enc->sample_rate);
1300 ost->sync_opts = lrintf(get_sync_ipts(ost, ist->pts) * enc->sample_rate) -
1301 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1303 if (ost->audio_resample || ost->audio_channels_mapped) {
1305 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, allocated_audio_buf_size / (enc->channels * osize),
1306 buf, size / (dec->channels * isize));
1308 av_log(NULL, AV_LOG_FATAL, "swr_convert failed\n");
1311 size_out = size_out * enc->channels * osize;
1317 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1319 /* now encode as many frames as possible */
1320 if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1321 /* output resampled raw samples */
1322 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1323 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1326 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1328 frame_bytes = enc->frame_size * osize * enc->channels;
1330 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1331 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1332 encode_audio_frame(s, ost, audio_buf, frame_bytes);
1335 encode_audio_frame(s, ost, buftmp, size_out);
1339 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1341 AVCodecContext *dec;
1342 AVPicture *picture2;
1343 AVPicture picture_tmp;
1346 dec = ist->st->codec;
1348 /* deinterlace : must be done before any resize */
1349 if (do_deinterlace) {
1352 /* create temporary picture */
1353 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1354 buf = av_malloc(size);
1358 picture2 = &picture_tmp;
1359 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1361 if (avpicture_deinterlace(picture2, picture,
1362 dec->pix_fmt, dec->width, dec->height) < 0) {
1363 /* if error, do not deinterlace */
1364 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1373 if (picture != picture2)
1374 *picture = *picture2;
1378 static void do_subtitle_out(AVFormatContext *s,
1384 static uint8_t *subtitle_out = NULL;
1385 int subtitle_out_max_size = 1024 * 1024;
1386 int subtitle_out_size, nb, i;
1387 AVCodecContext *enc;
1390 if (pts == AV_NOPTS_VALUE) {
1391 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1397 enc = ost->st->codec;
1399 if (!subtitle_out) {
1400 subtitle_out = av_malloc(subtitle_out_max_size);
1403 /* Note: DVB subtitle need one packet to draw them and one other
1404 packet to clear them */
1405 /* XXX: signal it in the codec context ? */
1406 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1411 for (i = 0; i < nb; i++) {
1412 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1414 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1415 // start_display_time is required to be 0
1416 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1417 sub->end_display_time -= sub->start_display_time;
1418 sub->start_display_time = 0;
1419 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1420 subtitle_out_max_size, sub);
1421 if (subtitle_out_size < 0) {
1422 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1426 av_init_packet(&pkt);
1427 pkt.data = subtitle_out;
1428 pkt.size = subtitle_out_size;
1429 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1430 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1431 /* XXX: the pts correction is handled here. Maybe handling
1432 it in the codec would be better */
1434 pkt.pts += 90 * sub->start_display_time;
1436 pkt.pts += 90 * sub->end_display_time;
1438 write_frame(s, &pkt, ost);
1442 static void do_video_resample(OutputStream *ost,
1444 AVFrame *in_picture,
1445 AVFrame **out_picture)
1448 *out_picture = in_picture;
1450 AVCodecContext *dec = ist->st->codec;
1451 AVCodecContext *enc = ost->st->codec;
1452 int resample_changed = ost->resample_width != in_picture->width ||
1453 ost->resample_height != in_picture->height ||
1454 ost->resample_pix_fmt != in_picture->format;
1456 *out_picture = in_picture;
1457 if (resample_changed) {
1458 av_log(NULL, AV_LOG_INFO,
1459 "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",
1460 ist->file_index, ist->st->index,
1461 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1462 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt),
1463 in_picture->width, in_picture->height, av_get_pix_fmt_name(in_picture->format));
1464 ost->resample_width = in_picture->width;
1465 ost->resample_height = in_picture->height;
1466 ost->resample_pix_fmt = in_picture->format;
1469 ost->video_resample = in_picture->width != enc->width ||
1470 in_picture->height != enc->height ||
1471 in_picture->format != enc->pix_fmt;
1473 if (ost->video_resample) {
1474 *out_picture = &ost->resample_frame;
1475 if (!ost->img_resample_ctx || resample_changed) {
1476 /* initialize the destination picture */
1477 if (!ost->resample_frame.data[0]) {
1478 avcodec_get_frame_defaults(&ost->resample_frame);
1479 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1480 enc->width, enc->height)) {
1481 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1485 /* initialize a new scaler context */
1486 sws_freeContext(ost->img_resample_ctx);
1487 ost->img_resample_ctx = sws_getContext(in_picture->width, in_picture->height, in_picture->format,
1488 enc->width, enc->height, enc->pix_fmt,
1489 ost->sws_flags, NULL, NULL, NULL);
1490 if (ost->img_resample_ctx == NULL) {
1491 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1495 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1496 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1501 static double psnr(double d)
1503 return -10.0 * log(d) / log(10.0);
1506 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1509 AVCodecContext *enc;
1511 double ti1, bitrate, avg_bitrate;
1513 /* this is executed just the first time do_video_stats is called */
1515 vstats_file = fopen(vstats_filename, "w");
1522 enc = ost->st->codec;
1523 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1524 frame_number = ost->frame_number;
1525 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1526 if (enc->flags&CODEC_FLAG_PSNR)
1527 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1529 fprintf(vstats_file,"f_size= %6d ", frame_size);
1530 /* compute pts value */
1531 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1535 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1536 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1537 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1538 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1539 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1544 static void do_video_out(AVFormatContext *s, OutputStream *ost,
1545 InputStream *ist, AVFrame *in_picture)
1547 int nb_frames, i, ret, format_video_sync;
1548 AVFrame *final_picture;
1549 AVCodecContext *enc;
1550 double sync_ipts, delta;
1551 double duration = 0;
1553 float quality = same_quant ? in_picture->quality
1554 : ost->st->codec->global_quality;
1556 enc = ost->st->codec;
1558 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1559 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1560 if(ist->st->r_frame_rate.num)
1561 duration= FFMAX(duration, 1/av_q2d(ist->st->r_frame_rate));
1562 if(ist->st->avg_frame_rate.num && 0)
1563 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1565 duration /= av_q2d(enc->time_base);
1568 sync_ipts = get_sync_ipts(ost, in_picture->pts) / av_q2d(enc->time_base);
1569 delta = sync_ipts - ost->sync_opts + duration;
1571 /* by default, we output a single frame */
1574 format_video_sync = video_sync_method;
1575 if (format_video_sync == VSYNC_AUTO)
1576 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1578 switch (format_video_sync) {
1580 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1583 else if (delta > 1.1)
1584 nb_frames = lrintf(delta);
1589 else if (delta > 0.6)
1590 ost->sync_opts = lrintf(sync_ipts);
1593 case VSYNC_PASSTHROUGH:
1594 ost->sync_opts = lrintf(sync_ipts);
1600 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1601 if (nb_frames == 0) {
1603 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1605 } else if (nb_frames > 1) {
1606 nb_frames_dup += nb_frames - 1;
1607 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1610 do_video_resample(ost, ist, in_picture, &final_picture);
1612 /* duplicates frame if needed */
1613 for (i = 0; i < nb_frames; i++) {
1615 av_init_packet(&pkt);
1619 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1620 enc->codec->id == CODEC_ID_RAWVIDEO) {
1621 /* raw pictures are written as AVPicture structure to
1622 avoid any copies. We support temporarily the older
1624 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1625 enc->coded_frame->top_field_first = in_picture->top_field_first;
1626 pkt.data = (uint8_t *)final_picture;
1627 pkt.size = sizeof(AVPicture);
1628 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1629 pkt.flags |= AV_PKT_FLAG_KEY;
1631 write_frame(s, &pkt, ost);
1634 AVFrame big_picture;
1636 big_picture = *final_picture;
1637 /* better than nothing: use input picture interlaced
1639 big_picture.interlaced_frame = in_picture->interlaced_frame;
1640 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1641 if (ost->top_field_first == -1)
1642 big_picture.top_field_first = in_picture->top_field_first;
1644 big_picture.top_field_first = !!ost->top_field_first;
1647 /* handles same_quant here. This is not correct because it may
1648 not be a global option */
1649 big_picture.quality = quality;
1650 if (!enc->me_threshold)
1651 big_picture.pict_type = 0;
1652 big_picture.pts = ost->sync_opts;
1653 if (ost->forced_kf_index < ost->forced_kf_count &&
1654 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1655 big_picture.pict_type = AV_PICTURE_TYPE_I;
1656 ost->forced_kf_index++;
1658 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
1660 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1665 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
1666 pkt.pts = ost->sync_opts;
1668 if (pkt.pts != AV_NOPTS_VALUE)
1669 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1670 if (pkt.dts != AV_NOPTS_VALUE)
1671 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1674 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1675 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1676 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1677 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1680 write_frame(s, &pkt, ost);
1681 frame_size = pkt.size;
1682 video_size += pkt.size;
1683 av_free_packet(&pkt);
1685 /* if two pass, output log */
1686 if (ost->logfile && enc->stats_out) {
1687 fprintf(ost->logfile, "%s", enc->stats_out);
1693 * For video, number of frames in == number of packets out.
1694 * But there may be reordering, so we can't throw away frames on encoder
1695 * flush, we need to limit them here, before they go into encoder.
1697 ost->frame_number++;
1699 if (vstats_filename && frame_size)
1700 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
1703 static void print_report(OutputFile *output_files,
1704 OutputStream *ost_table, int nb_ostreams,
1705 int is_last_report, int64_t timer_start, int64_t cur_time)
1709 AVFormatContext *oc;
1711 AVCodecContext *enc;
1712 int frame_number, vid, i;
1714 int64_t pts = INT64_MAX;
1715 static int64_t last_time = -1;
1716 static int qp_histogram[52];
1717 int hours, mins, secs, us;
1719 if (!print_stats && !is_last_report)
1722 if (!is_last_report) {
1723 if (last_time == -1) {
1724 last_time = cur_time;
1727 if ((cur_time - last_time) < 500000)
1729 last_time = cur_time;
1733 oc = output_files[0].ctx;
1735 total_size = avio_size(oc->pb);
1736 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
1737 total_size = avio_tell(oc->pb);
1744 for (i = 0; i < nb_ostreams; i++) {
1746 ost = &ost_table[i];
1747 enc = ost->st->codec;
1748 if (!ost->stream_copy && enc->coded_frame)
1749 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1750 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1751 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1753 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1754 float fps, t = (cur_time-timer_start) / 1000000.0;
1756 frame_number = ost->frame_number;
1757 fps = t > 1 ? frame_number / t : 0;
1758 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
1759 frame_number, fps < 9.95, fps, q);
1761 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1765 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1767 for (j = 0; j < 32; j++)
1768 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1770 if (enc->flags&CODEC_FLAG_PSNR) {
1772 double error, error_sum = 0;
1773 double scale, scale_sum = 0;
1774 char type[3] = { 'Y','U','V' };
1775 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1776 for (j = 0; j < 3; j++) {
1777 if (is_last_report) {
1778 error = enc->error[j];
1779 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1781 error = enc->coded_frame->error[j];
1782 scale = enc->width * enc->height * 255.0 * 255.0;
1788 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1790 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1794 /* compute min output value */
1795 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1796 ost->st->time_base, AV_TIME_BASE_Q));
1799 secs = pts / AV_TIME_BASE;
1800 us = pts % AV_TIME_BASE;
1806 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1808 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1809 "size=%8.0fkB time=", total_size / 1024.0);
1810 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1811 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1812 (100 * us) / AV_TIME_BASE);
1813 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1814 "bitrate=%6.1fkbits/s", bitrate);
1816 if (nb_frames_dup || nb_frames_drop)
1817 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1818 nb_frames_dup, nb_frames_drop);
1820 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1824 if (is_last_report) {
1825 int64_t raw= audio_size + video_size + extra_size;
1826 av_log(NULL, AV_LOG_INFO, "\n");
1827 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1828 video_size / 1024.0,
1829 audio_size / 1024.0,
1830 extra_size / 1024.0,
1831 100.0 * (total_size - raw) / raw
1833 if(video_size + audio_size + extra_size == 0){
1834 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1839 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1843 for (i = 0; i < nb_ostreams; i++) {
1844 OutputStream *ost = &ost_table[i];
1845 AVCodecContext *enc = ost->st->codec;
1846 AVFormatContext *os = output_files[ost->file_index].ctx;
1847 int stop_encoding = 0;
1849 if (!ost->encoding_needed)
1852 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1854 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1859 int fifo_bytes, got_packet;
1860 av_init_packet(&pkt);
1864 switch (ost->st->codec->codec_type) {
1865 case AVMEDIA_TYPE_AUDIO:
1866 fifo_bytes = av_fifo_size(ost->fifo);
1867 if (fifo_bytes > 0) {
1868 /* encode any samples remaining in fifo */
1869 int frame_bytes = fifo_bytes;
1871 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1873 /* pad last frame with silence if needed */
1874 if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
1875 frame_bytes = enc->frame_size * enc->channels *
1876 av_get_bytes_per_sample(enc->sample_fmt);
1877 if (allocated_audio_buf_size < frame_bytes)
1879 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1881 encode_audio_frame(os, ost, audio_buf, frame_bytes);
1883 /* flush encoder with NULL frames until it is done
1884 returning packets */
1885 if (encode_audio_frame(os, ost, NULL, 0) == 0) {
1891 case AVMEDIA_TYPE_VIDEO:
1892 ret = avcodec_encode_video2(enc, &pkt, NULL, &got_packet);
1894 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1897 video_size += pkt.size;
1898 if (ost->logfile && enc->stats_out) {
1899 fprintf(ost->logfile, "%s", enc->stats_out);
1905 if (pkt.pts != AV_NOPTS_VALUE)
1906 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1907 if (pkt.dts != AV_NOPTS_VALUE)
1908 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1909 write_frame(os, &pkt, ost);
1921 * Check whether a packet from ist should be written into ost at this time
1923 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1925 OutputFile *of = &output_files[ost->file_index];
1926 int ist_index = ist - input_streams;
1928 if (ost->source_index != ist_index)
1931 if (of->start_time && ist->pts < of->start_time)
1934 if (of->recording_time != INT64_MAX &&
1935 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1936 (AVRational){ 1, 1000000 }) >= 0) {
1937 ost->is_past_recording_time = 1;
1944 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1946 OutputFile *of = &output_files[ost->file_index];
1947 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1951 av_init_packet(&opkt);
1953 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1954 !ost->copy_initial_nonkeyframes)
1957 /* force the input stream PTS */
1958 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1959 audio_size += pkt->size;
1960 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1961 video_size += pkt->size;
1965 if (pkt->pts != AV_NOPTS_VALUE)
1966 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1968 opkt.pts = AV_NOPTS_VALUE;
1970 if (pkt->dts == AV_NOPTS_VALUE)
1971 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
1973 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1974 opkt.dts -= ost_tb_start_time;
1976 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1977 opkt.flags = pkt->flags;
1979 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1980 if ( ost->st->codec->codec_id != CODEC_ID_H264
1981 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1982 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1983 && ost->st->codec->codec_id != CODEC_ID_VC1
1985 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1986 opkt.destruct = av_destruct_packet;
1988 opkt.data = pkt->data;
1989 opkt.size = pkt->size;
1991 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
1992 /* store AVPicture in AVPacket, as expected by the output format */
1993 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1994 opkt.data = (uint8_t *)&pict;
1995 opkt.size = sizeof(AVPicture);
1996 opkt.flags |= AV_PKT_FLAG_KEY;
1999 write_frame(of->ctx, &opkt, ost);
2000 ost->st->codec->frame_number++;
2001 av_free_packet(&opkt);
2004 static void rate_emu_sleep(InputStream *ist)
2006 if (input_files[ist->file_index].rate_emu) {
2007 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2008 int64_t now = av_gettime() - ist->start;
2014 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2016 AVFrame *decoded_frame;
2017 AVCodecContext *avctx = ist->st->codec;
2018 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
2021 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2022 return AVERROR(ENOMEM);
2024 avcodec_get_frame_defaults(ist->decoded_frame);
2025 decoded_frame = ist->decoded_frame;
2027 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2031 if (avctx->sample_rate <= 0) {
2032 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2033 return AVERROR_INVALIDDATA;
2037 /* no audio frame */
2041 /* if the decoder provides a pts, use it instead of the last packet pts.
2042 the decoder could be delaying output by a packet or more. */
2043 if (decoded_frame->pts != AV_NOPTS_VALUE)
2044 ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2046 /* increment next_dts to use for the case where the input stream does not
2047 have timestamps or there are multiple frames in the packet */
2048 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2050 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2054 // preprocess audio (volume)
2055 if (audio_volume != 256) {
2056 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
2057 void *samples = decoded_frame->data[0];
2058 switch (avctx->sample_fmt) {
2059 case AV_SAMPLE_FMT_U8:
2061 uint8_t *volp = samples;
2062 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2063 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
2064 *volp++ = av_clip_uint8(v);
2068 case AV_SAMPLE_FMT_S16:
2070 int16_t *volp = samples;
2071 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2072 int v = ((*volp) * audio_volume + 128) >> 8;
2073 *volp++ = av_clip_int16(v);
2077 case AV_SAMPLE_FMT_S32:
2079 int32_t *volp = samples;
2080 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2081 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
2082 *volp++ = av_clipl_int32(v);
2086 case AV_SAMPLE_FMT_FLT:
2088 float *volp = samples;
2089 float scale = audio_volume / 256.f;
2090 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2095 case AV_SAMPLE_FMT_DBL:
2097 double *volp = samples;
2098 double scale = audio_volume / 256.;
2099 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2105 av_log(NULL, AV_LOG_FATAL,
2106 "Audio volume adjustment on sample format %s is not supported.\n",
2107 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
2112 rate_emu_sleep(ist);
2114 for (i = 0; i < nb_output_streams; i++) {
2115 OutputStream *ost = &output_streams[i];
2117 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2119 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
2125 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
2127 AVFrame *decoded_frame;
2128 void *buffer_to_free = NULL;
2130 int64_t *best_effort_timestamp;
2131 AVRational *frame_sample_aspect;
2133 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2134 return AVERROR(ENOMEM);
2136 avcodec_get_frame_defaults(ist->decoded_frame);
2137 decoded_frame = ist->decoded_frame;
2138 pkt->pts = *pkt_pts;
2139 pkt->dts = ist->dts;
2140 *pkt_pts = AV_NOPTS_VALUE;
2142 ret = avcodec_decode_video2(ist->st->codec,
2143 decoded_frame, got_output, pkt);
2148 /* no picture yet */
2152 best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
2153 if(*best_effort_timestamp != AV_NOPTS_VALUE)
2154 ist->next_pts = ist->pts = decoded_frame->pts = *best_effort_timestamp;
2158 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2161 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2162 for(i=0;i<nb_output_streams;i++) {
2163 OutputStream *ost = ost = &output_streams[i];
2164 if(check_output_constraints(ist, ost) && ost->encoding_needed){
2165 int changed = ist->st->codec->width != ost->input_video_filter->outputs[0]->w
2166 || ist->st->codec->height != ost->input_video_filter->outputs[0]->h
2167 || ist->st->codec->pix_fmt != ost->input_video_filter->outputs[0]->format;
2168 if (!frame_sample_aspect->num)
2169 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2170 decoded_frame->pts = ist->pts;
2171 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2172 FrameBuffer *buf = decoded_frame->opaque;
2173 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2174 decoded_frame->data, decoded_frame->linesize,
2175 AV_PERM_READ | AV_PERM_PRESERVE,
2176 ist->st->codec->width, ist->st->codec->height,
2177 ist->st->codec->pix_fmt);
2179 avfilter_copy_frame_props(fb, decoded_frame);
2180 fb->buf->priv = buf;
2181 fb->buf->free = filter_release_buffer;
2184 av_buffersrc_buffer(ost->input_video_filter, fb);
2186 if((av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE)) < 0){
2187 av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2194 rate_emu_sleep(ist);
2196 for (i = 0; i < nb_output_streams; i++) {
2197 OutputStream *ost = &output_streams[i];
2199 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2203 while (av_buffersink_poll_frame(ost->output_video_filter)) {
2204 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
2205 AVFrame *filtered_frame;
2207 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0){
2208 av_log(NULL, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");
2211 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2212 ret = AVERROR(ENOMEM);
2215 filtered_frame = ist->filtered_frame;
2216 *filtered_frame= *decoded_frame; //for me_threshold
2217 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
2218 filtered_frame->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2219 if (!ost->frame_aspect_ratio)
2220 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
2221 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame);
2223 avfilter_unref_buffer(ost->picref);
2226 do_video_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
2231 av_free(buffer_to_free);
2235 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2237 AVSubtitle subtitle;
2238 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2239 &subtitle, got_output, pkt);
2245 rate_emu_sleep(ist);
2247 for (i = 0; i < nb_output_streams; i++) {
2248 OutputStream *ost = &output_streams[i];
2250 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2253 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2256 avsubtitle_free(&subtitle);
2260 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2261 static int output_packet(InputStream *ist,
2262 OutputStream *ost_table, int nb_ostreams,
2263 const AVPacket *pkt)
2267 int64_t pkt_pts = AV_NOPTS_VALUE;
2271 if (ist->next_dts == AV_NOPTS_VALUE)
2272 ist->next_dts = ist->dts;
2273 if (ist->next_pts == AV_NOPTS_VALUE)
2274 ist->next_pts = ist->pts;
2278 av_init_packet(&avpkt);
2286 if (pkt->dts != AV_NOPTS_VALUE) {
2287 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2288 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2289 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2291 if(pkt->pts != AV_NOPTS_VALUE)
2292 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2294 // while we have more to decode or while the decoder did output something on EOF
2295 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2299 ist->pts = ist->next_pts;
2300 ist->dts = ist->next_dts;
2302 if (avpkt.size && avpkt.size != pkt->size) {
2303 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2304 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2305 ist->showed_multi_packet_warning = 1;
2308 switch (ist->st->codec->codec_type) {
2309 case AVMEDIA_TYPE_AUDIO:
2310 ret = transcode_audio (ist, &avpkt, &got_output);
2312 case AVMEDIA_TYPE_VIDEO:
2313 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
2314 if (avpkt.duration) {
2315 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2316 } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2317 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2318 duration = ((int64_t)AV_TIME_BASE *
2319 ist->st->codec->time_base.num * ticks) /
2320 ist->st->codec->time_base.den;
2324 if(ist->dts != AV_NOPTS_VALUE && duration) {
2325 ist->next_dts += duration;
2327 ist->next_dts = AV_NOPTS_VALUE;
2330 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2332 case AVMEDIA_TYPE_SUBTITLE:
2333 ret = transcode_subtitles(ist, &avpkt, &got_output);
2343 avpkt.pts= AV_NOPTS_VALUE;
2345 // touch data and size only if not EOF
2347 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2357 /* handle stream copy */
2358 if (!ist->decoding_needed) {
2359 rate_emu_sleep(ist);
2360 ist->dts = ist->next_dts;
2361 switch (ist->st->codec->codec_type) {
2362 case AVMEDIA_TYPE_AUDIO:
2363 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2364 ist->st->codec->sample_rate;
2366 case AVMEDIA_TYPE_VIDEO:
2367 if (pkt->duration) {
2368 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2369 } else if(ist->st->codec->time_base.num != 0) {
2370 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2371 ist->next_dts += ((int64_t)AV_TIME_BASE *
2372 ist->st->codec->time_base.num * ticks) /
2373 ist->st->codec->time_base.den;
2377 ist->pts = ist->dts;
2378 ist->next_pts = ist->next_dts;
2380 for (i = 0; pkt && i < nb_ostreams; i++) {
2381 OutputStream *ost = &ost_table[i];
2383 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2386 do_streamcopy(ist, ost, pkt);
2392 static void print_sdp(OutputFile *output_files, int n)
2396 AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2400 for (i = 0; i < n; i++)
2401 avc[i] = output_files[i].ctx;
2403 av_sdp_create(avc, n, sdp, sizeof(sdp));
2404 printf("SDP:\n%s\n", sdp);
2409 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2410 char *error, int error_len)
2412 InputStream *ist = &input_streams[ist_index];
2413 if (ist->decoding_needed) {
2414 AVCodec *codec = ist->dec;
2416 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2417 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2418 return AVERROR(EINVAL);
2421 ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
2422 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2423 ist->st->codec->get_buffer = codec_get_buffer;
2424 ist->st->codec->release_buffer = codec_release_buffer;
2425 ist->st->codec->opaque = ist;
2428 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2429 av_dict_set(&ist->opts, "threads", "auto", 0);
2430 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2431 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2432 ist->file_index, ist->st->index);
2433 return AVERROR(EINVAL);
2435 assert_codec_experimental(ist->st->codec, 0);
2436 assert_avoptions(ist->opts);
2439 ist->dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
2440 ist->next_pts = AV_NOPTS_VALUE;
2441 ist->next_dts = AV_NOPTS_VALUE;
2447 static int transcode_init(OutputFile *output_files, int nb_output_files,
2448 InputFile *input_files, int nb_input_files)
2450 int ret = 0, i, j, k;
2451 AVFormatContext *oc;
2452 AVCodecContext *codec, *icodec;
2458 /* init framerate emulation */
2459 for (i = 0; i < nb_input_files; i++) {
2460 InputFile *ifile = &input_files[i];
2461 if (ifile->rate_emu)
2462 for (j = 0; j < ifile->nb_streams; j++)
2463 input_streams[j + ifile->ist_index].start = av_gettime();
2466 /* output stream init */
2467 for (i = 0; i < nb_output_files; i++) {
2468 oc = output_files[i].ctx;
2469 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2470 av_dump_format(oc, i, oc->filename, 1);
2471 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2472 return AVERROR(EINVAL);
2476 /* for each output stream, we compute the right encoding parameters */
2477 for (i = 0; i < nb_output_streams; i++) {
2478 ost = &output_streams[i];
2479 oc = output_files[ost->file_index].ctx;
2480 ist = &input_streams[ost->source_index];
2482 if (ost->attachment_filename)
2485 codec = ost->st->codec;
2486 icodec = ist->st->codec;
2488 ost->st->disposition = ist->st->disposition;
2489 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2490 codec->chroma_sample_location = icodec->chroma_sample_location;
2492 if (ost->stream_copy) {
2493 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2495 if (extra_size > INT_MAX) {
2496 return AVERROR(EINVAL);
2499 /* if stream_copy is selected, no need to decode or encode */
2500 codec->codec_id = icodec->codec_id;
2501 codec->codec_type = icodec->codec_type;
2503 if (!codec->codec_tag) {
2504 if (!oc->oformat->codec_tag ||
2505 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2506 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2507 codec->codec_tag = icodec->codec_tag;
2510 codec->bit_rate = icodec->bit_rate;
2511 codec->rc_max_rate = icodec->rc_max_rate;
2512 codec->rc_buffer_size = icodec->rc_buffer_size;
2513 codec->field_order = icodec->field_order;
2514 codec->extradata = av_mallocz(extra_size);
2515 if (!codec->extradata) {
2516 return AVERROR(ENOMEM);
2518 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2519 codec->extradata_size= icodec->extradata_size;
2521 codec->time_base = ist->st->time_base;
2523 * Avi is a special case here because it supports variable fps but
2524 * having the fps and timebase differe significantly adds quite some
2527 if(!strcmp(oc->oformat->name, "avi")) {
2528 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2529 && av_q2d(ist->st->time_base) < 1.0/500
2531 codec->time_base = icodec->time_base;
2532 codec->time_base.num *= icodec->ticks_per_frame;
2533 codec->time_base.den *= 2;
2535 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2536 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2537 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2539 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2540 && av_q2d(ist->st->time_base) < 1.0/500
2542 codec->time_base = icodec->time_base;
2543 codec->time_base.num *= icodec->ticks_per_frame;
2546 av_reduce(&codec->time_base.num, &codec->time_base.den,
2547 codec->time_base.num, codec->time_base.den, INT_MAX);
2549 switch (codec->codec_type) {
2550 case AVMEDIA_TYPE_AUDIO:
2551 if (audio_volume != 256) {
2552 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2555 codec->channel_layout = icodec->channel_layout;
2556 codec->sample_rate = icodec->sample_rate;
2557 codec->channels = icodec->channels;
2558 codec->frame_size = icodec->frame_size;
2559 codec->audio_service_type = icodec->audio_service_type;
2560 codec->block_align = icodec->block_align;
2562 case AVMEDIA_TYPE_VIDEO:
2563 codec->pix_fmt = icodec->pix_fmt;
2564 codec->width = icodec->width;
2565 codec->height = icodec->height;
2566 codec->has_b_frames = icodec->has_b_frames;
2567 if (!codec->sample_aspect_ratio.num) {
2568 codec->sample_aspect_ratio =
2569 ost->st->sample_aspect_ratio =
2570 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2571 ist->st->codec->sample_aspect_ratio.num ?
2572 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2574 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2576 case AVMEDIA_TYPE_SUBTITLE:
2577 codec->width = icodec->width;
2578 codec->height = icodec->height;
2580 case AVMEDIA_TYPE_DATA:
2581 case AVMEDIA_TYPE_ATTACHMENT:
2588 ost->enc = avcodec_find_encoder(codec->codec_id);
2590 ist->decoding_needed = 1;
2591 ost->encoding_needed = 1;
2593 switch (codec->codec_type) {
2594 case AVMEDIA_TYPE_AUDIO:
2595 ost->fifo = av_fifo_alloc(1024);
2597 return AVERROR(ENOMEM);
2599 if (!codec->sample_rate)
2600 codec->sample_rate = icodec->sample_rate;
2601 choose_sample_rate(ost->st, ost->enc);
2602 codec->time_base = (AVRational){ 1, codec->sample_rate };
2604 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2605 codec->sample_fmt = icodec->sample_fmt;
2606 choose_sample_fmt(ost->st, ost->enc);
2608 if (ost->audio_channels_mapped) {
2609 /* the requested output channel is set to the number of
2610 * -map_channel only if no -ac are specified */
2611 if (!codec->channels) {
2612 codec->channels = ost->audio_channels_mapped;
2613 codec->channel_layout = av_get_default_channel_layout(codec->channels);
2614 if (!codec->channel_layout) {
2615 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2619 /* fill unused channel mapping with -1 (which means a muted
2620 * channel in case the number of output channels is bigger
2621 * than the number of mapped channel) */
2622 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2623 ost->audio_channels_map[j] = -1;
2624 } else if (!codec->channels) {
2625 codec->channels = icodec->channels;
2626 codec->channel_layout = icodec->channel_layout;
2628 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2629 codec->channel_layout = 0;
2631 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2632 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2633 || codec->channel_layout != icodec->channel_layout;
2634 icodec->request_channels = codec->channels;
2635 ost->resample_sample_fmt = icodec->sample_fmt;
2636 ost->resample_sample_rate = icodec->sample_rate;
2637 ost->resample_channels = icodec->channels;
2639 case AVMEDIA_TYPE_VIDEO:
2640 if (codec->pix_fmt == PIX_FMT_NONE)
2641 codec->pix_fmt = icodec->pix_fmt;
2642 choose_pixel_fmt(ost->st, ost->enc);
2644 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2645 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2649 if (!codec->width || !codec->height) {
2650 codec->width = icodec->width;
2651 codec->height = icodec->height;
2654 ost->video_resample = codec->width != icodec->width ||
2655 codec->height != icodec->height ||
2656 codec->pix_fmt != icodec->pix_fmt;
2657 if (ost->video_resample) {
2658 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
2661 ost->resample_height = icodec->height;
2662 ost->resample_width = icodec->width;
2663 ost->resample_pix_fmt = icodec->pix_fmt;
2665 if (!ost->frame_rate.num)
2666 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2667 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2668 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2669 ost->frame_rate = ost->enc->supported_framerates[idx];
2671 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2672 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
2673 && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2674 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
2675 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
2677 for (j = 0; j < ost->forced_kf_count; j++)
2678 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2683 if (configure_video_filters(ist, ost)) {
2684 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2689 case AVMEDIA_TYPE_SUBTITLE:
2690 codec->time_base = (AVRational){1, 1000};
2697 if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
2698 char logfilename[1024];
2701 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2702 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2704 if (!strcmp(ost->enc->name, "libx264")) {
2705 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
2707 if (codec->flags & CODEC_FLAG_PASS2) {
2709 size_t logbuffer_size;
2710 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2711 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2715 codec->stats_in = logbuffer;
2717 if (codec->flags & CODEC_FLAG_PASS1) {
2718 f = fopen(logfilename, "wb");
2720 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2721 logfilename, strerror(errno));
2731 /* open each encoder */
2732 for (i = 0; i < nb_output_streams; i++) {
2733 ost = &output_streams[i];
2734 if (ost->encoding_needed) {
2735 AVCodec *codec = ost->enc;
2736 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2738 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2739 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2740 ret = AVERROR(EINVAL);
2743 if (dec->subtitle_header) {
2744 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2745 if (!ost->st->codec->subtitle_header) {
2746 ret = AVERROR(ENOMEM);
2749 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2750 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2752 if (!av_dict_get(ost->opts, "threads", NULL, 0))
2753 av_dict_set(&ost->opts, "threads", "auto", 0);
2754 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2755 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2756 ost->file_index, ost->index);
2757 ret = AVERROR(EINVAL);
2760 assert_codec_experimental(ost->st->codec, 1);
2761 assert_avoptions(ost->opts);
2762 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2763 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2764 " It takes bits/s as argument, not kbits/s\n");
2765 extra_size += ost->st->codec->extradata_size;
2767 if (ost->st->codec->me_threshold)
2768 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2772 /* init input streams */
2773 for (i = 0; i < nb_input_streams; i++)
2774 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2777 /* discard unused programs */
2778 for (i = 0; i < nb_input_files; i++) {
2779 InputFile *ifile = &input_files[i];
2780 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2781 AVProgram *p = ifile->ctx->programs[j];
2782 int discard = AVDISCARD_ALL;
2784 for (k = 0; k < p->nb_stream_indexes; k++)
2785 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2786 discard = AVDISCARD_DEFAULT;
2789 p->discard = discard;
2793 /* open files and write file headers */
2794 for (i = 0; i < nb_output_files; i++) {
2795 oc = output_files[i].ctx;
2796 oc->interrupt_callback = int_cb;
2797 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2798 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2799 ret = AVERROR(EINVAL);
2802 // assert_avoptions(output_files[i].opts);
2803 if (strcmp(oc->oformat->name, "rtp")) {
2809 /* dump the file output parameters - cannot be done before in case
2811 for (i = 0; i < nb_output_files; i++) {
2812 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2815 /* dump the stream mapping */
2816 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2817 for (i = 0; i < nb_output_streams; i++) {
2818 ost = &output_streams[i];
2820 if (ost->attachment_filename) {
2821 /* an attached file */
2822 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2823 ost->attachment_filename, ost->file_index, ost->index);
2826 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2827 input_streams[ost->source_index].file_index,
2828 input_streams[ost->source_index].st->index,
2831 if (ost->audio_channels_mapped) {
2832 av_log(NULL, AV_LOG_INFO, " [ch:");
2833 for (j = 0; j < ost->audio_channels_mapped; j++)
2834 if (ost->audio_channels_map[j] == -1)
2835 av_log(NULL, AV_LOG_INFO, " M");
2837 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2838 av_log(NULL, AV_LOG_INFO, "]");
2840 if (ost->sync_ist != &input_streams[ost->source_index])
2841 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2842 ost->sync_ist->file_index,
2843 ost->sync_ist->st->index);
2844 if (ost->stream_copy)
2845 av_log(NULL, AV_LOG_INFO, " (copy)");
2847 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2848 input_streams[ost->source_index].dec->name : "?",
2849 ost->enc ? ost->enc->name : "?");
2850 av_log(NULL, AV_LOG_INFO, "\n");
2854 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2859 print_sdp(output_files, nb_output_files);
2866 * The following code is the main loop of the file converter
2868 static int transcode(OutputFile *output_files, int nb_output_files,
2869 InputFile *input_files, int nb_input_files)
2872 AVFormatContext *is, *os;
2876 int no_packet_count = 0;
2877 int64_t timer_start;
2880 if (!(no_packet = av_mallocz(nb_input_files)))
2883 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2888 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2891 timer_start = av_gettime();
2893 for (; received_sigterm == 0;) {
2894 int file_index, ist_index;
2898 int64_t cur_time= av_gettime();
2900 ipts_min = INT64_MAX;
2902 /* if 'q' pressed, exits */
2904 static int64_t last_time;
2905 if (received_nb_signals)
2907 /* read_key() returns 0 on EOF */
2908 if(cur_time - last_time >= 100000 && !run_as_daemon){
2910 last_time = cur_time;
2915 if (key == '+') av_log_set_level(av_log_get_level()+10);
2916 if (key == '-') av_log_set_level(av_log_get_level()-10);
2917 if (key == 's') qp_hist ^= 1;
2920 do_hex_dump = do_pkt_dump = 0;
2921 } else if(do_pkt_dump){
2925 av_log_set_level(AV_LOG_DEBUG);
2928 if (key == 'c' || key == 'C'){
2929 char buf[4096], target[64], command[256], arg[256] = {0};
2932 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2934 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2939 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2940 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2941 target, time, command, arg);
2942 for (i = 0; i < nb_output_streams; i++) {
2943 ost = &output_streams[i];
2946 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2947 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2948 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2950 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2955 av_log(NULL, AV_LOG_ERROR,
2956 "Parse error, at least 3 arguments were expected, "
2957 "only %d given in string '%s'\n", n, buf);
2961 if (key == 'd' || key == 'D'){
2964 debug = input_streams[0].st->codec->debug<<1;
2965 if(!debug) debug = 1;
2966 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2969 if(scanf("%d", &debug)!=1)
2970 fprintf(stderr,"error parsing debug value\n");
2971 for(i=0;i<nb_input_streams;i++) {
2972 input_streams[i].st->codec->debug = debug;
2974 for(i=0;i<nb_output_streams;i++) {
2975 ost = &output_streams[i];
2976 ost->st->codec->debug = debug;
2978 if(debug) av_log_set_level(AV_LOG_DEBUG);
2979 fprintf(stderr,"debug=%d\n", debug);
2982 fprintf(stderr, "key function\n"
2983 "? show this help\n"
2984 "+ increase verbosity\n"
2985 "- decrease verbosity\n"
2986 "c Send command to filtergraph\n"
2987 "D cycle through available debug modes\n"
2988 "h dump packets/hex press to cycle through the 3 states\n"
2990 "s Show QP histogram\n"
2995 /* select the stream that we must read now by looking at the
2996 smallest output pts */
2998 for (i = 0; i < nb_output_streams; i++) {
3002 ost = &output_streams[i];
3003 of = &output_files[ost->file_index];
3004 os = output_files[ost->file_index].ctx;
3005 ist = &input_streams[ost->source_index];
3006 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
3007 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3009 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
3011 if (!input_files[ist->file_index].eof_reached) {
3012 if (ipts < ipts_min) {
3015 file_index = ist->file_index;
3017 if (opts < opts_min) {
3019 if (!input_sync) file_index = ist->file_index;
3022 if (ost->frame_number >= ost->max_frames) {
3024 for (j = 0; j < of->ctx->nb_streams; j++)
3025 output_streams[of->ost_index + j].is_past_recording_time = 1;
3029 /* if none, if is finished */
3030 if (file_index < 0) {
3031 if (no_packet_count) {
3032 no_packet_count = 0;
3033 memset(no_packet, 0, nb_input_files);
3040 /* read a frame from it and output it in the fifo */
3041 is = input_files[file_index].ctx;
3042 ret = av_read_frame(is, &pkt);
3043 if (ret == AVERROR(EAGAIN)) {
3044 no_packet[file_index] = 1;
3049 input_files[file_index].eof_reached = 1;
3056 no_packet_count = 0;
3057 memset(no_packet, 0, nb_input_files);
3060 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3061 is->streams[pkt.stream_index]);
3063 /* the following test is needed in case new streams appear
3064 dynamically in stream : we ignore them */
3065 if (pkt.stream_index >= input_files[file_index].nb_streams)
3066 goto discard_packet;
3067 ist_index = input_files[file_index].ist_index + pkt.stream_index;
3068 ist = &input_streams[ist_index];
3070 goto discard_packet;
3072 if (pkt.dts != AV_NOPTS_VALUE)
3073 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3074 if (pkt.pts != AV_NOPTS_VALUE)
3075 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3077 if (pkt.pts != AV_NOPTS_VALUE)
3078 pkt.pts *= ist->ts_scale;
3079 if (pkt.dts != AV_NOPTS_VALUE)
3080 pkt.dts *= ist->ts_scale;
3083 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3084 "next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%"PRId64"\n",
3085 ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3086 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3087 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3088 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3089 input_files[ist->file_index].ts_offset);
3092 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3093 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3094 int64_t delta = pkt_dts - ist->next_dts;
3095 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3096 if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3097 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3098 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3099 pkt_dts+1<ist->pts){
3100 input_files[ist->file_index].ts_offset -= delta;
3101 av_log(NULL, AV_LOG_DEBUG,
3102 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3103 delta, input_files[ist->file_index].ts_offset);
3104 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3105 if (pkt.pts != AV_NOPTS_VALUE)
3106 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3109 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3110 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3111 pkt_dts+1<ist->pts){
3112 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3113 pkt.dts = AV_NOPTS_VALUE;
3115 if (pkt.pts != AV_NOPTS_VALUE){
3116 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3117 delta = pkt_pts - ist->next_dts;
3118 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3119 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3120 pkt_pts+1<ist->pts) {
3121 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3122 pkt.pts = AV_NOPTS_VALUE;
3128 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3129 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
3131 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3132 ist->file_index, ist->st->index);
3135 av_free_packet(&pkt);
3140 av_free_packet(&pkt);
3142 /* dump report by using the output first video and audio streams */
3143 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
3146 /* at the end of stream, we must flush the decoder buffers */
3147 for (i = 0; i < nb_input_streams; i++) {
3148 ist = &input_streams[i];
3149 if (ist->decoding_needed) {
3150 output_packet(ist, output_streams, nb_output_streams, NULL);
3153 flush_encoders(output_streams, nb_output_streams);
3157 /* write the trailer if needed and close file */
3158 for (i = 0; i < nb_output_files; i++) {
3159 os = output_files[i].ctx;
3160 av_write_trailer(os);
3163 /* dump report by using the first video and audio streams */
3164 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
3166 /* close each encoder */
3167 for (i = 0; i < nb_output_streams; i++) {
3168 ost = &output_streams[i];
3169 if (ost->encoding_needed) {
3170 av_freep(&ost->st->codec->stats_in);
3171 avcodec_close(ost->st->codec);
3174 avfilter_graph_free(&ost->graph);
3178 /* close each decoder */
3179 for (i = 0; i < nb_input_streams; i++) {
3180 ist = &input_streams[i];
3181 if (ist->decoding_needed) {
3182 avcodec_close(ist->st->codec);
3190 av_freep(&no_packet);
3192 if (output_streams) {
3193 for (i = 0; i < nb_output_streams; i++) {
3194 ost = &output_streams[i];
3196 if (ost->stream_copy)
3197 av_freep(&ost->st->codec->extradata);
3199 fclose(ost->logfile);
3200 ost->logfile = NULL;
3202 av_fifo_free(ost->fifo); /* works even if fifo is not
3203 initialized but set to zero */
3204 av_freep(&ost->st->codec->subtitle_header);
3205 av_free(ost->resample_frame.data[0]);
3206 av_free(ost->forced_kf_pts);
3207 if (ost->video_resample)
3208 sws_freeContext(ost->img_resample_ctx);
3209 swr_free(&ost->swr);
3210 av_dict_free(&ost->opts);
3217 static int opt_frame_crop(const char *opt, const char *arg)
3219 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3220 return AVERROR(EINVAL);
3223 static int opt_pad(const char *opt, const char *arg)
3225 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3229 static int opt_video_channel(const char *opt, const char *arg)
3231 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3232 return opt_default("channel", arg);
3235 static int opt_video_standard(const char *opt, const char *arg)
3237 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3238 return opt_default("standard", arg);
3241 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3243 audio_codec_name = arg;
3244 return parse_option(o, "codec:a", arg, options);
3247 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3249 video_codec_name = arg;
3250 return parse_option(o, "codec:v", arg, options);
3253 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3255 subtitle_codec_name = arg;
3256 return parse_option(o, "codec:s", arg, options);
3259 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3261 return parse_option(o, "codec:d", arg, options);
3264 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3266 StreamMap *m = NULL;
3267 int i, negative = 0, file_idx;
3268 int sync_file_idx = -1, sync_stream_idx = 0;
3276 map = av_strdup(arg);
3278 /* parse sync stream first, just pick first matching stream */
3279 if (sync = strchr(map, ',')) {
3281 sync_file_idx = strtol(sync + 1, &sync, 0);
3282 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3283 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3288 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
3289 if (check_stream_specifier(input_files[sync_file_idx].ctx,
3290 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
3291 sync_stream_idx = i;
3294 if (i == input_files[sync_file_idx].nb_streams) {
3295 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3296 "match any streams.\n", arg);
3302 file_idx = strtol(map, &p, 0);
3303 if (file_idx >= nb_input_files || file_idx < 0) {
3304 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3308 /* disable some already defined maps */
3309 for (i = 0; i < o->nb_stream_maps; i++) {
3310 m = &o->stream_maps[i];
3311 if (file_idx == m->file_index &&
3312 check_stream_specifier(input_files[m->file_index].ctx,
3313 input_files[m->file_index].ctx->streams[m->stream_index],
3314 *p == ':' ? p + 1 : p) > 0)
3318 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3319 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3320 *p == ':' ? p + 1 : p) <= 0)
3322 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3323 &o->nb_stream_maps, o->nb_stream_maps + 1);
3324 m = &o->stream_maps[o->nb_stream_maps - 1];
3326 m->file_index = file_idx;
3327 m->stream_index = i;
3329 if (sync_file_idx >= 0) {
3330 m->sync_file_index = sync_file_idx;
3331 m->sync_stream_index = sync_stream_idx;
3333 m->sync_file_index = file_idx;
3334 m->sync_stream_index = i;
3339 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3347 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3349 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3350 &o->nb_attachments, o->nb_attachments + 1);
3351 o->attachments[o->nb_attachments - 1] = arg;
3355 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3361 o->audio_channel_maps =
3362 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3363 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3364 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3366 /* muted channel syntax */
3367 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3368 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3369 m->file_idx = m->stream_idx = -1;
3371 m->ofile_idx = m->ostream_idx = -1;
3376 n = sscanf(arg, "%d.%d.%d:%d.%d",
3377 &m->file_idx, &m->stream_idx, &m->channel_idx,
3378 &m->ofile_idx, &m->ostream_idx);
3380 if (n != 3 && n != 5) {
3381 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3382 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3386 if (n != 5) // only file.stream.channel specified
3387 m->ofile_idx = m->ostream_idx = -1;
3390 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3391 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3395 if (m->stream_idx < 0 ||
3396 m->stream_idx >= input_files[m->file_idx].nb_streams) {
3397 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3398 m->file_idx, m->stream_idx);
3401 st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3402 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3403 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3404 m->file_idx, m->stream_idx);
3407 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3408 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3409 m->file_idx, m->stream_idx, m->channel_idx);
3416 * Parse a metadata specifier in arg.
3417 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3418 * @param index for type c/p, chapter/program index is written here
3419 * @param stream_spec for type s, the stream specifier is written here
3421 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3429 if (*(++arg) && *arg != ':') {
3430 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3433 *stream_spec = *arg == ':' ? arg + 1 : "";
3437 if (*(++arg) == ':')
3438 *index = strtol(++arg, NULL, 0);
3441 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3448 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3450 AVDictionary **meta_in = NULL;
3451 AVDictionary **meta_out = NULL;
3453 char type_in, type_out;
3454 const char *istream_spec = NULL, *ostream_spec = NULL;
3455 int idx_in = 0, idx_out = 0;
3457 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3458 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3461 if (type_out == 'g' || !*outspec)
3462 o->metadata_global_manual = 1;
3463 if (type_out == 's' || !*outspec)
3464 o->metadata_streams_manual = 1;
3465 if (type_out == 'c' || !*outspec)
3466 o->metadata_chapters_manual = 1;
3470 if (type_in == 'g' || type_out == 'g')
3471 o->metadata_global_manual = 1;
3472 if (type_in == 's' || type_out == 's')
3473 o->metadata_streams_manual = 1;
3474 if (type_in == 'c' || type_out == 'c')
3475 o->metadata_chapters_manual = 1;
3477 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3478 if ((index) < 0 || (index) >= (nb_elems)) {\
3479 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3484 #define SET_DICT(type, meta, context, index)\
3487 meta = &context->metadata;\
3490 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3491 meta = &context->chapters[index]->metadata;\
3494 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3495 meta = &context->programs[index]->metadata;\
3499 SET_DICT(type_in, meta_in, ic, idx_in);
3500 SET_DICT(type_out, meta_out, oc, idx_out);
3502 /* for input streams choose first matching stream */
3503 if (type_in == 's') {
3504 for (i = 0; i < ic->nb_streams; i++) {
3505 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3506 meta_in = &ic->streams[i]->metadata;
3512 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3517 if (type_out == 's') {
3518 for (i = 0; i < oc->nb_streams; i++) {
3519 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3520 meta_out = &oc->streams[i]->metadata;
3521 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3526 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3531 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3534 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3535 struct tm time = *gmtime((time_t*)&recording_timestamp);
3536 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3537 parse_option(o, "metadata", buf, options);
3539 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3540 "tag instead.\n", opt);
3544 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3546 const char *codec_string = encoder ? "encoder" : "decoder";
3550 avcodec_find_encoder_by_name(name) :
3551 avcodec_find_decoder_by_name(name);
3553 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3556 if (codec->type != type) {
3557 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3563 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3565 char *codec_name = NULL;
3567 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3569 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3570 st->codec->codec_id = codec->id;
3573 return avcodec_find_decoder(st->codec->codec_id);
3577 * Add all the streams from the given input file to the global
3578 * list of input streams.
3580 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3583 char *next, *codec_tag = NULL;
3585 for (i = 0; i < ic->nb_streams; i++) {
3586 AVStream *st = ic->streams[i];
3587 AVCodecContext *dec = st->codec;
3590 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3591 ist = &input_streams[nb_input_streams - 1];
3593 ist->file_index = nb_input_files;
3595 st->discard = AVDISCARD_ALL;
3596 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3598 ist->ts_scale = 1.0;
3599 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3601 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3603 uint32_t tag = strtol(codec_tag, &next, 0);
3605 tag = AV_RL32(codec_tag);
3606 st->codec->codec_tag = tag;
3609 ist->dec = choose_decoder(o, ic, st);
3611 switch (dec->codec_type) {
3612 case AVMEDIA_TYPE_VIDEO:
3614 ist->dec = avcodec_find_decoder(dec->codec_id);
3616 dec->flags |= CODEC_FLAG_EMU_EDGE;
3620 case AVMEDIA_TYPE_AUDIO:
3621 case AVMEDIA_TYPE_DATA:
3622 case AVMEDIA_TYPE_SUBTITLE:
3624 ist->dec = avcodec_find_decoder(dec->codec_id);
3626 case AVMEDIA_TYPE_ATTACHMENT:
3627 case AVMEDIA_TYPE_UNKNOWN:
3635 static void assert_file_overwrite(const char *filename)
3637 if ((!file_overwrite || no_file_overwrite) &&
3638 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3639 av_strstart(filename, "file:", NULL))) {
3640 if (avio_check(filename, 0) == 0) {
3641 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3642 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3645 signal(SIGINT, SIG_DFL);
3646 if (!read_yesno()) {
3647 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
3653 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3660 static void dump_attachment(AVStream *st, const char *filename)
3663 AVIOContext *out = NULL;
3664 AVDictionaryEntry *e;
3666 if (!st->codec->extradata_size) {
3667 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3668 nb_input_files - 1, st->index);
3671 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3672 filename = e->value;
3674 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3675 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3679 assert_file_overwrite(filename);
3681 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3682 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3687 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3692 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3694 AVFormatContext *ic;
3695 AVInputFormat *file_iformat = NULL;
3699 AVDictionary **opts;
3700 int orig_nb_streams; // number of streams before avformat_find_stream_info
3703 if (!(file_iformat = av_find_input_format(o->format))) {
3704 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3709 if (!strcmp(filename, "-"))
3712 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3713 !strcmp(filename, "/dev/stdin");
3715 /* get default parameters from command line */
3716 ic = avformat_alloc_context();
3718 print_error(filename, AVERROR(ENOMEM));
3721 if (o->nb_audio_sample_rate) {
3722 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3723 av_dict_set(&format_opts, "sample_rate", buf, 0);
3725 if (o->nb_audio_channels) {
3726 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3727 av_dict_set(&format_opts, "channels", buf, 0);
3729 if (o->nb_frame_rates) {
3730 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3732 if (o->nb_frame_sizes) {
3733 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3735 if (o->nb_frame_pix_fmts)
3736 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3738 ic->video_codec_id = video_codec_name ?
3739 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3740 ic->audio_codec_id = audio_codec_name ?
3741 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3742 ic->subtitle_codec_id= subtitle_codec_name ?
3743 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3744 ic->flags |= AVFMT_FLAG_NONBLOCK;
3745 ic->interrupt_callback = int_cb;
3747 /* open the input file with generic avformat function */
3748 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3750 print_error(filename, err);
3753 assert_avoptions(format_opts);
3755 /* apply forced codec ids */
3756 for (i = 0; i < ic->nb_streams; i++)
3757 choose_decoder(o, ic, ic->streams[i]);
3759 /* Set AVCodecContext options for avformat_find_stream_info */
3760 opts = setup_find_stream_info_opts(ic, codec_opts);
3761 orig_nb_streams = ic->nb_streams;
3763 /* If not enough info to get the stream parameters, we decode the
3764 first frames to get it. (used in mpeg case for example) */
3765 ret = avformat_find_stream_info(ic, opts);
3767 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3768 avformat_close_input(&ic);
3772 timestamp = o->start_time;
3773 /* add the stream start time */
3774 if (ic->start_time != AV_NOPTS_VALUE)
3775 timestamp += ic->start_time;
3777 /* if seeking requested, we execute it */
3778 if (o->start_time != 0) {
3779 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3781 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3782 filename, (double)timestamp / AV_TIME_BASE);
3786 /* update the current parameters so that they match the one of the input stream */
3787 add_input_streams(o, ic);
3789 /* dump the file content */
3790 av_dump_format(ic, nb_input_files, filename, 0);
3792 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3793 input_files[nb_input_files - 1].ctx = ic;
3794 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3795 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3796 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3797 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3799 for (i = 0; i < o->nb_dump_attachment; i++) {
3802 for (j = 0; j < ic->nb_streams; j++) {
3803 AVStream *st = ic->streams[j];
3805 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3806 dump_attachment(st, o->dump_attachment[i].u.str);
3810 for (i = 0; i < orig_nb_streams; i++)
3811 av_dict_free(&opts[i]);
3814 reset_options(o, 1);
3818 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3823 for (p = kf; *p; p++)
3826 ost->forced_kf_count = n;
3827 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3828 if (!ost->forced_kf_pts) {
3829 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3832 for (i = 0; i < n; i++) {
3833 p = i ? strchr(p, ',') + 1 : kf;
3834 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3838 static uint8_t *get_line(AVIOContext *s)
3844 if (avio_open_dyn_buf(&line) < 0) {
3845 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3849 while ((c = avio_r8(s)) && c != '\n')
3852 avio_close_dyn_buf(line, &buf);
3857 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3860 char filename[1000];
3861 const char *base[3] = { getenv("AVCONV_DATADIR"),
3866 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3870 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3871 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3872 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3875 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3876 i != 1 ? "" : "/.avconv", preset_name);
3877 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3883 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3885 char *codec_name = NULL;
3887 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3889 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3890 NULL, ost->st->codec->codec_type);
3891 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3892 } else if (!strcmp(codec_name, "copy"))
3893 ost->stream_copy = 1;
3895 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3896 ost->st->codec->codec_id = ost->enc->id;
3900 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
3903 AVStream *st = avformat_new_stream(oc, NULL);
3904 int idx = oc->nb_streams - 1, ret = 0;
3905 char *bsf = NULL, *next, *codec_tag = NULL;
3906 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3908 char *buf = NULL, *arg = NULL, *preset = NULL;
3909 AVIOContext *s = NULL;
3912 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3916 if (oc->nb_streams - 1 < o->nb_streamid_map)
3917 st->id = o->streamid_map[oc->nb_streams - 1];
3919 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3920 nb_output_streams + 1);
3921 ost = &output_streams[nb_output_streams - 1];
3922 ost->file_index = nb_output_files;
3925 st->codec->codec_type = type;
3926 choose_encoder(o, oc, ost);
3928 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3931 avcodec_get_context_defaults3(st->codec, ost->enc);
3932 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3934 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3935 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3938 if (!buf[0] || buf[0] == '#') {
3942 if (!(arg = strchr(buf, '='))) {
3943 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3947 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3949 } while (!s->eof_reached);
3953 av_log(NULL, AV_LOG_FATAL,
3954 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3955 preset, ost->file_index, ost->index);
3959 ost->max_frames = INT64_MAX;
3960 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3962 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3964 if (next = strchr(bsf, ','))
3966 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3967 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3971 bsfc_prev->next = bsfc;
3973 ost->bitstream_filters = bsfc;
3979 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3981 uint32_t tag = strtol(codec_tag, &next, 0);
3983 tag = AV_RL32(codec_tag);
3984 st->codec->codec_tag = tag;
3987 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
3988 if (qscale >= 0 || same_quant) {
3989 st->codec->flags |= CODEC_FLAG_QSCALE;
3990 st->codec->global_quality = FF_QP2LAMBDA * qscale;
3993 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
3994 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
3996 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
3998 ost->source_index = source_index;
3999 if (source_index >= 0) {
4000 ost->sync_ist = &input_streams[source_index];
4001 input_streams[source_index].discard = 0;
4002 input_streams[source_index].st->discard = AVDISCARD_NONE;
4008 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4011 const char *p = str;
4018 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4025 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4029 AVCodecContext *video_enc;
4031 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4033 video_enc = st->codec;
4035 if (!ost->stream_copy) {
4036 const char *p = NULL;
4037 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
4038 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4039 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
4042 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4043 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4044 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4048 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4049 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4050 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4054 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4055 if (frame_aspect_ratio) {
4057 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4058 q.num <= 0 || q.den <= 0) {
4059 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4062 ost->frame_aspect_ratio = av_q2d(q);
4065 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4066 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4067 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4068 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4071 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4074 video_enc->gop_size = 0;
4075 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4077 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4078 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4081 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4083 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4085 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4086 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4089 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4092 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4093 for (i = 0; p; i++) {
4095 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4097 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4100 /* FIXME realloc failure */
4101 video_enc->rc_override =
4102 av_realloc(video_enc->rc_override,
4103 sizeof(RcOverride) * (i + 1));
4104 video_enc->rc_override[i].start_frame = start;
4105 video_enc->rc_override[i].end_frame = end;
4107 video_enc->rc_override[i].qscale = q;
4108 video_enc->rc_override[i].quality_factor = 1.0;
4111 video_enc->rc_override[i].qscale = 0;
4112 video_enc->rc_override[i].quality_factor = -q/100.0;
4117 video_enc->rc_override_count = i;
4118 if (!video_enc->rc_initial_buffer_occupancy)
4119 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4120 video_enc->intra_dc_precision = intra_dc_precision - 8;
4123 video_enc->flags|= CODEC_FLAG_PSNR;
4128 video_enc->flags |= CODEC_FLAG_PASS1;
4131 video_enc->flags |= CODEC_FLAG_PASS2;
4135 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4136 if (forced_key_frames)
4137 parse_forced_key_frames(forced_key_frames, ost);
4139 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4141 ost->top_field_first = -1;
4142 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4145 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4147 ost->avfilter = av_strdup(filters);
4150 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4156 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4161 AVCodecContext *audio_enc;
4163 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4166 audio_enc = st->codec;
4167 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4169 if (!ost->stream_copy) {
4170 char *sample_fmt = NULL;
4172 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4174 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4176 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4177 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4181 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4183 ost->rematrix_volume=1.0;
4184 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4187 /* check for channel mapping for this audio stream */
4188 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4189 AudioChannelMap *map = &o->audio_channel_maps[n];
4190 InputStream *ist = &input_streams[ost->source_index];
4191 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4192 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4193 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4194 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4195 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4197 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4198 ost->file_index, ost->st->index);
4205 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4209 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4210 if (!ost->stream_copy) {
4211 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4218 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4220 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4221 ost->stream_copy = 1;
4225 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4229 AVCodecContext *subtitle_enc;
4231 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4233 subtitle_enc = st->codec;
4235 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4240 /* arg format is "output-stream-index:streamid-value". */
4241 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4247 av_strlcpy(idx_str, arg, sizeof(idx_str));
4248 p = strchr(idx_str, ':');
4250 av_log(NULL, AV_LOG_FATAL,
4251 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4256 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4257 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4258 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4262 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4264 AVFormatContext *is = ifile->ctx;
4265 AVFormatContext *os = ofile->ctx;
4268 for (i = 0; i < is->nb_chapters; i++) {
4269 AVChapter *in_ch = is->chapters[i], *out_ch;
4270 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4271 AV_TIME_BASE_Q, in_ch->time_base);
4272 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4273 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4276 if (in_ch->end < ts_off)
4278 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4281 out_ch = av_mallocz(sizeof(AVChapter));
4283 return AVERROR(ENOMEM);
4285 out_ch->id = in_ch->id;
4286 out_ch->time_base = in_ch->time_base;
4287 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4288 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4291 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4294 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4296 return AVERROR(ENOMEM);
4297 os->chapters[os->nb_chapters - 1] = out_ch;
4302 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4305 AVFormatContext *ic = avformat_alloc_context();
4307 ic->interrupt_callback = int_cb;
4308 err = avformat_open_input(&ic, filename, NULL, NULL);
4311 /* copy stream format */
4312 for(i=0;i<ic->nb_streams;i++) {
4316 AVCodecContext *avctx;
4318 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4319 ost = new_output_stream(o, s, codec->type, -1);
4324 // FIXME: a more elegant solution is needed
4325 memcpy(st, ic->streams[i], sizeof(AVStream));
4327 st->info = av_malloc(sizeof(*st->info));
4328 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4330 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4332 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4333 choose_sample_fmt(st, codec);
4334 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4335 choose_pixel_fmt(st, codec);
4338 avformat_close_input(&ic);
4342 static void opt_output_file(void *optctx, const char *filename)
4344 OptionsContext *o = optctx;
4345 AVFormatContext *oc;
4347 AVOutputFormat *file_oformat;
4351 if (!strcmp(filename, "-"))
4354 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4356 print_error(filename, err);
4359 file_oformat= oc->oformat;
4360 oc->interrupt_callback = int_cb;
4362 if (!strcmp(file_oformat->name, "ffm") &&
4363 av_strstart(filename, "http:", NULL)) {
4365 /* special case for files sent to ffserver: we get the stream
4366 parameters from ffserver */
4367 int err = read_ffserver_streams(o, oc, filename);
4369 print_error(filename, err);
4372 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4373 ost = &output_streams[j];
4374 for (i = 0; i < nb_input_streams; i++) {
4375 ist = &input_streams[i];
4376 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4378 ost->source_index= i;
4380 ist->st->discard = AVDISCARD_NONE;
4385 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));
4389 } else if (!o->nb_stream_maps) {
4390 /* pick the "best" stream of each type */
4392 /* video: highest resolution */
4393 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4394 int area = 0, idx = -1;
4395 for (i = 0; i < nb_input_streams; i++) {
4396 ist = &input_streams[i];
4397 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4398 ist->st->codec->width * ist->st->codec->height > area) {
4399 area = ist->st->codec->width * ist->st->codec->height;
4404 new_video_stream(o, oc, idx);
4407 /* audio: most channels */
4408 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4409 int channels = 0, idx = -1;
4410 for (i = 0; i < nb_input_streams; i++) {
4411 ist = &input_streams[i];
4412 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4413 ist->st->codec->channels > channels) {
4414 channels = ist->st->codec->channels;
4419 new_audio_stream(o, oc, idx);
4422 /* subtitles: pick first */
4423 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4424 for (i = 0; i < nb_input_streams; i++)
4425 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4426 new_subtitle_stream(o, oc, i);
4430 /* do something with data? */
4432 for (i = 0; i < o->nb_stream_maps; i++) {
4433 StreamMap *map = &o->stream_maps[i];
4434 int src_idx = input_files[map->file_index].ist_index + map->stream_index;
4439 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4440 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4442 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4444 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4446 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4449 switch (ist->st->codec->codec_type) {
4450 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, src_idx); break;
4451 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, src_idx); break;
4452 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc, src_idx); break;
4453 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc, src_idx); break;
4454 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
4456 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4457 map->file_index, map->stream_index);
4464 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
4465 AVDictionaryEntry *e;
4466 ost = &output_streams[i];
4468 if ( ost->stream_copy
4469 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
4470 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
4471 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
4475 /* handle attached files */
4476 for (i = 0; i < o->nb_attachments; i++) {
4478 uint8_t *attachment;
4482 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4483 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4487 if ((len = avio_size(pb)) <= 0) {
4488 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4492 if (!(attachment = av_malloc(len))) {
4493 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4497 avio_read(pb, attachment, len);
4499 ost = new_attachment_stream(o, oc, -1);
4500 ost->stream_copy = 0;
4501 ost->attachment_filename = o->attachments[i];
4502 ost->st->codec->extradata = attachment;
4503 ost->st->codec->extradata_size = len;
4505 p = strrchr(o->attachments[i], '/');
4506 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4510 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4511 output_files[nb_output_files - 1].ctx = oc;
4512 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4513 output_files[nb_output_files - 1].recording_time = o->recording_time;
4514 if (o->recording_time != INT64_MAX)
4515 oc->duration = o->recording_time;
4516 output_files[nb_output_files - 1].start_time = o->start_time;
4517 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4518 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4520 /* check filename in case of an image number is expected */
4521 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4522 if (!av_filename_number_test(oc->filename)) {
4523 print_error(oc->filename, AVERROR(EINVAL));
4528 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4529 /* test if it already exists to avoid losing precious files */
4530 assert_file_overwrite(filename);
4533 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4534 &oc->interrupt_callback,
4535 &output_files[nb_output_files - 1].opts)) < 0) {
4536 print_error(filename, err);
4541 if (o->mux_preload) {
4543 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4544 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4546 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4549 for (i = 0; i < o->nb_metadata_map; i++) {
4551 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4553 if (in_file_index >= nb_input_files) {
4554 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4557 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index].ctx : NULL, o);
4561 if (o->chapters_input_file >= nb_input_files) {
4562 if (o->chapters_input_file == INT_MAX) {
4563 /* copy chapters from the first input file that has them*/
4564 o->chapters_input_file = -1;
4565 for (i = 0; i < nb_input_files; i++)
4566 if (input_files[i].ctx->nb_chapters) {
4567 o->chapters_input_file = i;
4571 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4572 o->chapters_input_file);
4576 if (o->chapters_input_file >= 0)
4577 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4578 !o->metadata_chapters_manual);
4580 /* copy global metadata by default */
4581 if (!o->metadata_global_manual && nb_input_files){
4582 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4583 AV_DICT_DONT_OVERWRITE);
4584 if(o->recording_time != INT64_MAX)
4585 av_dict_set(&oc->metadata, "duration", NULL, 0);
4587 if (!o->metadata_streams_manual)
4588 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4590 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4592 ist = &input_streams[output_streams[i].source_index];
4593 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4596 /* process manually set metadata */
4597 for (i = 0; i < o->nb_metadata; i++) {
4600 const char *stream_spec;
4601 int index = 0, j, ret = 0;
4603 val = strchr(o->metadata[i].u.str, '=');
4605 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4606 o->metadata[i].u.str);
4611 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4613 for (j = 0; j < oc->nb_streams; j++) {
4614 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4615 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4619 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4627 if (index < 0 || index >= oc->nb_chapters) {
4628 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4631 m = &oc->chapters[index]->metadata;
4634 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4637 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4641 reset_options(o, 0);
4644 /* same option as mencoder */
4645 static int opt_pass(const char *opt, const char *arg)
4647 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4651 static int64_t getutime(void)
4654 struct rusage rusage;
4656 getrusage(RUSAGE_SELF, &rusage);
4657 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4658 #elif HAVE_GETPROCESSTIMES
4660 FILETIME c, e, k, u;
4661 proc = GetCurrentProcess();
4662 GetProcessTimes(proc, &c, &e, &k, &u);
4663 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4665 return av_gettime();
4669 static int64_t getmaxrss(void)
4671 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4672 struct rusage rusage;
4673 getrusage(RUSAGE_SELF, &rusage);
4674 return (int64_t)rusage.ru_maxrss * 1024;
4675 #elif HAVE_GETPROCESSMEMORYINFO
4677 PROCESS_MEMORY_COUNTERS memcounters;
4678 proc = GetCurrentProcess();
4679 memcounters.cb = sizeof(memcounters);
4680 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4681 return memcounters.PeakPagefileUsage;
4687 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4689 return parse_option(o, "q:a", arg, options);
4692 static void show_usage(void)
4694 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
4695 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4696 av_log(NULL, AV_LOG_INFO, "\n");
4699 static int opt_help(const char *opt, const char *arg)
4701 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4702 av_log_set_callback(log_callback_help);
4704 show_help_options(options, "Main options:\n",
4705 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4706 show_help_options(options, "\nAdvanced options:\n",
4707 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4709 show_help_options(options, "\nVideo options:\n",
4710 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4712 show_help_options(options, "\nAdvanced Video options:\n",
4713 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4714 OPT_VIDEO | OPT_EXPERT);
4715 show_help_options(options, "\nAudio options:\n",
4716 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4718 show_help_options(options, "\nAdvanced Audio options:\n",
4719 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4720 OPT_AUDIO | OPT_EXPERT);
4721 show_help_options(options, "\nSubtitle options:\n",
4722 OPT_SUBTITLE | OPT_GRAB,
4724 show_help_options(options, "\nAudio/Video grab options:\n",
4728 show_help_children(avcodec_get_class(), flags);
4729 show_help_children(avformat_get_class(), flags);
4730 show_help_children(sws_get_class(), flags);
4735 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4737 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4738 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4740 if (!strncmp(arg, "pal-", 4)) {
4743 } else if (!strncmp(arg, "ntsc-", 5)) {
4746 } else if (!strncmp(arg, "film-", 5)) {
4750 /* Try to determine PAL/NTSC by peeking in the input files */
4751 if (nb_input_files) {
4753 for (j = 0; j < nb_input_files; j++) {
4754 for (i = 0; i < input_files[j].nb_streams; i++) {
4755 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4756 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4758 fr = c->time_base.den * 1000 / c->time_base.num;
4762 } else if ((fr == 29970) || (fr == 23976)) {
4767 if (norm != UNKNOWN)
4771 if (norm != UNKNOWN)
4772 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4775 if (norm == UNKNOWN) {
4776 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4777 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4778 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4782 if (!strcmp(arg, "vcd")) {
4783 opt_video_codec(o, "c:v", "mpeg1video");
4784 opt_audio_codec(o, "c:a", "mp2");
4785 parse_option(o, "f", "vcd", options);
4787 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4788 parse_option(o, "r", frame_rates[norm], options);
4789 opt_default("g", norm == PAL ? "15" : "18");
4791 opt_default("b:v", "1150000");
4792 opt_default("maxrate", "1150000");
4793 opt_default("minrate", "1150000");
4794 opt_default("bufsize", "327680"); // 40*1024*8;
4796 opt_default("b:a", "224000");
4797 parse_option(o, "ar", "44100", options);
4798 parse_option(o, "ac", "2", options);
4800 opt_default("packetsize", "2324");
4801 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4803 /* We have to offset the PTS, so that it is consistent with the SCR.
4804 SCR starts at 36000, but the first two packs contain only padding
4805 and the first pack from the other stream, respectively, may also have
4806 been written before.
4807 So the real data starts at SCR 36000+3*1200. */
4808 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4809 } else if (!strcmp(arg, "svcd")) {
4811 opt_video_codec(o, "c:v", "mpeg2video");
4812 opt_audio_codec(o, "c:a", "mp2");
4813 parse_option(o, "f", "svcd", options);
4815 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4816 parse_option(o, "r", frame_rates[norm], options);
4817 parse_option(o, "pix_fmt", "yuv420p", options);
4818 opt_default("g", norm == PAL ? "15" : "18");
4820 opt_default("b:v", "2040000");
4821 opt_default("maxrate", "2516000");
4822 opt_default("minrate", "0"); // 1145000;
4823 opt_default("bufsize", "1835008"); // 224*1024*8;
4824 opt_default("scan_offset", "1");
4827 opt_default("b:a", "224000");
4828 parse_option(o, "ar", "44100", options);
4830 opt_default("packetsize", "2324");
4832 } else if (!strcmp(arg, "dvd")) {
4834 opt_video_codec(o, "c:v", "mpeg2video");
4835 opt_audio_codec(o, "c:a", "ac3");
4836 parse_option(o, "f", "dvd", options);
4838 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4839 parse_option(o, "r", frame_rates[norm], options);
4840 parse_option(o, "pix_fmt", "yuv420p", options);
4841 opt_default("g", norm == PAL ? "15" : "18");
4843 opt_default("b:v", "6000000");
4844 opt_default("maxrate", "9000000");
4845 opt_default("minrate", "0"); // 1500000;
4846 opt_default("bufsize", "1835008"); // 224*1024*8;
4848 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4849 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4851 opt_default("b:a", "448000");
4852 parse_option(o, "ar", "48000", options);
4854 } else if (!strncmp(arg, "dv", 2)) {
4856 parse_option(o, "f", "dv", options);
4858 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4859 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4860 norm == PAL ? "yuv420p" : "yuv411p", options);
4861 parse_option(o, "r", frame_rates[norm], options);
4863 parse_option(o, "ar", "48000", options);
4864 parse_option(o, "ac", "2", options);
4867 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4868 return AVERROR(EINVAL);
4873 static int opt_vstats_file(const char *opt, const char *arg)
4875 av_free (vstats_filename);
4876 vstats_filename = av_strdup (arg);
4880 static int opt_vstats(const char *opt, const char *arg)
4883 time_t today2 = time(NULL);
4884 struct tm *today = localtime(&today2);
4886 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4888 return opt_vstats_file(opt, filename);
4891 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4893 return parse_option(o, "frames:v", arg, options);
4896 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4898 return parse_option(o, "frames:a", arg, options);
4901 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4903 return parse_option(o, "frames:d", arg, options);
4906 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4909 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4910 const char *codec_name = *opt == 'v' ? video_codec_name :
4911 *opt == 'a' ? audio_codec_name :
4912 subtitle_codec_name;
4914 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4915 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4916 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4918 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4923 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4924 if(line[0] == '#' && !e)
4926 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4928 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4931 if(!strcmp(tmp, "acodec")){
4932 opt_audio_codec(o, tmp, tmp2);
4933 }else if(!strcmp(tmp, "vcodec")){
4934 opt_video_codec(o, tmp, tmp2);
4935 }else if(!strcmp(tmp, "scodec")){
4936 opt_subtitle_codec(o, tmp, tmp2);
4937 }else if(!strcmp(tmp, "dcodec")){
4938 opt_data_codec(o, tmp, tmp2);
4939 }else if(opt_default(tmp, tmp2) < 0){
4940 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4950 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4954 static int opt_passlogfile(const char *opt, const char *arg)
4956 pass_logfilename_prefix = arg;
4957 #if CONFIG_LIBX264_ENCODER
4958 return opt_default(opt, arg);
4964 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4966 char *s = av_asprintf("%s:%c", opt + 1, *opt);
4967 int ret = parse_option(o, s, arg, options);
4972 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4974 if(!strcmp(opt, "b")){
4975 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4976 return parse_option(o, "b:v", arg, options);
4978 return opt_default(opt, arg);
4981 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
4985 if(!strcmp(opt, "qscale")){
4986 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
4987 return parse_option(o, "q:v", arg, options);
4989 s = av_asprintf("q%s", opt + 6);
4990 ret = parse_option(o, s, arg, options);
4995 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
4997 if(!strcmp(opt, "profile")){
4998 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
4999 return parse_option(o, "profile:v", arg, options);
5001 return opt_default(opt, arg);
5004 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5006 return parse_option(o, "filter:v", arg, options);
5009 static int opt_vsync(const char *opt, const char *arg)
5011 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
5012 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
5013 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5014 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
5016 if (video_sync_method == VSYNC_AUTO)
5017 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5021 static int opt_deinterlace(const char *opt, const char *arg)
5023 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5028 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5030 int idx = locate_option(argc, argv, options, "cpuflags");
5031 if (idx && argv[idx + 1])
5032 opt_cpuflags("cpuflags", argv[idx + 1]);
5035 #define OFFSET(x) offsetof(OptionsContext, x)
5036 static const OptionDef options[] = {
5038 #include "cmdutils_common_opts.h"
5039 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5040 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5041 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5042 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5043 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5044 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5045 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5046 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5047 { "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]" },
5048 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5049 "outfile[,metadata]:infile[,metadata]" },
5050 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
5051 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5052 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5053 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5054 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5055 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5056 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5057 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5058 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5059 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5060 "add timings for benchmarking" },
5061 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5062 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5063 "dump each input packet" },
5064 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5065 "when dumping packets, also dump the payload" },
5066 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5067 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5068 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5069 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5070 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5071 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
5072 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
5073 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5074 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5075 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5076 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5077 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5078 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5079 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5080 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5081 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5082 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5084 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5086 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5087 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5088 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5089 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5092 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5093 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5094 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5095 { "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" },
5096 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5097 { "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" },
5098 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5099 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5100 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5101 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5102 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5103 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5104 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5105 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5106 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5107 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5108 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5109 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5110 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5111 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5112 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5113 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5114 "use same quantizer as source (implies VBR)" },
5115 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5116 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5117 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5118 "this option is deprecated, use the yadif filter instead" },
5119 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5120 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5121 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5123 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5125 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5126 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5127 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5128 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5129 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5130 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5131 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5132 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5133 { "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" },
5134 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5137 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5138 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5139 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5140 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5141 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5142 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5143 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5144 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5145 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5146 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
5148 /* subtitle options */
5149 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5150 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5151 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5154 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5155 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5156 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5159 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5160 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5162 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5163 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5164 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5166 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5167 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5168 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5169 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5170 /* data codec support */
5171 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5172 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5174 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5178 int main(int argc, char **argv)
5180 OptionsContext o = { 0 };
5183 reset_options(&o, 0);
5185 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5186 parse_loglevel(argc, argv, options);
5188 if(argc>1 && !strcmp(argv[1], "-d")){
5190 av_log_set_callback(log_callback_null);
5195 avcodec_register_all();
5197 avdevice_register_all();
5200 avfilter_register_all();
5203 avformat_network_init();
5205 show_banner(argc, argv, options);
5209 parse_cpuflags(argc, argv, options);
5212 parse_options(&o, argc, argv, options, opt_output_file);
5214 if (nb_output_files <= 0 && nb_input_files == 0) {
5216 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5220 /* file converter / grab */
5221 if (nb_output_files <= 0) {
5222 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5226 if (nb_input_files == 0) {
5227 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5232 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
5234 ti = getutime() - ti;
5236 int maxrss = getmaxrss() / 1024;
5237 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);