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
121 * select an input file for an output file
123 typedef struct MetadataMap {
124 int file; ///< file index
125 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
126 int index; ///< stream/chapter/program number
129 static const OptionDef options[];
131 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
133 static int frame_bits_per_raw_sample = 0;
134 static int video_discard = 0;
135 static int same_quant = 0;
136 static int do_deinterlace = 0;
137 static int intra_dc_precision = 8;
138 static int qp_hist = 0;
139 static int intra_only = 0;
140 static const char *video_codec_name = NULL;
141 static const char *audio_codec_name = NULL;
142 static const char *subtitle_codec_name = NULL;
144 static int file_overwrite = 0;
145 static int no_file_overwrite = 0;
146 static int do_benchmark = 0;
147 static int do_hex_dump = 0;
148 static int do_pkt_dump = 0;
149 static int do_psnr = 0;
150 static int do_pass = 0;
151 static const char *pass_logfilename_prefix;
152 static int video_sync_method = VSYNC_AUTO;
153 static int audio_sync_method = 0;
154 static float audio_drift_threshold = 0.1;
155 static int copy_ts = 0;
156 static int copy_tb = -1;
157 static int opt_shortest = 0;
158 static char *vstats_filename;
159 static FILE *vstats_file;
161 static int audio_volume = 256;
163 static int exit_on_error = 0;
164 static int using_stdin = 0;
165 static int run_as_daemon = 0;
166 static volatile int received_nb_signals = 0;
167 static int64_t video_size = 0;
168 static int64_t audio_size = 0;
169 static int64_t extra_size = 0;
170 static int nb_frames_dup = 0;
171 static int nb_frames_drop = 0;
172 static int input_sync;
174 static float dts_delta_threshold = 10;
175 static float dts_error_threshold = 3600*30;
177 static int print_stats = 1;
178 static int debug_ts = 0;
180 static uint8_t *audio_buf;
181 static unsigned int allocated_audio_buf_size;
182 static uint8_t *async_buf;
183 static unsigned int allocated_async_buf_size;
185 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
187 typedef struct FrameBuffer {
193 enum PixelFormat pix_fmt;
196 struct InputStream *ist;
197 struct FrameBuffer *next;
200 typedef struct InputStream {
203 int discard; /* true if stream data should be discarded */
204 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
206 AVFrame *decoded_frame;
207 AVFrame *filtered_frame;
209 int64_t start; /* time when read started */
210 /* predicted dts of the next packet read for this stream or (when there are
211 * several frames in a packet) of the next frame in current packet */
213 /* dts of the last packet read for this stream */
216 int64_t next_pts; ///< synthetic pts for the next decode frame
217 int64_t pts; ///< current pts of the decoded frame
219 int is_start; /* is 1 at the start and after a discontinuity */
220 int showed_multi_packet_warning;
223 /* a pool of free buffers for decoded data */
224 FrameBuffer *buffer_pool;
228 typedef struct InputFile {
229 AVFormatContext *ctx;
230 int eof_reached; /* true if eof reached */
231 int ist_index; /* index of first stream in input_streams */
232 int buffer_size; /* current total buffer size */
234 int nb_streams; /* number of stream that ffmpeg is aware of; may be different
235 from ctx.nb_streams if new streams appear during av_read_frame() */
239 typedef struct OutputStream {
240 int file_index; /* file index */
241 int index; /* stream index in the output file */
242 int source_index; /* InputStream index */
243 AVStream *st; /* stream in the output file */
244 int encoding_needed; /* true if encoding needed for this stream */
246 /* input pts and corresponding output pts
248 struct InputStream *sync_ist; /* input stream to sync against */
249 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ // FIXME look at frame_number
250 AVBitStreamFilterContext *bitstream_filters;
253 AVFrame *output_frame;
257 AVFrame resample_frame; /* temporary frame for image resampling */
258 struct SwsContext *img_resample_ctx; /* for image resampling */
261 int resample_pix_fmt;
262 AVRational frame_rate;
266 float frame_aspect_ratio;
268 /* forced key frames */
269 int64_t *forced_kf_pts;
275 int audio_channels_map[SWR_CH_MAX]; ///< list of the channels id to pick from the source stream
276 int audio_channels_mapped; ///< number of channels in audio_channels_map
277 int resample_sample_fmt;
278 int resample_channels;
279 int resample_sample_rate;
280 float rematrix_volume;
281 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
287 AVFilterContext *output_video_filter;
288 AVFilterContext *input_video_filter;
289 AVFilterBufferRef *picref;
291 AVFilterGraph *graph;
296 int is_past_recording_time;
298 const char *attachment_filename;
299 int copy_initial_nonkeyframes;
305 /* init terminal so that we can grab keys */
306 static struct termios oldtty;
307 static int restore_tty;
310 typedef struct OutputFile {
311 AVFormatContext *ctx;
313 int ost_index; /* index of the first stream in output_streams */
314 int64_t recording_time; /* desired length of the resulting file in microseconds */
315 int64_t start_time; /* start time in microseconds */
316 uint64_t limit_filesize; /* filesize limit expressed in bytes */
319 static InputStream *input_streams = NULL;
320 static int nb_input_streams = 0;
321 static InputFile *input_files = NULL;
322 static int nb_input_files = 0;
324 static OutputStream *output_streams = NULL;
325 static int nb_output_streams = 0;
326 static OutputFile *output_files = NULL;
327 static int nb_output_files = 0;
329 typedef struct OptionsContext {
330 /* input/output options */
334 SpecifierOpt *codec_names;
336 SpecifierOpt *audio_channels;
337 int nb_audio_channels;
338 SpecifierOpt *audio_sample_rate;
339 int nb_audio_sample_rate;
340 SpecifierOpt *rematrix_volume;
341 int nb_rematrix_volume;
342 SpecifierOpt *frame_rates;
344 SpecifierOpt *frame_sizes;
346 SpecifierOpt *frame_pix_fmts;
347 int nb_frame_pix_fmts;
350 int64_t input_ts_offset;
353 SpecifierOpt *ts_scale;
355 SpecifierOpt *dump_attachment;
356 int nb_dump_attachment;
359 StreamMap *stream_maps;
361 AudioChannelMap *audio_channel_maps; ///< one info entry per -map_channel
362 int nb_audio_channel_maps; ///< number of (valid) -map_channel settings
363 /* first item specifies output metadata, second is input */
364 MetadataMap (*meta_data_maps)[2];
365 int nb_meta_data_maps;
366 int metadata_global_manual;
367 int metadata_streams_manual;
368 int metadata_chapters_manual;
369 const char **attachments;
372 int chapters_input_file;
374 int64_t recording_time;
375 uint64_t limit_filesize;
381 int subtitle_disable;
384 /* indexed by output file stream index */
388 SpecifierOpt *metadata;
390 SpecifierOpt *max_frames;
392 SpecifierOpt *bitstream_filters;
393 int nb_bitstream_filters;
394 SpecifierOpt *codec_tags;
396 SpecifierOpt *sample_fmts;
398 SpecifierOpt *qscale;
400 SpecifierOpt *forced_key_frames;
401 int nb_forced_key_frames;
402 SpecifierOpt *force_fps;
404 SpecifierOpt *frame_aspect_ratios;
405 int nb_frame_aspect_ratios;
406 SpecifierOpt *rc_overrides;
408 SpecifierOpt *intra_matrices;
409 int nb_intra_matrices;
410 SpecifierOpt *inter_matrices;
411 int nb_inter_matrices;
412 SpecifierOpt *top_field_first;
413 int nb_top_field_first;
414 SpecifierOpt *metadata_map;
416 SpecifierOpt *presets;
418 SpecifierOpt *copy_initial_nonkeyframes;
419 int nb_copy_initial_nonkeyframes;
421 SpecifierOpt *filters;
426 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
429 for (i = 0; i < o->nb_ ## name; i++) {\
430 char *spec = o->name[i].specifier;\
431 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
432 outvar = o->name[i].u.type;\
438 static void reset_options(OptionsContext *o, int is_input)
440 const OptionDef *po = options;
441 OptionsContext bak= *o;
443 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
445 void *dst = (uint8_t*)o + po->u.off;
447 if (po->flags & OPT_SPEC) {
448 SpecifierOpt **so = dst;
449 int i, *count = (int*)(so + 1);
450 for (i = 0; i < *count; i++) {
451 av_freep(&(*so)[i].specifier);
452 if (po->flags & OPT_STRING)
453 av_freep(&(*so)[i].u.str);
457 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
462 av_freep(&o->stream_maps);
463 av_freep(&o->audio_channel_maps);
464 av_freep(&o->meta_data_maps);
465 av_freep(&o->streamid_map);
467 memset(o, 0, sizeof(*o));
469 if(is_input) o->recording_time = bak.recording_time;
470 else o->recording_time = INT64_MAX;
471 o->mux_max_delay = 0.7;
472 o->limit_filesize = UINT64_MAX;
473 o->chapters_input_file = INT_MAX;
479 static int alloc_buffer(InputStream *ist, AVCodecContext *s, FrameBuffer **pbuf)
481 FrameBuffer *buf = av_mallocz(sizeof(*buf));
483 const int pixel_size = av_pix_fmt_descriptors[s->pix_fmt].comp[0].step_minus1+1;
484 int h_chroma_shift, v_chroma_shift;
485 int edge = 32; // XXX should be avcodec_get_edge_width(), but that fails on svq1
486 int w = s->width, h = s->height;
489 return AVERROR(ENOMEM);
491 if (!(s->flags & CODEC_FLAG_EMU_EDGE)) {
496 avcodec_align_dimensions(s, &w, &h);
497 if ((ret = av_image_alloc(buf->base, buf->linesize, w, h,
498 s->pix_fmt, 32)) < 0) {
502 /* XXX this shouldn't be needed, but some tests break without this line
503 * those decoders are buggy and need to be fixed.
504 * the following tests fail:
505 * cdgraphics, ansi, aasc, fraps-v1, qtrle-1bit
507 memset(buf->base[0], 128, ret);
509 avcodec_get_chroma_sub_sample(s->pix_fmt, &h_chroma_shift, &v_chroma_shift);
510 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
511 const int h_shift = i==0 ? 0 : h_chroma_shift;
512 const int v_shift = i==0 ? 0 : v_chroma_shift;
513 if ((s->flags & CODEC_FLAG_EMU_EDGE) || !buf->linesize[1])
514 buf->data[i] = buf->base[i];
516 buf->data[i] = buf->base[i] +
517 FFALIGN((buf->linesize[i]*edge >> v_shift) +
518 (pixel_size*edge >> h_shift), 32);
522 buf->pix_fmt = s->pix_fmt;
529 static void free_buffer_pool(InputStream *ist)
531 FrameBuffer *buf = ist->buffer_pool;
533 ist->buffer_pool = buf->next;
534 av_freep(&buf->base[0]);
536 buf = ist->buffer_pool;
540 static void unref_buffer(InputStream *ist, FrameBuffer *buf)
542 av_assert0(buf->refcount);
544 if (!buf->refcount) {
545 buf->next = ist->buffer_pool;
546 ist->buffer_pool = buf;
550 static int codec_get_buffer(AVCodecContext *s, AVFrame *frame)
552 InputStream *ist = s->opaque;
556 if(av_image_check_size(s->width, s->height, 0, s) || s->pix_fmt<0)
559 if (!ist->buffer_pool && (ret = alloc_buffer(ist, s, &ist->buffer_pool)) < 0)
562 buf = ist->buffer_pool;
563 ist->buffer_pool = buf->next;
565 if (buf->w != s->width || buf->h != s->height || buf->pix_fmt != s->pix_fmt) {
566 av_freep(&buf->base[0]);
568 if ((ret = alloc_buffer(ist, s, &buf)) < 0)
574 frame->type = FF_BUFFER_TYPE_USER;
575 frame->extended_data = frame->data;
576 frame->pkt_pts = s->pkt ? s->pkt->pts : AV_NOPTS_VALUE;
577 frame->width = buf->w;
578 frame->height = buf->h;
579 frame->format = buf->pix_fmt;
580 frame->sample_aspect_ratio = s->sample_aspect_ratio;
582 for (i = 0; i < FF_ARRAY_ELEMS(buf->data); i++) {
583 frame->base[i] = buf->base[i]; // XXX h264.c uses base though it shouldn't
584 frame->data[i] = buf->data[i];
585 frame->linesize[i] = buf->linesize[i];
591 static void codec_release_buffer(AVCodecContext *s, AVFrame *frame)
593 InputStream *ist = s->opaque;
594 FrameBuffer *buf = frame->opaque;
597 if(frame->type!=FF_BUFFER_TYPE_USER)
598 return avcodec_default_release_buffer(s, frame);
600 for (i = 0; i < FF_ARRAY_ELEMS(frame->data); i++)
601 frame->data[i] = NULL;
603 unref_buffer(ist, buf);
606 static void filter_release_buffer(AVFilterBuffer *fb)
608 FrameBuffer *buf = fb->priv;
610 unref_buffer(buf->ist, buf);
615 static int configure_video_filters(InputStream *ist, OutputStream *ost)
617 AVFilterContext *last_filter, *filter;
618 /** filter graph containing all filters including input & output */
619 AVCodecContext *codec = ost->st->codec;
620 AVCodecContext *icodec = ist->st->codec;
621 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
622 AVBufferSinkParams *buffersink_params = av_buffersink_params_alloc();
623 AVRational sample_aspect_ratio;
627 ost->graph = avfilter_graph_alloc();
629 return AVERROR(ENOMEM);
631 if (ist->st->sample_aspect_ratio.num) {
632 sample_aspect_ratio = ist->st->sample_aspect_ratio;
634 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
636 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d:flags=%d", ist->st->codec->width,
637 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
638 sample_aspect_ratio.num, sample_aspect_ratio.den, SWS_BILINEAR + ((icodec->flags&CODEC_FLAG_BITEXACT) ? SWS_BITEXACT:0));
640 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
641 "src", args, NULL, ost->graph);
645 #if FF_API_OLD_VSINK_API
646 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
647 "out", NULL, pix_fmts, ost->graph);
649 buffersink_params->pixel_fmts = pix_fmts;
650 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
651 "out", NULL, buffersink_params, ost->graph);
653 av_freep(&buffersink_params);
657 last_filter = ost->input_video_filter;
659 if (codec->width != icodec->width || codec->height != icodec->height) {
660 snprintf(args, 255, "%d:%d:flags=0x%X",
663 (unsigned)ost->sws_flags);
664 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
665 NULL, args, NULL, ost->graph)) < 0)
667 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
669 last_filter = filter;
672 snprintf(args, sizeof(args), "flags=0x%X", (unsigned)ost->sws_flags);
673 ost->graph->scale_sws_opts = av_strdup(args);
676 AVFilterInOut *outputs = avfilter_inout_alloc();
677 AVFilterInOut *inputs = avfilter_inout_alloc();
679 outputs->name = av_strdup("in");
680 outputs->filter_ctx = last_filter;
681 outputs->pad_idx = 0;
682 outputs->next = NULL;
684 inputs->name = av_strdup("out");
685 inputs->filter_ctx = ost->output_video_filter;
689 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
691 av_freep(&ost->avfilter);
693 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
697 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
700 codec->width = ost->output_video_filter->inputs[0]->w;
701 codec->height = ost->output_video_filter->inputs[0]->h;
702 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
703 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
704 av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
705 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
709 #endif /* CONFIG_AVFILTER */
711 static void term_exit(void)
713 av_log(NULL, AV_LOG_QUIET, "%s", "");
716 tcsetattr (0, TCSANOW, &oldtty);
720 static volatile int received_sigterm = 0;
722 static void sigterm_handler(int sig)
724 received_sigterm = sig;
725 received_nb_signals++;
727 if(received_nb_signals > 3)
731 static void term_init(void)
737 if (tcgetattr (0, &tty) == 0) {
742 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
743 |INLCR|IGNCR|ICRNL|IXON);
744 tty.c_oflag |= OPOST;
745 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
746 tty.c_cflag &= ~(CSIZE|PARENB);
751 tcsetattr (0, TCSANOW, &tty);
753 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
756 avformat_network_deinit();
758 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
759 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
761 signal(SIGXCPU, sigterm_handler);
765 /* read a key without blocking */
766 static int read_key(void)
778 n = select(1, &rfds, NULL, NULL, &tv);
787 # if HAVE_PEEKNAMEDPIPE
789 static HANDLE input_handle;
792 input_handle = GetStdHandle(STD_INPUT_HANDLE);
793 is_pipe = !GetConsoleMode(input_handle, &dw);
796 if (stdin->_cnt > 0) {
801 /* When running under a GUI, you will end here. */
802 if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL))
819 static int decode_interrupt_cb(void *ctx)
821 return received_nb_signals > 1;
824 static const AVIOInterruptCB int_cb = { decode_interrupt_cb, NULL };
826 void av_noreturn exit_program(int ret)
831 for (i = 0; i < nb_output_files; i++) {
832 AVFormatContext *s = output_files[i].ctx;
833 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
835 avformat_free_context(s);
836 av_dict_free(&output_files[i].opts);
838 for (i = 0; i < nb_output_streams; i++) {
839 AVBitStreamFilterContext *bsfc = output_streams[i].bitstream_filters;
841 AVBitStreamFilterContext *next = bsfc->next;
842 av_bitstream_filter_close(bsfc);
845 output_streams[i].bitstream_filters = NULL;
847 if (output_streams[i].output_frame) {
848 AVFrame *frame = output_streams[i].output_frame;
849 if (frame->extended_data != frame->data)
850 av_freep(&frame->extended_data);
854 for (i = 0; i < nb_input_files; i++) {
855 avformat_close_input(&input_files[i].ctx);
857 for (i = 0; i < nb_input_streams; i++) {
858 av_freep(&input_streams[i].decoded_frame);
859 av_freep(&input_streams[i].filtered_frame);
860 av_dict_free(&input_streams[i].opts);
861 free_buffer_pool(&input_streams[i]);
866 av_free(vstats_filename);
868 av_freep(&input_streams);
869 av_freep(&input_files);
870 av_freep(&output_streams);
871 av_freep(&output_files);
874 av_freep(&audio_buf);
875 allocated_audio_buf_size = 0;
876 av_freep(&async_buf);
877 allocated_async_buf_size = 0;
882 avformat_network_deinit();
884 if (received_sigterm) {
885 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
886 (int) received_sigterm);
890 exit(ret); /* not all OS-es handle main() return value */
893 static void assert_avoptions(AVDictionary *m)
895 AVDictionaryEntry *t;
896 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
897 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
902 static void assert_codec_experimental(AVCodecContext *c, int encoder)
904 const char *codec_string = encoder ? "encoder" : "decoder";
906 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
907 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
908 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
909 "results.\nAdd '-strict experimental' if you want to use it.\n",
910 codec_string, c->codec->name);
911 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
912 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
913 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
914 codec_string, codec->name);
919 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
921 if (codec && codec->sample_fmts) {
922 const enum AVSampleFormat *p = codec->sample_fmts;
923 for (; *p != -1; p++) {
924 if (*p == st->codec->sample_fmt)
928 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
929 av_log(NULL, AV_LOG_ERROR, "Conversion will not be lossless.\n");
930 if(av_get_sample_fmt_name(st->codec->sample_fmt))
931 av_log(NULL, AV_LOG_WARNING,
932 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
933 av_get_sample_fmt_name(st->codec->sample_fmt),
935 av_get_sample_fmt_name(codec->sample_fmts[0]));
936 st->codec->sample_fmt = codec->sample_fmts[0];
941 static void choose_sample_rate(AVStream *st, AVCodec *codec)
943 if (codec && codec->supported_samplerates) {
944 const int *p = codec->supported_samplerates;
946 int best_dist = INT_MAX;
948 int dist = abs(st->codec->sample_rate - *p);
949 if (dist < best_dist) {
956 const int *sample_rates = codec->supported_samplerates;
957 av_log(st->codec, AV_LOG_WARNING,
958 "Requested sampling rate (%dHz) unsupported, using %dHz instead\n"
959 "Available sampling rates for %s:",
960 st->codec->sample_rate, best, codec->name);
961 for (i = 0; sample_rates[i]; i++) {
962 if (!sample_rates[i + 1]) av_log(st->codec, AV_LOG_WARNING, " and");
963 else if (i) av_log(st->codec, AV_LOG_WARNING, ",");
964 av_log(st->codec, AV_LOG_WARNING, " %d", sample_rates[i]);
966 av_log(st->codec, AV_LOG_WARNING, ".\n");
968 st->codec->sample_rate = best;
972 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
974 if (codec && codec->pix_fmts) {
975 const enum PixelFormat *p = codec->pix_fmts;
976 int has_alpha= av_pix_fmt_descriptors[st->codec->pix_fmt].nb_components % 2 == 0;
977 enum PixelFormat best= PIX_FMT_NONE;
978 if (st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL) {
979 if (st->codec->codec_id == CODEC_ID_MJPEG) {
980 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE };
981 } else if (st->codec->codec_id == CODEC_ID_LJPEG) {
982 p = (const enum PixelFormat[]) { PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P,
983 PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE };
986 for (; *p != PIX_FMT_NONE; p++) {
987 best= avcodec_find_best_pix_fmt2(best, *p, st->codec->pix_fmt, has_alpha, NULL);
988 if (*p == st->codec->pix_fmt)
991 if (*p == PIX_FMT_NONE) {
992 if (st->codec->pix_fmt != PIX_FMT_NONE)
993 av_log(NULL, AV_LOG_WARNING,
994 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
995 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
997 av_pix_fmt_descriptors[best].name);
998 st->codec->pix_fmt = best;
1004 get_sync_ipts(const OutputStream *ost, int64_t pts)
1006 OutputFile *of = &output_files[ost->file_index];
1007 return (double)(pts - of->start_time) / AV_TIME_BASE;
1010 static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
1012 AVBitStreamFilterContext *bsfc = ost->bitstream_filters;
1013 AVCodecContext *avctx = ost->st->codec;
1016 if ((avctx->codec_type == AVMEDIA_TYPE_VIDEO && video_sync_method == VSYNC_DROP) ||
1017 (avctx->codec_type == AVMEDIA_TYPE_AUDIO && audio_sync_method < 0))
1018 pkt->pts = pkt->dts = AV_NOPTS_VALUE;
1021 * Audio encoders may split the packets -- #frames in != #packets out.
1022 * But there is no reordering, so we can limit the number of output packets
1023 * by simply dropping them here.
1024 * Counting encoded video frames needs to be done separately because of
1025 * reordering, see do_video_out()
1027 if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
1028 if (ost->frame_number >= ost->max_frames) {
1029 av_free_packet(pkt);
1032 ost->frame_number++;
1036 AVPacket new_pkt = *pkt;
1037 int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
1038 &new_pkt.data, &new_pkt.size,
1039 pkt->data, pkt->size,
1040 pkt->flags & AV_PKT_FLAG_KEY);
1042 av_free_packet(pkt);
1043 new_pkt.destruct = av_destruct_packet;
1045 av_log(NULL, AV_LOG_ERROR, "Failed to open bitstream filter %s for stream %d with codec %s",
1046 bsfc->filter->name, pkt->stream_index,
1047 avctx->codec ? avctx->codec->name : "copy");
1057 pkt->stream_index = ost->index;
1058 ret = av_interleaved_write_frame(s, pkt);
1060 print_error("av_interleaved_write_frame()", ret);
1065 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1067 int fill_char = 0x00;
1068 if (sample_fmt == AV_SAMPLE_FMT_U8)
1070 memset(buf, fill_char, size);
1073 static int encode_audio_frame(AVFormatContext *s, OutputStream *ost,
1074 const uint8_t *buf, int buf_size)
1076 AVCodecContext *enc = ost->st->codec;
1077 AVFrame *frame = NULL;
1079 int ret, got_packet;
1081 av_init_packet(&pkt);
1085 if (buf && buf_size) {
1086 if (!ost->output_frame) {
1087 ost->output_frame = avcodec_alloc_frame();
1088 if (!ost->output_frame) {
1089 av_log(NULL, AV_LOG_FATAL, "out-of-memory in encode_audio_frame()\n");
1093 frame = ost->output_frame;
1094 if (frame->extended_data != frame->data)
1095 av_freep(&frame->extended_data);
1096 avcodec_get_frame_defaults(frame);
1098 frame->nb_samples = buf_size /
1099 (enc->channels * av_get_bytes_per_sample(enc->sample_fmt));
1100 if ((ret = avcodec_fill_audio_frame(frame, enc->channels, enc->sample_fmt,
1101 buf, buf_size, 1)) < 0) {
1102 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_fill_audio_frame)\n");
1106 frame->pts = ost->sync_opts;
1107 ost->sync_opts += frame->nb_samples;
1111 if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
1112 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed (avcodec_encode_audio2)\n");
1119 if (pkt.pts != AV_NOPTS_VALUE)
1120 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1121 if (pkt.dts != AV_NOPTS_VALUE)
1122 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1123 if (pkt.duration > 0)
1124 pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
1126 write_frame(s, &pkt, ost);
1128 audio_size += pkt.size;
1130 av_free_packet(&pkt);
1134 av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
1135 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1136 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1137 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1143 static int alloc_audio_output_buf(AVCodecContext *dec, AVCodecContext *enc,
1146 int64_t audio_buf_samples;
1149 /* calculate required number of samples to allocate */
1150 audio_buf_samples = ((int64_t)nb_samples * enc->sample_rate + dec->sample_rate) /
1152 audio_buf_samples = 4 * audio_buf_samples + 10000; // safety factors for resampling
1153 audio_buf_samples = FFMAX(audio_buf_samples, enc->frame_size);
1154 if (audio_buf_samples > INT_MAX)
1155 return AVERROR(EINVAL);
1157 audio_buf_size = av_samples_get_buffer_size(NULL, enc->channels,
1159 enc->sample_fmt, 32);
1160 if (audio_buf_size < 0)
1161 return audio_buf_size;
1163 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
1165 return AVERROR(ENOMEM);
1170 static void do_audio_out(AVFormatContext *s, OutputStream *ost,
1171 InputStream *ist, AVFrame *decoded_frame)
1176 int frame_bytes, resample_changed;
1177 AVCodecContext *enc = ost->st->codec;
1178 AVCodecContext *dec = ist->st->codec;
1179 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1180 int isize = av_get_bytes_per_sample(dec->sample_fmt);
1181 uint8_t *buf[AV_NUM_DATA_POINTERS];
1182 int size = decoded_frame->nb_samples * dec->channels * isize;
1183 int planes = av_sample_fmt_is_planar(dec->sample_fmt) ? dec->channels : 1;
1186 av_assert0(planes <= AV_NUM_DATA_POINTERS);
1188 for(i=0; i<planes; i++)
1189 buf[i]= decoded_frame->data[i];
1191 if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples) < 0) {
1192 av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1196 if (enc->channels != dec->channels
1197 || enc->sample_fmt != dec->sample_fmt
1198 || enc->sample_rate!= dec->sample_rate
1200 ost->audio_resample = 1;
1202 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
1203 ost->resample_channels != dec->channels ||
1204 ost->resample_sample_rate != dec->sample_rate;
1206 if ((ost->audio_resample && !ost->swr) || resample_changed || ost->audio_channels_mapped) {
1207 if (resample_changed) {
1208 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",
1209 ist->file_index, ist->st->index,
1210 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
1211 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
1212 ost->resample_sample_fmt = dec->sample_fmt;
1213 ost->resample_channels = dec->channels;
1214 ost->resample_sample_rate = dec->sample_rate;
1215 swr_free(&ost->swr);
1217 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
1218 if (audio_sync_method <= 1 && !ost->audio_channels_mapped &&
1219 ost->resample_sample_fmt == enc->sample_fmt &&
1220 ost->resample_channels == enc->channels &&
1221 ost->resample_sample_rate == enc->sample_rate) {
1223 ost->audio_resample = 0;
1225 ost->swr = swr_alloc_set_opts(ost->swr,
1226 enc->channel_layout, enc->sample_fmt, enc->sample_rate,
1227 dec->channel_layout, dec->sample_fmt, dec->sample_rate,
1229 if (ost->audio_channels_mapped)
1230 swr_set_channel_mapping(ost->swr, ost->audio_channels_map);
1231 av_opt_set_double(ost->swr, "rmvol", ost->rematrix_volume, 0);
1232 if (ost->audio_channels_mapped) {
1233 av_opt_set_int(ost->swr, "icl", av_get_default_channel_layout(ost->audio_channels_mapped), 0);
1234 av_opt_set_int(ost->swr, "uch", ost->audio_channels_mapped, 0);
1236 if (av_opt_set_int(ost->swr, "ich", dec->channels, 0) < 0) {
1237 av_log(NULL, AV_LOG_FATAL, "Unsupported number of input channels\n");
1240 if (av_opt_set_int(ost->swr, "och", enc->channels, 0) < 0) {
1241 av_log(NULL, AV_LOG_FATAL, "Unsupported number of output channels\n");
1244 if(audio_sync_method>1) av_opt_set_int(ost->swr, "flags", SWR_FLAG_RESAMPLE, 0);
1245 if(ost->swr && swr_init(ost->swr) < 0){
1246 av_log(NULL, AV_LOG_FATAL, "swr_init() failed\n");
1247 swr_free(&ost->swr);
1251 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
1252 dec->channels, dec->sample_rate,
1253 enc->channels, enc->sample_rate);
1259 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1261 if (audio_sync_method > 0) {
1262 double delta = get_sync_ipts(ost, ist->pts) * enc->sample_rate - ost->sync_opts -
1263 av_fifo_size(ost->fifo) / (enc->channels * osize);
1264 int idelta = delta * dec->sample_rate / enc->sample_rate;
1265 int byte_delta = idelta * isize * dec->channels;
1267 // FIXME resample delay
1268 if (fabs(delta) > 50) {
1269 if (ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate) {
1270 if (byte_delta < 0) {
1271 byte_delta = FFMAX(byte_delta, -size);
1273 for (i=0; i<planes; i++)
1274 buf[i] -= byte_delta/planes;
1275 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n",
1276 -byte_delta / (isize * dec->channels));
1281 av_fast_malloc(&async_buf, &allocated_async_buf_size,
1284 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
1288 if (alloc_audio_output_buf(dec, enc, decoded_frame->nb_samples + idelta) < 0) {
1289 av_log(NULL, AV_LOG_FATAL, "Error allocating audio buffer\n");
1294 for (i=0; i<planes; i++) {
1295 uint8_t *t = async_buf + i*((byte_delta + size)/planes);
1296 generate_silence(t, dec->sample_fmt, byte_delta/planes);
1297 memcpy(t + byte_delta/planes, buf[i], size/planes);
1301 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", idelta);
1303 } else if (audio_sync_method > 1) {
1304 int comp = av_clip(delta, -audio_sync_method, audio_sync_method);
1305 av_assert0(ost->audio_resample);
1306 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
1307 delta, comp, enc->sample_rate);
1308 // 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));
1309 swr_set_compensation(ost->swr, comp, enc->sample_rate);
1313 ost->sync_opts = lrintf(get_sync_ipts(ost, ist->pts) * enc->sample_rate) -
1314 av_fifo_size(ost->fifo) / (enc->channels * osize); // FIXME wrong
1316 if (ost->audio_resample || ost->audio_channels_mapped) {
1318 size_out = swr_convert(ost->swr, ( uint8_t*[]){buftmp}, allocated_audio_buf_size / (enc->channels * osize),
1319 buf, size / (dec->channels * isize));
1321 av_log(NULL, AV_LOG_FATAL, "swr_convert failed\n");
1324 size_out = size_out * enc->channels * osize;
1330 av_assert0(ost->audio_resample || dec->sample_fmt==enc->sample_fmt);
1332 /* now encode as many frames as possible */
1333 if (!(enc->codec->capabilities & CODEC_CAP_VARIABLE_FRAME_SIZE)) {
1334 /* output resampled raw samples */
1335 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
1336 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
1339 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
1341 frame_bytes = enc->frame_size * osize * enc->channels;
1343 while (av_fifo_size(ost->fifo) >= frame_bytes) {
1344 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
1345 encode_audio_frame(s, ost, audio_buf, frame_bytes);
1348 encode_audio_frame(s, ost, buftmp, size_out);
1352 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
1354 AVCodecContext *dec;
1355 AVPicture *picture2;
1356 AVPicture picture_tmp;
1359 dec = ist->st->codec;
1361 /* deinterlace : must be done before any resize */
1362 if (do_deinterlace) {
1365 /* create temporary picture */
1366 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
1367 buf = av_malloc(size);
1371 picture2 = &picture_tmp;
1372 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
1374 if (avpicture_deinterlace(picture2, picture,
1375 dec->pix_fmt, dec->width, dec->height) < 0) {
1376 /* if error, do not deinterlace */
1377 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
1386 if (picture != picture2)
1387 *picture = *picture2;
1391 static void do_subtitle_out(AVFormatContext *s,
1397 static uint8_t *subtitle_out = NULL;
1398 int subtitle_out_max_size = 1024 * 1024;
1399 int subtitle_out_size, nb, i;
1400 AVCodecContext *enc;
1403 if (pts == AV_NOPTS_VALUE) {
1404 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1410 enc = ost->st->codec;
1412 if (!subtitle_out) {
1413 subtitle_out = av_malloc(subtitle_out_max_size);
1416 /* Note: DVB subtitle need one packet to draw them and one other
1417 packet to clear them */
1418 /* XXX: signal it in the codec context ? */
1419 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1424 for (i = 0; i < nb; i++) {
1425 ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
1427 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1428 // start_display_time is required to be 0
1429 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1430 sub->end_display_time -= sub->start_display_time;
1431 sub->start_display_time = 0;
1432 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1433 subtitle_out_max_size, sub);
1434 if (subtitle_out_size < 0) {
1435 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1439 av_init_packet(&pkt);
1440 pkt.data = subtitle_out;
1441 pkt.size = subtitle_out_size;
1442 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1443 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1444 /* XXX: the pts correction is handled here. Maybe handling
1445 it in the codec would be better */
1447 pkt.pts += 90 * sub->start_display_time;
1449 pkt.pts += 90 * sub->end_display_time;
1451 write_frame(s, &pkt, ost);
1455 static void do_video_resample(OutputStream *ost,
1457 AVFrame *in_picture,
1458 AVFrame **out_picture)
1461 *out_picture = in_picture;
1463 AVCodecContext *dec = ist->st->codec;
1464 AVCodecContext *enc = ost->st->codec;
1465 int resample_changed = ost->resample_width != in_picture->width ||
1466 ost->resample_height != in_picture->height ||
1467 ost->resample_pix_fmt != in_picture->format;
1469 *out_picture = in_picture;
1470 if (resample_changed) {
1471 av_log(NULL, AV_LOG_INFO,
1472 "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",
1473 ist->file_index, ist->st->index,
1474 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1475 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt),
1476 in_picture->width, in_picture->height, av_get_pix_fmt_name(in_picture->format));
1477 ost->resample_width = in_picture->width;
1478 ost->resample_height = in_picture->height;
1479 ost->resample_pix_fmt = in_picture->format;
1482 ost->video_resample = in_picture->width != enc->width ||
1483 in_picture->height != enc->height ||
1484 in_picture->format != enc->pix_fmt;
1486 if (ost->video_resample) {
1487 *out_picture = &ost->resample_frame;
1488 if (!ost->img_resample_ctx || resample_changed) {
1489 /* initialize the destination picture */
1490 if (!ost->resample_frame.data[0]) {
1491 avcodec_get_frame_defaults(&ost->resample_frame);
1492 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1493 enc->width, enc->height)) {
1494 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
1498 /* initialize a new scaler context */
1499 sws_freeContext(ost->img_resample_ctx);
1500 ost->img_resample_ctx = sws_getContext(in_picture->width, in_picture->height, in_picture->format,
1501 enc->width, enc->height, enc->pix_fmt,
1502 ost->sws_flags, NULL, NULL, NULL);
1503 if (ost->img_resample_ctx == NULL) {
1504 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1508 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1509 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1514 static double psnr(double d)
1516 return -10.0 * log(d) / log(10.0);
1519 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1522 AVCodecContext *enc;
1524 double ti1, bitrate, avg_bitrate;
1526 /* this is executed just the first time do_video_stats is called */
1528 vstats_file = fopen(vstats_filename, "w");
1535 enc = ost->st->codec;
1536 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1537 frame_number = ost->frame_number;
1538 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
1539 if (enc->flags&CODEC_FLAG_PSNR)
1540 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1542 fprintf(vstats_file,"f_size= %6d ", frame_size);
1543 /* compute pts value */
1544 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1548 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1549 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1550 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1551 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1552 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1557 static void do_video_out(AVFormatContext *s, OutputStream *ost,
1558 InputStream *ist, AVFrame *in_picture)
1560 int nb_frames, i, ret, format_video_sync;
1561 AVFrame *final_picture;
1562 AVCodecContext *enc;
1563 double sync_ipts, delta;
1564 double duration = 0;
1566 float quality = same_quant ? in_picture->quality
1567 : ost->st->codec->global_quality;
1569 enc = ost->st->codec;
1571 if (ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE) {
1572 duration = FFMAX(av_q2d(ist->st->time_base), av_q2d(ist->st->codec->time_base));
1573 if(ist->st->r_frame_rate.num)
1574 duration= FFMAX(duration, 1/av_q2d(ist->st->r_frame_rate));
1575 if(ist->st->avg_frame_rate.num && 0)
1576 duration= FFMAX(duration, 1/av_q2d(ist->st->avg_frame_rate));
1578 duration /= av_q2d(enc->time_base);
1581 sync_ipts = get_sync_ipts(ost, in_picture->pts) / av_q2d(enc->time_base);
1582 delta = sync_ipts - ost->sync_opts + duration;
1584 /* by default, we output a single frame */
1587 format_video_sync = video_sync_method;
1588 if (format_video_sync == VSYNC_AUTO)
1589 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? ((s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : 1;
1591 switch (format_video_sync) {
1593 // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1596 else if (delta > 1.1)
1597 nb_frames = lrintf(delta);
1602 else if (delta > 0.6)
1603 ost->sync_opts = lrintf(sync_ipts);
1606 case VSYNC_PASSTHROUGH:
1607 ost->sync_opts = lrintf(sync_ipts);
1613 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1614 if (nb_frames == 0) {
1616 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1618 } else if (nb_frames > 1) {
1619 nb_frames_dup += nb_frames - 1;
1620 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1623 do_video_resample(ost, ist, in_picture, &final_picture);
1625 /* duplicates frame if needed */
1626 for (i = 0; i < nb_frames; i++) {
1628 av_init_packet(&pkt);
1632 if (s->oformat->flags & AVFMT_RAWPICTURE &&
1633 enc->codec->id == CODEC_ID_RAWVIDEO) {
1634 /* raw pictures are written as AVPicture structure to
1635 avoid any copies. We support temporarily the older
1637 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1638 enc->coded_frame->top_field_first = in_picture->top_field_first;
1639 pkt.data = (uint8_t *)final_picture;
1640 pkt.size = sizeof(AVPicture);
1641 pkt.pts = av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1642 pkt.flags |= AV_PKT_FLAG_KEY;
1644 write_frame(s, &pkt, ost);
1647 AVFrame big_picture;
1649 big_picture = *final_picture;
1650 /* better than nothing: use input picture interlaced
1652 big_picture.interlaced_frame = in_picture->interlaced_frame;
1653 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1654 if (ost->top_field_first == -1)
1655 big_picture.top_field_first = in_picture->top_field_first;
1657 big_picture.top_field_first = !!ost->top_field_first;
1660 /* handles same_quant here. This is not correct because it may
1661 not be a global option */
1662 big_picture.quality = quality;
1663 if (!enc->me_threshold)
1664 big_picture.pict_type = 0;
1665 big_picture.pts = ost->sync_opts;
1666 if (ost->forced_kf_index < ost->forced_kf_count &&
1667 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1668 big_picture.pict_type = AV_PICTURE_TYPE_I;
1669 ost->forced_kf_index++;
1671 ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
1673 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1678 if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & CODEC_CAP_DELAY))
1679 pkt.pts = ost->sync_opts;
1681 if (pkt.pts != AV_NOPTS_VALUE)
1682 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1683 if (pkt.dts != AV_NOPTS_VALUE)
1684 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1687 av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1688 "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1689 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->st->time_base),
1690 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->st->time_base));
1693 write_frame(s, &pkt, ost);
1694 frame_size = pkt.size;
1695 video_size += pkt.size;
1696 av_free_packet(&pkt);
1698 /* if two pass, output log */
1699 if (ost->logfile && enc->stats_out) {
1700 fprintf(ost->logfile, "%s", enc->stats_out);
1706 * For video, number of frames in == number of packets out.
1707 * But there may be reordering, so we can't throw away frames on encoder
1708 * flush, we need to limit them here, before they go into encoder.
1710 ost->frame_number++;
1712 if (vstats_filename && frame_size)
1713 do_video_stats(output_files[ost->file_index].ctx, ost, frame_size);
1716 static void print_report(OutputFile *output_files,
1717 OutputStream *ost_table, int nb_ostreams,
1718 int is_last_report, int64_t timer_start, int64_t cur_time)
1722 AVFormatContext *oc;
1724 AVCodecContext *enc;
1725 int frame_number, vid, i;
1727 int64_t pts = INT64_MAX;
1728 static int64_t last_time = -1;
1729 static int qp_histogram[52];
1730 int hours, mins, secs, us;
1732 if (!print_stats && !is_last_report)
1735 if (!is_last_report) {
1736 if (last_time == -1) {
1737 last_time = cur_time;
1740 if ((cur_time - last_time) < 500000)
1742 last_time = cur_time;
1746 oc = output_files[0].ctx;
1748 total_size = avio_size(oc->pb);
1749 if (total_size < 0) { // FIXME improve avio_size() so it works with non seekable output too
1750 total_size = avio_tell(oc->pb);
1757 for (i = 0; i < nb_ostreams; i++) {
1759 ost = &ost_table[i];
1760 enc = ost->st->codec;
1761 if (!ost->stream_copy && enc->coded_frame)
1762 q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
1763 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1764 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1766 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1767 float fps, t = (cur_time-timer_start) / 1000000.0;
1769 frame_number = ost->frame_number;
1770 fps = t > 1 ? frame_number / t : 0;
1771 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3.*f q=%3.1f ",
1772 frame_number, fps < 9.95, fps, q);
1774 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1778 if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1780 for (j = 0; j < 32; j++)
1781 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j] + 1) / log(2)));
1783 if (enc->flags&CODEC_FLAG_PSNR) {
1785 double error, error_sum = 0;
1786 double scale, scale_sum = 0;
1787 char type[3] = { 'Y','U','V' };
1788 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1789 for (j = 0; j < 3; j++) {
1790 if (is_last_report) {
1791 error = enc->error[j];
1792 scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1794 error = enc->coded_frame->error[j];
1795 scale = enc->width * enc->height * 255.0 * 255.0;
1801 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
1803 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
1807 /* compute min output value */
1808 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1809 ost->st->time_base, AV_TIME_BASE_Q));
1812 secs = pts / AV_TIME_BASE;
1813 us = pts % AV_TIME_BASE;
1819 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1821 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1822 "size=%8.0fkB time=", total_size / 1024.0);
1823 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1824 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1825 (100 * us) / AV_TIME_BASE);
1826 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1827 "bitrate=%6.1fkbits/s", bitrate);
1829 if (nb_frames_dup || nb_frames_drop)
1830 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1831 nb_frames_dup, nb_frames_drop);
1833 av_log(NULL, AV_LOG_INFO, "%s \r", buf);
1837 if (is_last_report) {
1838 int64_t raw= audio_size + video_size + extra_size;
1839 av_log(NULL, AV_LOG_INFO, "\n");
1840 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1841 video_size / 1024.0,
1842 audio_size / 1024.0,
1843 extra_size / 1024.0,
1844 100.0 * (total_size - raw) / raw
1846 if(video_size + audio_size + extra_size == 0){
1847 av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded (check -ss / -t / -frames parameters if used)\n");
1852 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1856 for (i = 0; i < nb_ostreams; i++) {
1857 OutputStream *ost = &ost_table[i];
1858 AVCodecContext *enc = ost->st->codec;
1859 AVFormatContext *os = output_files[ost->file_index].ctx;
1860 int stop_encoding = 0;
1862 if (!ost->encoding_needed)
1865 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1867 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE) && enc->codec->id == CODEC_ID_RAWVIDEO)
1872 int fifo_bytes, got_packet;
1873 av_init_packet(&pkt);
1877 switch (ost->st->codec->codec_type) {
1878 case AVMEDIA_TYPE_AUDIO:
1879 fifo_bytes = av_fifo_size(ost->fifo);
1880 if (fifo_bytes > 0) {
1881 /* encode any samples remaining in fifo */
1882 int frame_bytes = fifo_bytes;
1884 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1886 /* pad last frame with silence if needed */
1887 if (!(enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME)) {
1888 frame_bytes = enc->frame_size * enc->channels *
1889 av_get_bytes_per_sample(enc->sample_fmt);
1890 if (allocated_audio_buf_size < frame_bytes)
1892 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1894 encode_audio_frame(os, ost, audio_buf, frame_bytes);
1896 /* flush encoder with NULL frames until it is done
1897 returning packets */
1898 if (encode_audio_frame(os, ost, NULL, 0) == 0) {
1904 case AVMEDIA_TYPE_VIDEO:
1905 ret = avcodec_encode_video2(enc, &pkt, NULL, &got_packet);
1907 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1910 video_size += pkt.size;
1911 if (ost->logfile && enc->stats_out) {
1912 fprintf(ost->logfile, "%s", enc->stats_out);
1918 if (pkt.pts != AV_NOPTS_VALUE)
1919 pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
1920 if (pkt.dts != AV_NOPTS_VALUE)
1921 pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
1922 write_frame(os, &pkt, ost);
1934 * Check whether a packet from ist should be written into ost at this time
1936 static int check_output_constraints(InputStream *ist, OutputStream *ost)
1938 OutputFile *of = &output_files[ost->file_index];
1939 int ist_index = ist - input_streams;
1941 if (ost->source_index != ist_index)
1944 if (of->start_time && ist->pts < of->start_time)
1947 if (of->recording_time != INT64_MAX &&
1948 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1949 (AVRational){ 1, 1000000 }) >= 0) {
1950 ost->is_past_recording_time = 1;
1957 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1959 OutputFile *of = &output_files[ost->file_index];
1960 int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1964 av_init_packet(&opkt);
1966 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1967 !ost->copy_initial_nonkeyframes)
1970 /* force the input stream PTS */
1971 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1972 audio_size += pkt->size;
1973 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1974 video_size += pkt->size;
1978 if (pkt->pts != AV_NOPTS_VALUE)
1979 opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1981 opkt.pts = AV_NOPTS_VALUE;
1983 if (pkt->dts == AV_NOPTS_VALUE)
1984 opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->st->time_base);
1986 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1987 opkt.dts -= ost_tb_start_time;
1989 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1990 opkt.flags = pkt->flags;
1992 // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1993 if ( ost->st->codec->codec_id != CODEC_ID_H264
1994 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1995 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1996 && ost->st->codec->codec_id != CODEC_ID_VC1
1998 if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1999 opkt.destruct = av_destruct_packet;
2001 opkt.data = pkt->data;
2002 opkt.size = pkt->size;
2004 if (of->ctx->oformat->flags & AVFMT_RAWPICTURE) {
2005 /* store AVPicture in AVPacket, as expected by the output format */
2006 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
2007 opkt.data = (uint8_t *)&pict;
2008 opkt.size = sizeof(AVPicture);
2009 opkt.flags |= AV_PKT_FLAG_KEY;
2012 write_frame(of->ctx, &opkt, ost);
2013 ost->st->codec->frame_number++;
2014 av_free_packet(&opkt);
2017 static void rate_emu_sleep(InputStream *ist)
2019 if (input_files[ist->file_index].rate_emu) {
2020 int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
2021 int64_t now = av_gettime() - ist->start;
2027 static int transcode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
2029 AVFrame *decoded_frame;
2030 AVCodecContext *avctx = ist->st->codec;
2031 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
2034 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2035 return AVERROR(ENOMEM);
2037 avcodec_get_frame_defaults(ist->decoded_frame);
2038 decoded_frame = ist->decoded_frame;
2040 ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
2044 if (avctx->sample_rate <= 0) {
2045 av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2046 return AVERROR_INVALIDDATA;
2050 /* no audio frame */
2054 /* if the decoder provides a pts, use it instead of the last packet pts.
2055 the decoder could be delaying output by a packet or more. */
2056 if (decoded_frame->pts != AV_NOPTS_VALUE)
2057 ist->dts = ist->next_dts = ist->pts = ist->next_pts = decoded_frame->pts;
2059 /* increment next_dts to use for the case where the input stream does not
2060 have timestamps or there are multiple frames in the packet */
2061 ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2063 ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2067 // preprocess audio (volume)
2068 if (audio_volume != 256) {
2069 int decoded_data_size = decoded_frame->nb_samples * avctx->channels * bps;
2070 void *samples = decoded_frame->data[0];
2071 switch (avctx->sample_fmt) {
2072 case AV_SAMPLE_FMT_U8:
2074 uint8_t *volp = samples;
2075 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2076 int v = (((*volp - 128) * audio_volume + 128) >> 8) + 128;
2077 *volp++ = av_clip_uint8(v);
2081 case AV_SAMPLE_FMT_S16:
2083 int16_t *volp = samples;
2084 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2085 int v = ((*volp) * audio_volume + 128) >> 8;
2086 *volp++ = av_clip_int16(v);
2090 case AV_SAMPLE_FMT_S32:
2092 int32_t *volp = samples;
2093 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2094 int64_t v = (((int64_t)*volp * audio_volume + 128) >> 8);
2095 *volp++ = av_clipl_int32(v);
2099 case AV_SAMPLE_FMT_FLT:
2101 float *volp = samples;
2102 float scale = audio_volume / 256.f;
2103 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2108 case AV_SAMPLE_FMT_DBL:
2110 double *volp = samples;
2111 double scale = audio_volume / 256.;
2112 for (i = 0; i < (decoded_data_size / sizeof(*volp)); i++) {
2118 av_log(NULL, AV_LOG_FATAL,
2119 "Audio volume adjustment on sample format %s is not supported.\n",
2120 av_get_sample_fmt_name(ist->st->codec->sample_fmt));
2125 rate_emu_sleep(ist);
2127 for (i = 0; i < nb_output_streams; i++) {
2128 OutputStream *ost = &output_streams[i];
2130 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2132 do_audio_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
2138 static int transcode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *pkt_pts)
2140 AVFrame *decoded_frame;
2141 void *buffer_to_free = NULL;
2143 int64_t *best_effort_timestamp;
2144 AVRational *frame_sample_aspect;
2146 if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
2147 return AVERROR(ENOMEM);
2149 avcodec_get_frame_defaults(ist->decoded_frame);
2150 decoded_frame = ist->decoded_frame;
2151 pkt->pts = *pkt_pts;
2152 pkt->dts = ist->dts;
2153 *pkt_pts = AV_NOPTS_VALUE;
2155 ret = avcodec_decode_video2(ist->st->codec,
2156 decoded_frame, got_output, pkt);
2161 /* no picture yet */
2165 best_effort_timestamp= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "best_effort_timestamp");
2166 if(*best_effort_timestamp != AV_NOPTS_VALUE)
2167 ist->next_pts = ist->pts = decoded_frame->pts = *best_effort_timestamp;
2171 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
2174 frame_sample_aspect= av_opt_ptr(avcodec_get_frame_class(), decoded_frame, "sample_aspect_ratio");
2175 for(i=0;i<nb_output_streams;i++) {
2176 OutputStream *ost = ost = &output_streams[i];
2177 if(check_output_constraints(ist, ost) && ost->encoding_needed){
2178 int changed = ist->st->codec->width != ost->input_video_filter->outputs[0]->w
2179 || ist->st->codec->height != ost->input_video_filter->outputs[0]->h
2180 || ist->st->codec->pix_fmt != ost->input_video_filter->outputs[0]->format;
2181 if (!frame_sample_aspect->num)
2182 *frame_sample_aspect = ist->st->sample_aspect_ratio;
2183 decoded_frame->pts = ist->pts;
2184 if (ist->dr1 && decoded_frame->type==FF_BUFFER_TYPE_USER && !changed) {
2185 FrameBuffer *buf = decoded_frame->opaque;
2186 AVFilterBufferRef *fb = avfilter_get_video_buffer_ref_from_arrays(
2187 decoded_frame->data, decoded_frame->linesize,
2188 AV_PERM_READ | AV_PERM_PRESERVE,
2189 ist->st->codec->width, ist->st->codec->height,
2190 ist->st->codec->pix_fmt);
2192 avfilter_copy_frame_props(fb, decoded_frame);
2193 fb->buf->priv = buf;
2194 fb->buf->free = filter_release_buffer;
2197 av_buffersrc_buffer(ost->input_video_filter, fb);
2199 if((av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, AV_VSRC_BUF_FLAG_OVERWRITE)) < 0){
2200 av_log(NULL, AV_LOG_FATAL, "Failed to inject frame into filter network\n");
2207 rate_emu_sleep(ist);
2209 for (i = 0; i < nb_output_streams; i++) {
2210 OutputStream *ost = &output_streams[i];
2212 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2216 while (av_buffersink_poll_frame(ost->output_video_filter)) {
2217 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
2218 AVFrame *filtered_frame;
2220 if (av_buffersink_get_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0){
2221 av_log(NULL, AV_LOG_WARNING, "AV Filter told us it has a frame available but failed to output one\n");
2224 if (!ist->filtered_frame && !(ist->filtered_frame = avcodec_alloc_frame())) {
2225 ret = AVERROR(ENOMEM);
2228 filtered_frame = ist->filtered_frame;
2229 *filtered_frame= *decoded_frame; //for me_threshold
2230 avfilter_fill_frame_from_video_buffer_ref(filtered_frame, ost->picref);
2231 filtered_frame->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
2232 if (!ost->frame_aspect_ratio)
2233 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
2234 do_video_out(output_files[ost->file_index].ctx, ost, ist, filtered_frame);
2236 avfilter_unref_buffer(ost->picref);
2239 do_video_out(output_files[ost->file_index].ctx, ost, ist, decoded_frame);
2244 av_free(buffer_to_free);
2248 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
2250 AVSubtitle subtitle;
2251 int i, ret = avcodec_decode_subtitle2(ist->st->codec,
2252 &subtitle, got_output, pkt);
2258 rate_emu_sleep(ist);
2260 for (i = 0; i < nb_output_streams; i++) {
2261 OutputStream *ost = &output_streams[i];
2263 if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
2266 do_subtitle_out(output_files[ost->file_index].ctx, ost, ist, &subtitle, pkt->pts);
2269 avsubtitle_free(&subtitle);
2273 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2274 static int output_packet(InputStream *ist,
2275 OutputStream *ost_table, int nb_ostreams,
2276 const AVPacket *pkt)
2280 int64_t pkt_pts = AV_NOPTS_VALUE;
2284 if (ist->next_dts == AV_NOPTS_VALUE)
2285 ist->next_dts = ist->dts;
2286 if (ist->next_pts == AV_NOPTS_VALUE)
2287 ist->next_pts = ist->pts;
2291 av_init_packet(&avpkt);
2299 if (pkt->dts != AV_NOPTS_VALUE) {
2300 ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2301 if (ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2302 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2304 if(pkt->pts != AV_NOPTS_VALUE)
2305 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2307 // while we have more to decode or while the decoder did output something on EOF
2308 while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
2312 ist->pts = ist->next_pts;
2313 ist->dts = ist->next_dts;
2315 if (avpkt.size && avpkt.size != pkt->size) {
2316 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
2317 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
2318 ist->showed_multi_packet_warning = 1;
2321 switch (ist->st->codec->codec_type) {
2322 case AVMEDIA_TYPE_AUDIO:
2323 ret = transcode_audio (ist, &avpkt, &got_output);
2325 case AVMEDIA_TYPE_VIDEO:
2326 ret = transcode_video (ist, &avpkt, &got_output, &pkt_pts);
2327 if (avpkt.duration) {
2328 duration = av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
2329 } else if(ist->st->codec->time_base.num != 0 && ist->st->codec->time_base.den != 0) {
2330 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
2331 duration = ((int64_t)AV_TIME_BASE *
2332 ist->st->codec->time_base.num * ticks) /
2333 ist->st->codec->time_base.den;
2337 if(ist->dts != AV_NOPTS_VALUE && duration) {
2338 ist->next_dts += duration;
2340 ist->next_dts = AV_NOPTS_VALUE;
2343 ist->next_pts += duration; //FIXME the duration is not correct in some cases
2345 case AVMEDIA_TYPE_SUBTITLE:
2346 ret = transcode_subtitles(ist, &avpkt, &got_output);
2356 avpkt.pts= AV_NOPTS_VALUE;
2358 // touch data and size only if not EOF
2360 if(ist->st->codec->codec_type != AVMEDIA_TYPE_AUDIO)
2370 /* handle stream copy */
2371 if (!ist->decoding_needed) {
2372 rate_emu_sleep(ist);
2373 ist->dts = ist->next_dts;
2374 switch (ist->st->codec->codec_type) {
2375 case AVMEDIA_TYPE_AUDIO:
2376 ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
2377 ist->st->codec->sample_rate;
2379 case AVMEDIA_TYPE_VIDEO:
2380 if (pkt->duration) {
2381 ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2382 } else if(ist->st->codec->time_base.num != 0) {
2383 int ticks= ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
2384 ist->next_dts += ((int64_t)AV_TIME_BASE *
2385 ist->st->codec->time_base.num * ticks) /
2386 ist->st->codec->time_base.den;
2390 ist->pts = ist->dts;
2391 ist->next_pts = ist->next_dts;
2393 for (i = 0; pkt && i < nb_ostreams; i++) {
2394 OutputStream *ost = &ost_table[i];
2396 if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2399 do_streamcopy(ist, ost, pkt);
2405 static void print_sdp(OutputFile *output_files, int n)
2409 AVFormatContext **avc = av_malloc(sizeof(*avc) * n);
2413 for (i = 0; i < n; i++)
2414 avc[i] = output_files[i].ctx;
2416 av_sdp_create(avc, n, sdp, sizeof(sdp));
2417 printf("SDP:\n%s\n", sdp);
2422 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
2423 char *error, int error_len)
2425 InputStream *ist = &input_streams[ist_index];
2426 if (ist->decoding_needed) {
2427 AVCodec *codec = ist->dec;
2429 snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2430 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
2431 return AVERROR(EINVAL);
2434 ist->dr1 = codec->capabilities & CODEC_CAP_DR1;
2435 if (codec->type == AVMEDIA_TYPE_VIDEO && ist->dr1) {
2436 ist->st->codec->get_buffer = codec_get_buffer;
2437 ist->st->codec->release_buffer = codec_release_buffer;
2438 ist->st->codec->opaque = ist;
2441 if (!av_dict_get(ist->opts, "threads", NULL, 0))
2442 av_dict_set(&ist->opts, "threads", "auto", 0);
2443 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
2444 snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
2445 ist->file_index, ist->st->index);
2446 return AVERROR(EINVAL);
2448 assert_codec_experimental(ist->st->codec, 0);
2449 assert_avoptions(ist->opts);
2452 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;
2453 ist->next_pts = AV_NOPTS_VALUE;
2454 ist->next_dts = AV_NOPTS_VALUE;
2460 static int transcode_init(OutputFile *output_files, int nb_output_files,
2461 InputFile *input_files, int nb_input_files)
2463 int ret = 0, i, j, k;
2464 AVFormatContext *oc;
2465 AVCodecContext *codec, *icodec;
2471 /* init framerate emulation */
2472 for (i = 0; i < nb_input_files; i++) {
2473 InputFile *ifile = &input_files[i];
2474 if (ifile->rate_emu)
2475 for (j = 0; j < ifile->nb_streams; j++)
2476 input_streams[j + ifile->ist_index].start = av_gettime();
2479 /* output stream init */
2480 for (i = 0; i < nb_output_files; i++) {
2481 oc = output_files[i].ctx;
2482 if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
2483 av_dump_format(oc, i, oc->filename, 1);
2484 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
2485 return AVERROR(EINVAL);
2489 /* for each output stream, we compute the right encoding parameters */
2490 for (i = 0; i < nb_output_streams; i++) {
2491 ost = &output_streams[i];
2492 oc = output_files[ost->file_index].ctx;
2493 ist = &input_streams[ost->source_index];
2495 if (ost->attachment_filename)
2498 codec = ost->st->codec;
2499 icodec = ist->st->codec;
2501 ost->st->disposition = ist->st->disposition;
2502 codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
2503 codec->chroma_sample_location = icodec->chroma_sample_location;
2505 if (ost->stream_copy) {
2506 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
2508 if (extra_size > INT_MAX) {
2509 return AVERROR(EINVAL);
2512 /* if stream_copy is selected, no need to decode or encode */
2513 codec->codec_id = icodec->codec_id;
2514 codec->codec_type = icodec->codec_type;
2516 if (!codec->codec_tag) {
2517 if (!oc->oformat->codec_tag ||
2518 av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
2519 av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
2520 codec->codec_tag = icodec->codec_tag;
2523 codec->bit_rate = icodec->bit_rate;
2524 codec->rc_max_rate = icodec->rc_max_rate;
2525 codec->rc_buffer_size = icodec->rc_buffer_size;
2526 codec->field_order = icodec->field_order;
2527 codec->extradata = av_mallocz(extra_size);
2528 if (!codec->extradata) {
2529 return AVERROR(ENOMEM);
2531 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
2532 codec->extradata_size= icodec->extradata_size;
2534 codec->time_base = ist->st->time_base;
2536 * Avi is a special case here because it supports variable fps but
2537 * having the fps and timebase differe significantly adds quite some
2540 if(!strcmp(oc->oformat->name, "avi")) {
2541 if ( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base)
2542 && av_q2d(ist->st->time_base) < 1.0/500
2544 codec->time_base = icodec->time_base;
2545 codec->time_base.num *= icodec->ticks_per_frame;
2546 codec->time_base.den *= 2;
2548 } else if(!(oc->oformat->flags & AVFMT_VARIABLE_FPS)
2549 && strcmp(oc->oformat->name, "mov") && strcmp(oc->oformat->name, "mp4") && strcmp(oc->oformat->name, "3gp")
2550 && strcmp(oc->oformat->name, "3g2") && strcmp(oc->oformat->name, "psp") && strcmp(oc->oformat->name, "ipod")
2552 if( copy_tb<0 && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base)
2553 && av_q2d(ist->st->time_base) < 1.0/500
2555 codec->time_base = icodec->time_base;
2556 codec->time_base.num *= icodec->ticks_per_frame;
2559 av_reduce(&codec->time_base.num, &codec->time_base.den,
2560 codec->time_base.num, codec->time_base.den, INT_MAX);
2562 switch (codec->codec_type) {
2563 case AVMEDIA_TYPE_AUDIO:
2564 if (audio_volume != 256) {
2565 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
2568 codec->channel_layout = icodec->channel_layout;
2569 codec->sample_rate = icodec->sample_rate;
2570 codec->channels = icodec->channels;
2571 codec->frame_size = icodec->frame_size;
2572 codec->audio_service_type = icodec->audio_service_type;
2573 codec->block_align = icodec->block_align;
2575 case AVMEDIA_TYPE_VIDEO:
2576 codec->pix_fmt = icodec->pix_fmt;
2577 codec->width = icodec->width;
2578 codec->height = icodec->height;
2579 codec->has_b_frames = icodec->has_b_frames;
2580 if (!codec->sample_aspect_ratio.num) {
2581 codec->sample_aspect_ratio =
2582 ost->st->sample_aspect_ratio =
2583 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2584 ist->st->codec->sample_aspect_ratio.num ?
2585 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2587 ost->st->avg_frame_rate = ist->st->avg_frame_rate;
2589 case AVMEDIA_TYPE_SUBTITLE:
2590 codec->width = icodec->width;
2591 codec->height = icodec->height;
2593 case AVMEDIA_TYPE_DATA:
2594 case AVMEDIA_TYPE_ATTACHMENT:
2601 ost->enc = avcodec_find_encoder(codec->codec_id);
2603 ist->decoding_needed = 1;
2604 ost->encoding_needed = 1;
2606 switch (codec->codec_type) {
2607 case AVMEDIA_TYPE_AUDIO:
2608 ost->fifo = av_fifo_alloc(1024);
2610 return AVERROR(ENOMEM);
2612 if (!codec->sample_rate)
2613 codec->sample_rate = icodec->sample_rate;
2614 choose_sample_rate(ost->st, ost->enc);
2615 codec->time_base = (AVRational){ 1, codec->sample_rate };
2617 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2618 codec->sample_fmt = icodec->sample_fmt;
2619 choose_sample_fmt(ost->st, ost->enc);
2621 if (ost->audio_channels_mapped) {
2622 /* the requested output channel is set to the number of
2623 * -map_channel only if no -ac are specified */
2624 if (!codec->channels) {
2625 codec->channels = ost->audio_channels_mapped;
2626 codec->channel_layout = av_get_default_channel_layout(codec->channels);
2627 if (!codec->channel_layout) {
2628 av_log(NULL, AV_LOG_FATAL, "Unable to find an appropriate channel layout for requested number of channel\n");
2632 /* fill unused channel mapping with -1 (which means a muted
2633 * channel in case the number of output channels is bigger
2634 * than the number of mapped channel) */
2635 for (j = ost->audio_channels_mapped; j < FF_ARRAY_ELEMS(ost->audio_channels_map); j++)
2636 ost->audio_channels_map[j] = -1;
2637 } else if (!codec->channels) {
2638 codec->channels = icodec->channels;
2639 codec->channel_layout = icodec->channel_layout;
2641 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2642 codec->channel_layout = 0;
2644 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2645 ost->audio_resample |= codec->sample_fmt != icodec->sample_fmt
2646 || codec->channel_layout != icodec->channel_layout;
2647 icodec->request_channels = codec->channels;
2648 ost->resample_sample_fmt = icodec->sample_fmt;
2649 ost->resample_sample_rate = icodec->sample_rate;
2650 ost->resample_channels = icodec->channels;
2652 case AVMEDIA_TYPE_VIDEO:
2653 if (codec->pix_fmt == PIX_FMT_NONE)
2654 codec->pix_fmt = icodec->pix_fmt;
2655 choose_pixel_fmt(ost->st, ost->enc);
2657 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2658 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2662 if (!codec->width || !codec->height) {
2663 codec->width = icodec->width;
2664 codec->height = icodec->height;
2667 ost->video_resample = codec->width != icodec->width ||
2668 codec->height != icodec->height ||
2669 codec->pix_fmt != icodec->pix_fmt;
2670 if (ost->video_resample) {
2671 codec->bits_per_raw_sample = frame_bits_per_raw_sample;
2674 ost->resample_height = icodec->height;
2675 ost->resample_width = icodec->width;
2676 ost->resample_pix_fmt = icodec->pix_fmt;
2678 if (!ost->frame_rate.num)
2679 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational) { 25, 1 };
2680 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2681 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2682 ost->frame_rate = ost->enc->supported_framerates[idx];
2684 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2685 if ( av_q2d(codec->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
2686 && (video_sync_method == VSYNC_CFR || (video_sync_method == VSYNC_AUTO && !(oc->oformat->flags & AVFMT_VARIABLE_FPS)))){
2687 av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
2688 "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
2690 for (j = 0; j < ost->forced_kf_count; j++)
2691 ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
2696 if (configure_video_filters(ist, ost)) {
2697 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2702 case AVMEDIA_TYPE_SUBTITLE:
2703 codec->time_base = (AVRational){1, 1000};
2710 if (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2)) {
2711 char logfilename[1024];
2714 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2715 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2717 if (!strcmp(ost->enc->name, "libx264")) {
2718 av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
2720 if (codec->flags & CODEC_FLAG_PASS2) {
2722 size_t logbuffer_size;
2723 if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2724 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2728 codec->stats_in = logbuffer;
2730 if (codec->flags & CODEC_FLAG_PASS1) {
2731 f = fopen(logfilename, "wb");
2733 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2734 logfilename, strerror(errno));
2744 /* open each encoder */
2745 for (i = 0; i < nb_output_streams; i++) {
2746 ost = &output_streams[i];
2747 if (ost->encoding_needed) {
2748 AVCodec *codec = ost->enc;
2749 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2751 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d:%d",
2752 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2753 ret = AVERROR(EINVAL);
2756 if (dec->subtitle_header) {
2757 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2758 if (!ost->st->codec->subtitle_header) {
2759 ret = AVERROR(ENOMEM);
2762 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2763 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2765 if (!av_dict_get(ost->opts, "threads", NULL, 0))
2766 av_dict_set(&ost->opts, "threads", "auto", 0);
2767 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2768 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2769 ost->file_index, ost->index);
2770 ret = AVERROR(EINVAL);
2773 assert_codec_experimental(ost->st->codec, 1);
2774 assert_avoptions(ost->opts);
2775 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2776 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2777 " It takes bits/s as argument, not kbits/s\n");
2778 extra_size += ost->st->codec->extradata_size;
2780 if (ost->st->codec->me_threshold)
2781 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2785 /* init input streams */
2786 for (i = 0; i < nb_input_streams; i++)
2787 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2790 /* discard unused programs */
2791 for (i = 0; i < nb_input_files; i++) {
2792 InputFile *ifile = &input_files[i];
2793 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2794 AVProgram *p = ifile->ctx->programs[j];
2795 int discard = AVDISCARD_ALL;
2797 for (k = 0; k < p->nb_stream_indexes; k++)
2798 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2799 discard = AVDISCARD_DEFAULT;
2802 p->discard = discard;
2806 /* open files and write file headers */
2807 for (i = 0; i < nb_output_files; i++) {
2808 oc = output_files[i].ctx;
2809 oc->interrupt_callback = int_cb;
2810 if (avformat_write_header(oc, &output_files[i].opts) < 0) {
2811 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2812 ret = AVERROR(EINVAL);
2815 // assert_avoptions(output_files[i].opts);
2816 if (strcmp(oc->oformat->name, "rtp")) {
2822 /* dump the file output parameters - cannot be done before in case
2824 for (i = 0; i < nb_output_files; i++) {
2825 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2828 /* dump the stream mapping */
2829 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2830 for (i = 0; i < nb_output_streams; i++) {
2831 ost = &output_streams[i];
2833 if (ost->attachment_filename) {
2834 /* an attached file */
2835 av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
2836 ost->attachment_filename, ost->file_index, ost->index);
2839 av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
2840 input_streams[ost->source_index].file_index,
2841 input_streams[ost->source_index].st->index,
2844 if (ost->audio_channels_mapped) {
2845 av_log(NULL, AV_LOG_INFO, " [ch:");
2846 for (j = 0; j < ost->audio_channels_mapped; j++)
2847 if (ost->audio_channels_map[j] == -1)
2848 av_log(NULL, AV_LOG_INFO, " M");
2850 av_log(NULL, AV_LOG_INFO, " %d", ost->audio_channels_map[j]);
2851 av_log(NULL, AV_LOG_INFO, "]");
2853 if (ost->sync_ist != &input_streams[ost->source_index])
2854 av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
2855 ost->sync_ist->file_index,
2856 ost->sync_ist->st->index);
2857 if (ost->stream_copy)
2858 av_log(NULL, AV_LOG_INFO, " (copy)");
2860 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2861 input_streams[ost->source_index].dec->name : "?",
2862 ost->enc ? ost->enc->name : "?");
2863 av_log(NULL, AV_LOG_INFO, "\n");
2867 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2872 print_sdp(output_files, nb_output_files);
2879 * The following code is the main loop of the file converter
2881 static int transcode(OutputFile *output_files, int nb_output_files,
2882 InputFile *input_files, int nb_input_files)
2885 AVFormatContext *is, *os;
2889 int no_packet_count = 0;
2890 int64_t timer_start;
2893 if (!(no_packet = av_mallocz(nb_input_files)))
2896 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2901 av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
2904 timer_start = av_gettime();
2906 for (; received_sigterm == 0;) {
2907 int file_index, ist_index;
2911 int64_t cur_time= av_gettime();
2913 ipts_min = INT64_MAX;
2915 /* if 'q' pressed, exits */
2917 static int64_t last_time;
2918 if (received_nb_signals)
2920 /* read_key() returns 0 on EOF */
2921 if(cur_time - last_time >= 100000 && !run_as_daemon){
2923 last_time = cur_time;
2928 if (key == '+') av_log_set_level(av_log_get_level()+10);
2929 if (key == '-') av_log_set_level(av_log_get_level()-10);
2930 if (key == 's') qp_hist ^= 1;
2933 do_hex_dump = do_pkt_dump = 0;
2934 } else if(do_pkt_dump){
2938 av_log_set_level(AV_LOG_DEBUG);
2941 if (key == 'c' || key == 'C'){
2942 char buf[4096], target[64], command[256], arg[256] = {0};
2945 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2947 while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
2952 (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
2953 av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
2954 target, time, command, arg);
2955 for (i = 0; i < nb_output_streams; i++) {
2956 ost = &output_streams[i];
2959 ret = avfilter_graph_send_command(ost->graph, target, command, arg, buf, sizeof(buf),
2960 key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2961 fprintf(stderr, "Command reply for stream %d: ret:%d res:%s\n", i, ret, buf);
2963 ret = avfilter_graph_queue_command(ost->graph, target, command, arg, 0, time);
2968 av_log(NULL, AV_LOG_ERROR,
2969 "Parse error, at least 3 arguments were expected, "
2970 "only %d given in string '%s'\n", n, buf);
2974 if (key == 'd' || key == 'D'){
2977 debug = input_streams[0].st->codec->debug<<1;
2978 if(!debug) debug = 1;
2979 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2982 if(scanf("%d", &debug)!=1)
2983 fprintf(stderr,"error parsing debug value\n");
2984 for(i=0;i<nb_input_streams;i++) {
2985 input_streams[i].st->codec->debug = debug;
2987 for(i=0;i<nb_output_streams;i++) {
2988 ost = &output_streams[i];
2989 ost->st->codec->debug = debug;
2991 if(debug) av_log_set_level(AV_LOG_DEBUG);
2992 fprintf(stderr,"debug=%d\n", debug);
2995 fprintf(stderr, "key function\n"
2996 "? show this help\n"
2997 "+ increase verbosity\n"
2998 "- decrease verbosity\n"
2999 "c Send command to filtergraph\n"
3000 "D cycle through available debug modes\n"
3001 "h dump packets/hex press to cycle through the 3 states\n"
3003 "s Show QP histogram\n"
3008 /* select the stream that we must read now by looking at the
3009 smallest output pts */
3011 for (i = 0; i < nb_output_streams; i++) {
3015 ost = &output_streams[i];
3016 of = &output_files[ost->file_index];
3017 os = output_files[ost->file_index].ctx;
3018 ist = &input_streams[ost->source_index];
3019 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
3020 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3022 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
3024 if (!input_files[ist->file_index].eof_reached) {
3025 if (ipts < ipts_min) {
3028 file_index = ist->file_index;
3030 if (opts < opts_min) {
3032 if (!input_sync) file_index = ist->file_index;
3035 if (ost->frame_number >= ost->max_frames) {
3037 for (j = 0; j < of->ctx->nb_streams; j++)
3038 output_streams[of->ost_index + j].is_past_recording_time = 1;
3042 /* if none, if is finished */
3043 if (file_index < 0) {
3044 if (no_packet_count) {
3045 no_packet_count = 0;
3046 memset(no_packet, 0, nb_input_files);
3053 /* read a frame from it and output it in the fifo */
3054 is = input_files[file_index].ctx;
3055 ret = av_read_frame(is, &pkt);
3056 if (ret == AVERROR(EAGAIN)) {
3057 no_packet[file_index] = 1;
3062 input_files[file_index].eof_reached = 1;
3069 no_packet_count = 0;
3070 memset(no_packet, 0, nb_input_files);
3073 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
3074 is->streams[pkt.stream_index]);
3076 /* the following test is needed in case new streams appear
3077 dynamically in stream : we ignore them */
3078 if (pkt.stream_index >= input_files[file_index].nb_streams)
3079 goto discard_packet;
3080 ist_index = input_files[file_index].ist_index + pkt.stream_index;
3081 ist = &input_streams[ist_index];
3083 goto discard_packet;
3085 if (pkt.dts != AV_NOPTS_VALUE)
3086 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3087 if (pkt.pts != AV_NOPTS_VALUE)
3088 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
3090 if (pkt.pts != AV_NOPTS_VALUE)
3091 pkt.pts *= ist->ts_scale;
3092 if (pkt.dts != AV_NOPTS_VALUE)
3093 pkt.dts *= ist->ts_scale;
3096 av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
3097 "next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%"PRId64"\n",
3098 ist_index, av_get_media_type_string(ist->st->codec->codec_type),
3099 av_ts2str(ist->next_pts), av_ts2timestr(ist->next_pts, &ist->st->time_base),
3100 av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
3101 av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
3102 input_files[ist->file_index].ts_offset);
3105 if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE && !copy_ts) {
3106 int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
3107 int64_t delta = pkt_dts - ist->next_dts;
3108 if (is->iformat->flags & AVFMT_TS_DISCONT) {
3109 if(delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
3110 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
3111 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3112 pkt_dts+1<ist->pts){
3113 input_files[ist->file_index].ts_offset -= delta;
3114 av_log(NULL, AV_LOG_DEBUG,
3115 "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
3116 delta, input_files[ist->file_index].ts_offset);
3117 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3118 if (pkt.pts != AV_NOPTS_VALUE)
3119 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
3122 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3123 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3124 pkt_dts+1<ist->pts){
3125 av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
3126 pkt.dts = AV_NOPTS_VALUE;
3128 if (pkt.pts != AV_NOPTS_VALUE){
3129 int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
3130 delta = pkt_pts - ist->next_dts;
3131 if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
3132 (delta > 1LL*dts_error_threshold*AV_TIME_BASE && ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
3133 pkt_pts+1<ist->pts) {
3134 av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
3135 pkt.pts = AV_NOPTS_VALUE;
3141 // fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
3142 if (output_packet(ist, output_streams, nb_output_streams, &pkt) < 0) {
3144 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
3145 ist->file_index, ist->st->index);
3148 av_free_packet(&pkt);
3153 av_free_packet(&pkt);
3155 /* dump report by using the output first video and audio streams */
3156 print_report(output_files, output_streams, nb_output_streams, 0, timer_start, cur_time);
3159 /* at the end of stream, we must flush the decoder buffers */
3160 for (i = 0; i < nb_input_streams; i++) {
3161 ist = &input_streams[i];
3162 if (ist->decoding_needed) {
3163 output_packet(ist, output_streams, nb_output_streams, NULL);
3166 flush_encoders(output_streams, nb_output_streams);
3170 /* write the trailer if needed and close file */
3171 for (i = 0; i < nb_output_files; i++) {
3172 os = output_files[i].ctx;
3173 av_write_trailer(os);
3176 /* dump report by using the first video and audio streams */
3177 print_report(output_files, output_streams, nb_output_streams, 1, timer_start, av_gettime());
3179 /* close each encoder */
3180 for (i = 0; i < nb_output_streams; i++) {
3181 ost = &output_streams[i];
3182 if (ost->encoding_needed) {
3183 av_freep(&ost->st->codec->stats_in);
3184 avcodec_close(ost->st->codec);
3187 avfilter_graph_free(&ost->graph);
3191 /* close each decoder */
3192 for (i = 0; i < nb_input_streams; i++) {
3193 ist = &input_streams[i];
3194 if (ist->decoding_needed) {
3195 avcodec_close(ist->st->codec);
3203 av_freep(&no_packet);
3205 if (output_streams) {
3206 for (i = 0; i < nb_output_streams; i++) {
3207 ost = &output_streams[i];
3209 if (ost->stream_copy)
3210 av_freep(&ost->st->codec->extradata);
3212 fclose(ost->logfile);
3213 ost->logfile = NULL;
3215 av_fifo_free(ost->fifo); /* works even if fifo is not
3216 initialized but set to zero */
3217 av_freep(&ost->st->codec->subtitle_header);
3218 av_free(ost->resample_frame.data[0]);
3219 av_free(ost->forced_kf_pts);
3220 if (ost->video_resample)
3221 sws_freeContext(ost->img_resample_ctx);
3222 swr_free(&ost->swr);
3223 av_dict_free(&ost->opts);
3230 static int opt_frame_crop(const char *opt, const char *arg)
3232 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the crop filter instead\n", opt);
3233 return AVERROR(EINVAL);
3236 static int opt_pad(const char *opt, const char *arg)
3238 av_log(NULL, AV_LOG_FATAL, "Option '%s' has been removed, use the pad filter instead\n", opt);
3242 static int opt_video_channel(const char *opt, const char *arg)
3244 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
3245 return opt_default("channel", arg);
3248 static int opt_video_standard(const char *opt, const char *arg)
3250 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
3251 return opt_default("standard", arg);
3254 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
3256 audio_codec_name = arg;
3257 return parse_option(o, "codec:a", arg, options);
3260 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
3262 video_codec_name = arg;
3263 return parse_option(o, "codec:v", arg, options);
3266 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
3268 subtitle_codec_name = arg;
3269 return parse_option(o, "codec:s", arg, options);
3272 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
3274 return parse_option(o, "codec:d", arg, options);
3277 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
3279 StreamMap *m = NULL;
3280 int i, negative = 0, file_idx;
3281 int sync_file_idx = -1, sync_stream_idx = 0;
3289 map = av_strdup(arg);
3291 /* parse sync stream first, just pick first matching stream */
3292 if (sync = strchr(map, ',')) {
3294 sync_file_idx = strtol(sync + 1, &sync, 0);
3295 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
3296 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
3301 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
3302 if (check_stream_specifier(input_files[sync_file_idx].ctx,
3303 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
3304 sync_stream_idx = i;
3307 if (i == input_files[sync_file_idx].nb_streams) {
3308 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
3309 "match any streams.\n", arg);
3315 file_idx = strtol(map, &p, 0);
3316 if (file_idx >= nb_input_files || file_idx < 0) {
3317 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
3321 /* disable some already defined maps */
3322 for (i = 0; i < o->nb_stream_maps; i++) {
3323 m = &o->stream_maps[i];
3324 if (file_idx == m->file_index &&
3325 check_stream_specifier(input_files[m->file_index].ctx,
3326 input_files[m->file_index].ctx->streams[m->stream_index],
3327 *p == ':' ? p + 1 : p) > 0)
3331 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
3332 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
3333 *p == ':' ? p + 1 : p) <= 0)
3335 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
3336 &o->nb_stream_maps, o->nb_stream_maps + 1);
3337 m = &o->stream_maps[o->nb_stream_maps - 1];
3339 m->file_index = file_idx;
3340 m->stream_index = i;
3342 if (sync_file_idx >= 0) {
3343 m->sync_file_index = sync_file_idx;
3344 m->sync_stream_index = sync_stream_idx;
3346 m->sync_file_index = file_idx;
3347 m->sync_stream_index = i;
3352 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
3360 static int opt_attach(OptionsContext *o, const char *opt, const char *arg)
3362 o->attachments = grow_array(o->attachments, sizeof(*o->attachments),
3363 &o->nb_attachments, o->nb_attachments + 1);
3364 o->attachments[o->nb_attachments - 1] = arg;
3368 static int opt_map_channel(OptionsContext *o, const char *opt, const char *arg)
3374 o->audio_channel_maps =
3375 grow_array(o->audio_channel_maps, sizeof(*o->audio_channel_maps),
3376 &o->nb_audio_channel_maps, o->nb_audio_channel_maps + 1);
3377 m = &o->audio_channel_maps[o->nb_audio_channel_maps - 1];
3379 /* muted channel syntax */
3380 n = sscanf(arg, "%d:%d.%d", &m->channel_idx, &m->ofile_idx, &m->ostream_idx);
3381 if ((n == 1 || n == 3) && m->channel_idx == -1) {
3382 m->file_idx = m->stream_idx = -1;
3384 m->ofile_idx = m->ostream_idx = -1;
3389 n = sscanf(arg, "%d.%d.%d:%d.%d",
3390 &m->file_idx, &m->stream_idx, &m->channel_idx,
3391 &m->ofile_idx, &m->ostream_idx);
3393 if (n != 3 && n != 5) {
3394 av_log(NULL, AV_LOG_FATAL, "Syntax error, mapchan usage: "
3395 "[file.stream.channel|-1][:syncfile:syncstream]\n");
3399 if (n != 5) // only file.stream.channel specified
3400 m->ofile_idx = m->ostream_idx = -1;
3403 if (m->file_idx < 0 || m->file_idx >= nb_input_files) {
3404 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file index: %d\n",
3408 if (m->stream_idx < 0 ||
3409 m->stream_idx >= input_files[m->file_idx].nb_streams) {
3410 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid input file stream index #%d.%d\n",
3411 m->file_idx, m->stream_idx);
3414 st = input_files[m->file_idx].ctx->streams[m->stream_idx];
3415 if (st->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
3416 av_log(NULL, AV_LOG_FATAL, "mapchan: stream #%d.%d is not an audio stream.\n",
3417 m->file_idx, m->stream_idx);
3420 if (m->channel_idx < 0 || m->channel_idx >= st->codec->channels) {
3421 av_log(NULL, AV_LOG_FATAL, "mapchan: invalid audio channel #%d.%d.%d\n",
3422 m->file_idx, m->stream_idx, m->channel_idx);
3429 * Parse a metadata specifier in arg.
3430 * @param type metadata type is written here -- g(lobal)/s(tream)/c(hapter)/p(rogram)
3431 * @param index for type c/p, chapter/program index is written here
3432 * @param stream_spec for type s, the stream specifier is written here
3434 static void parse_meta_type(char *arg, char *type, int *index, const char **stream_spec)
3442 if (*(++arg) && *arg != ':') {
3443 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", arg);
3446 *stream_spec = *arg == ':' ? arg + 1 : "";
3450 if (*(++arg) == ':')
3451 *index = strtol(++arg, NULL, 0);
3454 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
3461 static int copy_metadata(char *outspec, char *inspec, AVFormatContext *oc, AVFormatContext *ic, OptionsContext *o)
3463 AVDictionary **meta_in = NULL;
3464 AVDictionary **meta_out = NULL;
3466 char type_in, type_out;
3467 const char *istream_spec = NULL, *ostream_spec = NULL;
3468 int idx_in = 0, idx_out = 0;
3470 parse_meta_type(inspec, &type_in, &idx_in, &istream_spec);
3471 parse_meta_type(outspec, &type_out, &idx_out, &ostream_spec);
3474 if (type_out == 'g' || !*outspec)
3475 o->metadata_global_manual = 1;
3476 if (type_out == 's' || !*outspec)
3477 o->metadata_streams_manual = 1;
3478 if (type_out == 'c' || !*outspec)
3479 o->metadata_chapters_manual = 1;
3483 if (type_in == 'g' || type_out == 'g')
3484 o->metadata_global_manual = 1;
3485 if (type_in == 's' || type_out == 's')
3486 o->metadata_streams_manual = 1;
3487 if (type_in == 'c' || type_out == 'c')
3488 o->metadata_chapters_manual = 1;
3490 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3491 if ((index) < 0 || (index) >= (nb_elems)) {\
3492 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps.\n",\
3497 #define SET_DICT(type, meta, context, index)\
3500 meta = &context->metadata;\
3503 METADATA_CHECK_INDEX(index, context->nb_chapters, "chapter")\
3504 meta = &context->chapters[index]->metadata;\
3507 METADATA_CHECK_INDEX(index, context->nb_programs, "program")\
3508 meta = &context->programs[index]->metadata;\
3512 SET_DICT(type_in, meta_in, ic, idx_in);
3513 SET_DICT(type_out, meta_out, oc, idx_out);
3515 /* for input streams choose first matching stream */
3516 if (type_in == 's') {
3517 for (i = 0; i < ic->nb_streams; i++) {
3518 if ((ret = check_stream_specifier(ic, ic->streams[i], istream_spec)) > 0) {
3519 meta_in = &ic->streams[i]->metadata;
3525 av_log(NULL, AV_LOG_FATAL, "Stream specifier %s does not match any streams.\n", istream_spec);
3530 if (type_out == 's') {
3531 for (i = 0; i < oc->nb_streams; i++) {
3532 if ((ret = check_stream_specifier(oc, oc->streams[i], ostream_spec)) > 0) {
3533 meta_out = &oc->streams[i]->metadata;
3534 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3539 av_dict_copy(meta_out, *meta_in, AV_DICT_DONT_OVERWRITE);
3544 static int opt_recording_timestamp(OptionsContext *o, const char *opt, const char *arg)
3547 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
3548 struct tm time = *gmtime((time_t*)&recording_timestamp);
3549 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
3550 parse_option(o, "metadata", buf, options);
3552 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
3553 "tag instead.\n", opt);
3557 static AVCodec *find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
3559 const char *codec_string = encoder ? "encoder" : "decoder";
3563 avcodec_find_encoder_by_name(name) :
3564 avcodec_find_decoder_by_name(name);
3566 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
3569 if (codec->type != type) {
3570 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
3576 static AVCodec *choose_decoder(OptionsContext *o, AVFormatContext *s, AVStream *st)
3578 char *codec_name = NULL;
3580 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
3582 AVCodec *codec = find_codec_or_die(codec_name, st->codec->codec_type, 0);
3583 st->codec->codec_id = codec->id;
3586 return avcodec_find_decoder(st->codec->codec_id);
3590 * Add all the streams from the given input file to the global
3591 * list of input streams.
3593 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
3596 char *next, *codec_tag = NULL;
3598 for (i = 0; i < ic->nb_streams; i++) {
3599 AVStream *st = ic->streams[i];
3600 AVCodecContext *dec = st->codec;
3603 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3604 ist = &input_streams[nb_input_streams - 1];
3606 ist->file_index = nb_input_files;
3608 st->discard = AVDISCARD_ALL;
3609 ist->opts = filter_codec_opts(codec_opts, choose_decoder(o, ic, st), ic, st);
3611 ist->ts_scale = 1.0;
3612 MATCH_PER_STREAM_OPT(ts_scale, dbl, ist->ts_scale, ic, st);
3614 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
3616 uint32_t tag = strtol(codec_tag, &next, 0);
3618 tag = AV_RL32(codec_tag);
3619 st->codec->codec_tag = tag;
3622 ist->dec = choose_decoder(o, ic, st);
3624 switch (dec->codec_type) {
3625 case AVMEDIA_TYPE_VIDEO:
3627 ist->dec = avcodec_find_decoder(dec->codec_id);
3629 dec->flags |= CODEC_FLAG_EMU_EDGE;
3633 case AVMEDIA_TYPE_AUDIO:
3634 case AVMEDIA_TYPE_DATA:
3635 case AVMEDIA_TYPE_SUBTITLE:
3637 ist->dec = avcodec_find_decoder(dec->codec_id);
3639 case AVMEDIA_TYPE_ATTACHMENT:
3640 case AVMEDIA_TYPE_UNKNOWN:
3648 static void assert_file_overwrite(const char *filename)
3650 if ((!file_overwrite || no_file_overwrite) &&
3651 (strchr(filename, ':') == NULL || filename[1] == ':' ||
3652 av_strstart(filename, "file:", NULL))) {
3653 if (avio_check(filename, 0) == 0) {
3654 if (!using_stdin && (!no_file_overwrite || file_overwrite)) {
3655 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3658 signal(SIGINT, SIG_DFL);
3659 if (!read_yesno()) {
3660 av_log(NULL, AV_LOG_FATAL, "Not overwriting - exiting\n");
3666 av_log(NULL, AV_LOG_FATAL, "File '%s' already exists. Exiting.\n", filename);
3673 static void dump_attachment(AVStream *st, const char *filename)
3676 AVIOContext *out = NULL;
3677 AVDictionaryEntry *e;
3679 if (!st->codec->extradata_size) {
3680 av_log(NULL, AV_LOG_WARNING, "No extradata to dump in stream #%d:%d.\n",
3681 nb_input_files - 1, st->index);
3684 if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
3685 filename = e->value;
3687 av_log(NULL, AV_LOG_FATAL, "No filename specified and no 'filename' tag"
3688 "in stream #%d:%d.\n", nb_input_files - 1, st->index);
3692 assert_file_overwrite(filename);
3694 if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
3695 av_log(NULL, AV_LOG_FATAL, "Could not open file %s for writing.\n",
3700 avio_write(out, st->codec->extradata, st->codec->extradata_size);
3705 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
3707 AVFormatContext *ic;
3708 AVInputFormat *file_iformat = NULL;
3712 AVDictionary **opts;
3713 int orig_nb_streams; // number of streams before avformat_find_stream_info
3716 if (!(file_iformat = av_find_input_format(o->format))) {
3717 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
3722 if (!strcmp(filename, "-"))
3725 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3726 !strcmp(filename, "/dev/stdin");
3728 /* get default parameters from command line */
3729 ic = avformat_alloc_context();
3731 print_error(filename, AVERROR(ENOMEM));
3734 if (o->nb_audio_sample_rate) {
3735 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
3736 av_dict_set(&format_opts, "sample_rate", buf, 0);
3738 if (o->nb_audio_channels) {
3739 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
3740 av_dict_set(&format_opts, "channels", buf, 0);
3742 if (o->nb_frame_rates) {
3743 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
3745 if (o->nb_frame_sizes) {
3746 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
3748 if (o->nb_frame_pix_fmts)
3749 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
3751 ic->video_codec_id = video_codec_name ?
3752 find_codec_or_die(video_codec_name , AVMEDIA_TYPE_VIDEO , 0)->id : CODEC_ID_NONE;
3753 ic->audio_codec_id = audio_codec_name ?
3754 find_codec_or_die(audio_codec_name , AVMEDIA_TYPE_AUDIO , 0)->id : CODEC_ID_NONE;
3755 ic->subtitle_codec_id= subtitle_codec_name ?
3756 find_codec_or_die(subtitle_codec_name, AVMEDIA_TYPE_SUBTITLE, 0)->id : CODEC_ID_NONE;
3757 ic->flags |= AVFMT_FLAG_NONBLOCK;
3758 ic->interrupt_callback = int_cb;
3760 /* open the input file with generic avformat function */
3761 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3763 print_error(filename, err);
3766 assert_avoptions(format_opts);
3768 /* apply forced codec ids */
3769 for (i = 0; i < ic->nb_streams; i++)
3770 choose_decoder(o, ic, ic->streams[i]);
3772 /* Set AVCodecContext options for avformat_find_stream_info */
3773 opts = setup_find_stream_info_opts(ic, codec_opts);
3774 orig_nb_streams = ic->nb_streams;
3776 /* If not enough info to get the stream parameters, we decode the
3777 first frames to get it. (used in mpeg case for example) */
3778 ret = avformat_find_stream_info(ic, opts);
3780 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
3781 avformat_close_input(&ic);
3785 timestamp = o->start_time;
3786 /* add the stream start time */
3787 if (ic->start_time != AV_NOPTS_VALUE)
3788 timestamp += ic->start_time;
3790 /* if seeking requested, we execute it */
3791 if (o->start_time != 0) {
3792 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3794 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
3795 filename, (double)timestamp / AV_TIME_BASE);
3799 /* update the current parameters so that they match the one of the input stream */
3800 add_input_streams(o, ic);
3802 /* dump the file content */
3803 av_dump_format(ic, nb_input_files, filename, 0);
3805 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3806 input_files[nb_input_files - 1].ctx = ic;
3807 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3808 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
3809 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3810 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
3812 for (i = 0; i < o->nb_dump_attachment; i++) {
3815 for (j = 0; j < ic->nb_streams; j++) {
3816 AVStream *st = ic->streams[j];
3818 if (check_stream_specifier(ic, st, o->dump_attachment[i].specifier) == 1)
3819 dump_attachment(st, o->dump_attachment[i].u.str);
3823 for (i = 0; i < orig_nb_streams; i++)
3824 av_dict_free(&opts[i]);
3827 reset_options(o, 1);
3831 static void parse_forced_key_frames(char *kf, OutputStream *ost)
3836 for (p = kf; *p; p++)
3839 ost->forced_kf_count = n;
3840 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3841 if (!ost->forced_kf_pts) {
3842 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3845 for (i = 0; i < n; i++) {
3846 p = i ? strchr(p, ',') + 1 : kf;
3847 ost->forced_kf_pts[i] = parse_time_or_die("force_key_frames", p, 1);
3851 static uint8_t *get_line(AVIOContext *s)
3857 if (avio_open_dyn_buf(&line) < 0) {
3858 av_log(NULL, AV_LOG_FATAL, "Could not alloc buffer for reading preset.\n");
3862 while ((c = avio_r8(s)) && c != '\n')
3865 avio_close_dyn_buf(line, &buf);
3870 static int get_preset_file_2(const char *preset_name, const char *codec_name, AVIOContext **s)
3873 char filename[1000];
3874 const char *base[3] = { getenv("AVCONV_DATADIR"),
3879 for (i = 0; i < FF_ARRAY_ELEMS(base) && ret; i++) {
3883 snprintf(filename, sizeof(filename), "%s%s/%s-%s.avpreset", base[i],
3884 i != 1 ? "" : "/.avconv", codec_name, preset_name);
3885 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3888 snprintf(filename, sizeof(filename), "%s%s/%s.avpreset", base[i],
3889 i != 1 ? "" : "/.avconv", preset_name);
3890 ret = avio_open2(s, filename, AVIO_FLAG_READ, &int_cb, NULL);
3896 static void choose_encoder(OptionsContext *o, AVFormatContext *s, OutputStream *ost)
3898 char *codec_name = NULL;
3900 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, ost->st);
3902 ost->st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename,
3903 NULL, ost->st->codec->codec_type);
3904 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
3905 } else if (!strcmp(codec_name, "copy"))
3906 ost->stream_copy = 1;
3908 ost->enc = find_codec_or_die(codec_name, ost->st->codec->codec_type, 1);
3909 ost->st->codec->codec_id = ost->enc->id;
3913 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type, int source_index)
3916 AVStream *st = avformat_new_stream(oc, NULL);
3917 int idx = oc->nb_streams - 1, ret = 0;
3918 char *bsf = NULL, *next, *codec_tag = NULL;
3919 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
3921 char *buf = NULL, *arg = NULL, *preset = NULL;
3922 AVIOContext *s = NULL;
3925 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
3929 if (oc->nb_streams - 1 < o->nb_streamid_map)
3930 st->id = o->streamid_map[oc->nb_streams - 1];
3932 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3933 nb_output_streams + 1);
3934 ost = &output_streams[nb_output_streams - 1];
3935 ost->file_index = nb_output_files;
3938 st->codec->codec_type = type;
3939 choose_encoder(o, oc, ost);
3941 ost->opts = filter_codec_opts(codec_opts, ost->enc, oc, st);
3944 avcodec_get_context_defaults3(st->codec, ost->enc);
3945 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3947 MATCH_PER_STREAM_OPT(presets, str, preset, oc, st);
3948 if (preset && (!(ret = get_preset_file_2(preset, ost->enc->name, &s)))) {
3951 if (!buf[0] || buf[0] == '#') {
3955 if (!(arg = strchr(buf, '='))) {
3956 av_log(NULL, AV_LOG_FATAL, "Invalid line found in the preset file.\n");
3960 av_dict_set(&ost->opts, buf, arg, AV_DICT_DONT_OVERWRITE);
3962 } while (!s->eof_reached);
3966 av_log(NULL, AV_LOG_FATAL,
3967 "Preset %s specified for stream %d:%d, but could not be opened.\n",
3968 preset, ost->file_index, ost->index);
3972 ost->max_frames = INT64_MAX;
3973 MATCH_PER_STREAM_OPT(max_frames, i64, ost->max_frames, oc, st);
3975 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
3977 if (next = strchr(bsf, ','))
3979 if (!(bsfc = av_bitstream_filter_init(bsf))) {
3980 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
3984 bsfc_prev->next = bsfc;
3986 ost->bitstream_filters = bsfc;
3992 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
3994 uint32_t tag = strtol(codec_tag, &next, 0);
3996 tag = AV_RL32(codec_tag);
3997 st->codec->codec_tag = tag;
4000 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
4001 if (qscale >= 0 || same_quant) {
4002 st->codec->flags |= CODEC_FLAG_QSCALE;
4003 st->codec->global_quality = FF_QP2LAMBDA * qscale;
4006 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
4007 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
4009 av_opt_get_int(sws_opts, "sws_flags", 0, &ost->sws_flags);
4011 ost->source_index = source_index;
4012 if (source_index >= 0) {
4013 ost->sync_ist = &input_streams[source_index];
4014 input_streams[source_index].discard = 0;
4015 input_streams[source_index].st->discard = AVDISCARD_NONE;
4021 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
4024 const char *p = str;
4031 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
4038 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4042 AVCodecContext *video_enc;
4044 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO, source_index);
4046 video_enc = st->codec;
4048 if (!ost->stream_copy) {
4049 const char *p = NULL;
4050 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
4051 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
4052 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
4055 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
4056 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
4057 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
4061 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
4062 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
4063 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
4067 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
4068 if (frame_aspect_ratio) {
4070 if (av_parse_ratio(&q, frame_aspect_ratio, 255, 0, NULL) < 0 ||
4071 q.num <= 0 || q.den <= 0) {
4072 av_log(NULL, AV_LOG_FATAL, "Invalid aspect ratio: %s\n", frame_aspect_ratio);
4075 ost->frame_aspect_ratio = av_q2d(q);
4078 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
4079 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
4080 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
4081 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
4084 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
4087 video_enc->gop_size = 0;
4088 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
4090 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
4091 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
4094 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
4096 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
4098 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
4099 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
4102 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
4105 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
4106 for (i = 0; p; i++) {
4108 int e = sscanf(p, "%d,%d,%d", &start, &end, &q);
4110 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
4113 /* FIXME realloc failure */
4114 video_enc->rc_override =
4115 av_realloc(video_enc->rc_override,
4116 sizeof(RcOverride) * (i + 1));
4117 video_enc->rc_override[i].start_frame = start;
4118 video_enc->rc_override[i].end_frame = end;
4120 video_enc->rc_override[i].qscale = q;
4121 video_enc->rc_override[i].quality_factor = 1.0;
4124 video_enc->rc_override[i].qscale = 0;
4125 video_enc->rc_override[i].quality_factor = -q/100.0;
4130 video_enc->rc_override_count = i;
4131 if (!video_enc->rc_initial_buffer_occupancy)
4132 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size * 3 / 4;
4133 video_enc->intra_dc_precision = intra_dc_precision - 8;
4136 video_enc->flags|= CODEC_FLAG_PSNR;
4141 video_enc->flags |= CODEC_FLAG_PASS1;
4144 video_enc->flags |= CODEC_FLAG_PASS2;
4148 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
4149 if (forced_key_frames)
4150 parse_forced_key_frames(forced_key_frames, ost);
4152 MATCH_PER_STREAM_OPT(force_fps, i, ost->force_fps, oc, st);
4154 ost->top_field_first = -1;
4155 MATCH_PER_STREAM_OPT(top_field_first, i, ost->top_field_first, oc, st);
4158 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
4160 ost->avfilter = av_strdup(filters);
4163 MATCH_PER_STREAM_OPT(copy_initial_nonkeyframes, i, ost->copy_initial_nonkeyframes, oc ,st);
4169 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4174 AVCodecContext *audio_enc;
4176 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO, source_index);
4179 audio_enc = st->codec;
4180 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
4182 if (!ost->stream_copy) {
4183 char *sample_fmt = NULL;
4185 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
4187 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
4189 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
4190 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
4194 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
4196 ost->rematrix_volume=1.0;
4197 MATCH_PER_STREAM_OPT(rematrix_volume, f, ost->rematrix_volume, oc, st);
4200 /* check for channel mapping for this audio stream */
4201 for (n = 0; n < o->nb_audio_channel_maps; n++) {
4202 AudioChannelMap *map = &o->audio_channel_maps[n];
4203 InputStream *ist = &input_streams[ost->source_index];
4204 if ((map->channel_idx == -1 || (ist->file_index == map->file_idx && ist->st->index == map->stream_idx)) &&
4205 (map->ofile_idx == -1 || ost->file_index == map->ofile_idx) &&
4206 (map->ostream_idx == -1 || ost->st->index == map->ostream_idx)) {
4207 if (ost->audio_channels_mapped < FF_ARRAY_ELEMS(ost->audio_channels_map))
4208 ost->audio_channels_map[ost->audio_channels_mapped++] = map->channel_idx;
4210 av_log(NULL, AV_LOG_FATAL, "Max channel mapping for output %d.%d reached\n",
4211 ost->file_index, ost->st->index);
4218 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4222 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA, source_index);
4223 if (!ost->stream_copy) {
4224 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
4231 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4233 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT, source_index);
4234 ost->stream_copy = 1;
4238 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc, int source_index)
4242 AVCodecContext *subtitle_enc;
4244 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE, source_index);
4246 subtitle_enc = st->codec;
4248 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
4253 /* arg format is "output-stream-index:streamid-value". */
4254 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
4260 av_strlcpy(idx_str, arg, sizeof(idx_str));
4261 p = strchr(idx_str, ':');
4263 av_log(NULL, AV_LOG_FATAL,
4264 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
4269 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
4270 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
4271 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
4275 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
4277 AVFormatContext *is = ifile->ctx;
4278 AVFormatContext *os = ofile->ctx;
4281 for (i = 0; i < is->nb_chapters; i++) {
4282 AVChapter *in_ch = is->chapters[i], *out_ch;
4283 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
4284 AV_TIME_BASE_Q, in_ch->time_base);
4285 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
4286 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
4289 if (in_ch->end < ts_off)
4291 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
4294 out_ch = av_mallocz(sizeof(AVChapter));
4296 return AVERROR(ENOMEM);
4298 out_ch->id = in_ch->id;
4299 out_ch->time_base = in_ch->time_base;
4300 out_ch->start = FFMAX(0, in_ch->start - ts_off);
4301 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
4304 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
4307 os->chapters = av_realloc_f(os->chapters, os->nb_chapters, sizeof(AVChapter));
4309 return AVERROR(ENOMEM);
4310 os->chapters[os->nb_chapters - 1] = out_ch;
4315 static int read_ffserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
4318 AVFormatContext *ic = avformat_alloc_context();
4320 ic->interrupt_callback = int_cb;
4321 err = avformat_open_input(&ic, filename, NULL, NULL);
4324 /* copy stream format */
4325 for(i=0;i<ic->nb_streams;i++) {
4329 AVCodecContext *avctx;
4331 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
4332 ost = new_output_stream(o, s, codec->type, -1);
4337 // FIXME: a more elegant solution is needed
4338 memcpy(st, ic->streams[i], sizeof(AVStream));
4340 st->info = av_malloc(sizeof(*st->info));
4341 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
4343 avcodec_copy_context(st->codec, ic->streams[i]->codec);
4345 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !ost->stream_copy)
4346 choose_sample_fmt(st, codec);
4347 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !ost->stream_copy)
4348 choose_pixel_fmt(st, codec);
4351 avformat_close_input(&ic);
4355 static void opt_output_file(void *optctx, const char *filename)
4357 OptionsContext *o = optctx;
4358 AVFormatContext *oc;
4360 AVOutputFormat *file_oformat;
4364 if (!strcmp(filename, "-"))
4367 err = avformat_alloc_output_context2(&oc, NULL, o->format, filename);
4369 print_error(filename, err);
4372 file_oformat= oc->oformat;
4373 oc->interrupt_callback = int_cb;
4375 if (!strcmp(file_oformat->name, "ffm") &&
4376 av_strstart(filename, "http:", NULL)) {
4378 /* special case for files sent to ffserver: we get the stream
4379 parameters from ffserver */
4380 int err = read_ffserver_streams(o, oc, filename);
4382 print_error(filename, err);
4385 for(j = nb_output_streams - oc->nb_streams; j < nb_output_streams; j++) {
4386 ost = &output_streams[j];
4387 for (i = 0; i < nb_input_streams; i++) {
4388 ist = &input_streams[i];
4389 if(ist->st->codec->codec_type == ost->st->codec->codec_type){
4391 ost->source_index= i;
4393 ist->st->discard = AVDISCARD_NONE;
4398 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));
4402 } else if (!o->nb_stream_maps) {
4403 /* pick the "best" stream of each type */
4405 /* video: highest resolution */
4406 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
4407 int area = 0, idx = -1;
4408 for (i = 0; i < nb_input_streams; i++) {
4409 ist = &input_streams[i];
4410 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
4411 ist->st->codec->width * ist->st->codec->height > area) {
4412 area = ist->st->codec->width * ist->st->codec->height;
4417 new_video_stream(o, oc, idx);
4420 /* audio: most channels */
4421 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
4422 int channels = 0, idx = -1;
4423 for (i = 0; i < nb_input_streams; i++) {
4424 ist = &input_streams[i];
4425 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
4426 ist->st->codec->channels > channels) {
4427 channels = ist->st->codec->channels;
4432 new_audio_stream(o, oc, idx);
4435 /* subtitles: pick first */
4436 if (!o->subtitle_disable && (oc->oformat->subtitle_codec != CODEC_ID_NONE || subtitle_codec_name)) {
4437 for (i = 0; i < nb_input_streams; i++)
4438 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
4439 new_subtitle_stream(o, oc, i);
4443 /* do something with data? */
4445 for (i = 0; i < o->nb_stream_maps; i++) {
4446 StreamMap *map = &o->stream_maps[i];
4447 int src_idx = input_files[map->file_index].ist_index + map->stream_index;
4452 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
4453 if(o->subtitle_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE)
4455 if(o-> audio_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
4457 if(o-> video_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
4459 if(o-> data_disable && ist->st->codec->codec_type == AVMEDIA_TYPE_DATA)
4462 switch (ist->st->codec->codec_type) {
4463 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc, src_idx); break;
4464 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc, src_idx); break;
4465 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc, src_idx); break;
4466 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc, src_idx); break;
4467 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc, src_idx); break;
4469 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d:%d - unsupported type.\n",
4470 map->file_index, map->stream_index);
4477 for (i = nb_output_streams - oc->nb_streams; i < nb_output_streams; i++) { //for all streams of this output file
4478 AVDictionaryEntry *e;
4479 ost = &output_streams[i];
4481 if ( ost->stream_copy
4482 && (e = av_dict_get(codec_opts, "flags", NULL, AV_DICT_IGNORE_SUFFIX))
4483 && (!e->key[5] || check_stream_specifier(oc, ost->st, e->key+6)))
4484 if (av_opt_set(ost->st->codec, "flags", e->value, 0) < 0)
4488 /* handle attached files */
4489 for (i = 0; i < o->nb_attachments; i++) {
4491 uint8_t *attachment;
4495 if ((err = avio_open2(&pb, o->attachments[i], AVIO_FLAG_READ, &int_cb, NULL)) < 0) {
4496 av_log(NULL, AV_LOG_FATAL, "Could not open attachment file %s.\n",
4500 if ((len = avio_size(pb)) <= 0) {
4501 av_log(NULL, AV_LOG_FATAL, "Could not get size of the attachment %s.\n",
4505 if (!(attachment = av_malloc(len))) {
4506 av_log(NULL, AV_LOG_FATAL, "Attachment %s too large to fit into memory.\n",
4510 avio_read(pb, attachment, len);
4512 ost = new_attachment_stream(o, oc, -1);
4513 ost->stream_copy = 0;
4514 ost->attachment_filename = o->attachments[i];
4515 ost->st->codec->extradata = attachment;
4516 ost->st->codec->extradata_size = len;
4518 p = strrchr(o->attachments[i], '/');
4519 av_dict_set(&ost->st->metadata, "filename", (p && *p) ? p + 1 : o->attachments[i], AV_DICT_DONT_OVERWRITE);
4523 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
4524 output_files[nb_output_files - 1].ctx = oc;
4525 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
4526 output_files[nb_output_files - 1].recording_time = o->recording_time;
4527 if (o->recording_time != INT64_MAX)
4528 oc->duration = o->recording_time;
4529 output_files[nb_output_files - 1].start_time = o->start_time;
4530 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
4531 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
4533 /* check filename in case of an image number is expected */
4534 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
4535 if (!av_filename_number_test(oc->filename)) {
4536 print_error(oc->filename, AVERROR(EINVAL));
4541 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
4542 /* test if it already exists to avoid losing precious files */
4543 assert_file_overwrite(filename);
4546 if ((err = avio_open2(&oc->pb, filename, AVIO_FLAG_WRITE,
4547 &oc->interrupt_callback,
4548 &output_files[nb_output_files - 1].opts)) < 0) {
4549 print_error(filename, err);
4554 if (o->mux_preload) {
4556 snprintf(buf, sizeof(buf), "%d", (int)(o->mux_preload*AV_TIME_BASE));
4557 av_dict_set(&output_files[nb_output_files - 1].opts, "preload", buf, 0);
4559 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
4562 for (i = 0; i < o->nb_metadata_map; i++) {
4564 int in_file_index = strtol(o->metadata_map[i].u.str, &p, 0);
4566 if (in_file_index >= nb_input_files) {
4567 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d while processing metadata maps\n", in_file_index);
4570 copy_metadata(o->metadata_map[i].specifier, *p ? p + 1 : p, oc, in_file_index >= 0 ? input_files[in_file_index].ctx : NULL, o);
4574 if (o->chapters_input_file >= nb_input_files) {
4575 if (o->chapters_input_file == INT_MAX) {
4576 /* copy chapters from the first input file that has them*/
4577 o->chapters_input_file = -1;
4578 for (i = 0; i < nb_input_files; i++)
4579 if (input_files[i].ctx->nb_chapters) {
4580 o->chapters_input_file = i;
4584 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
4585 o->chapters_input_file);
4589 if (o->chapters_input_file >= 0)
4590 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
4591 !o->metadata_chapters_manual);
4593 /* copy global metadata by default */
4594 if (!o->metadata_global_manual && nb_input_files){
4595 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
4596 AV_DICT_DONT_OVERWRITE);
4597 if(o->recording_time != INT64_MAX)
4598 av_dict_set(&oc->metadata, "duration", NULL, 0);
4600 if (!o->metadata_streams_manual)
4601 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
4603 if (output_streams[i].source_index < 0) /* this is true e.g. for attached files */
4605 ist = &input_streams[output_streams[i].source_index];
4606 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
4609 /* process manually set metadata */
4610 for (i = 0; i < o->nb_metadata; i++) {
4613 const char *stream_spec;
4614 int index = 0, j, ret = 0;
4616 val = strchr(o->metadata[i].u.str, '=');
4618 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
4619 o->metadata[i].u.str);
4624 parse_meta_type(o->metadata[i].specifier, &type, &index, &stream_spec);
4626 for (j = 0; j < oc->nb_streams; j++) {
4627 if ((ret = check_stream_specifier(oc, oc->streams[j], stream_spec)) > 0) {
4628 av_dict_set(&oc->streams[j]->metadata, o->metadata[i].u.str, *val ? val : NULL, 0);
4632 printf("ret %d, stream_spec %s\n", ret, stream_spec);
4640 if (index < 0 || index >= oc->nb_chapters) {
4641 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
4644 m = &oc->chapters[index]->metadata;
4647 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
4650 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
4654 reset_options(o, 0);
4657 /* same option as mencoder */
4658 static int opt_pass(const char *opt, const char *arg)
4660 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 3);
4664 static int64_t getutime(void)
4667 struct rusage rusage;
4669 getrusage(RUSAGE_SELF, &rusage);
4670 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4671 #elif HAVE_GETPROCESSTIMES
4673 FILETIME c, e, k, u;
4674 proc = GetCurrentProcess();
4675 GetProcessTimes(proc, &c, &e, &k, &u);
4676 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4678 return av_gettime();
4682 static int64_t getmaxrss(void)
4684 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4685 struct rusage rusage;
4686 getrusage(RUSAGE_SELF, &rusage);
4687 return (int64_t)rusage.ru_maxrss * 1024;
4688 #elif HAVE_GETPROCESSMEMORYINFO
4690 PROCESS_MEMORY_COUNTERS memcounters;
4691 proc = GetCurrentProcess();
4692 memcounters.cb = sizeof(memcounters);
4693 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4694 return memcounters.PeakPagefileUsage;
4700 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
4702 return parse_option(o, "q:a", arg, options);
4705 static void show_usage(void)
4707 av_log(NULL, AV_LOG_INFO, "Hyper fast Audio and Video encoder\n");
4708 av_log(NULL, AV_LOG_INFO, "usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
4709 av_log(NULL, AV_LOG_INFO, "\n");
4712 static int opt_help(const char *opt, const char *arg)
4714 int flags = AV_OPT_FLAG_DECODING_PARAM | AV_OPT_FLAG_ENCODING_PARAM;
4715 av_log_set_callback(log_callback_help);
4717 show_help_options(options, "Main options:\n",
4718 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
4719 show_help_options(options, "\nAdvanced options:\n",
4720 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
4722 show_help_options(options, "\nVideo options:\n",
4723 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4725 show_help_options(options, "\nAdvanced Video options:\n",
4726 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4727 OPT_VIDEO | OPT_EXPERT);
4728 show_help_options(options, "\nAudio options:\n",
4729 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4731 show_help_options(options, "\nAdvanced Audio options:\n",
4732 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
4733 OPT_AUDIO | OPT_EXPERT);
4734 show_help_options(options, "\nSubtitle options:\n",
4735 OPT_SUBTITLE | OPT_GRAB,
4737 show_help_options(options, "\nAudio/Video grab options:\n",
4741 show_help_children(avcodec_get_class(), flags);
4742 show_help_children(avformat_get_class(), flags);
4743 show_help_children(sws_get_class(), flags);
4748 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
4750 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4751 static const char *const frame_rates[] = { "25", "30000/1001", "24000/1001" };
4753 if (!strncmp(arg, "pal-", 4)) {
4756 } else if (!strncmp(arg, "ntsc-", 5)) {
4759 } else if (!strncmp(arg, "film-", 5)) {
4763 /* Try to determine PAL/NTSC by peeking in the input files */
4764 if (nb_input_files) {
4766 for (j = 0; j < nb_input_files; j++) {
4767 for (i = 0; i < input_files[j].nb_streams; i++) {
4768 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4769 if (c->codec_type != AVMEDIA_TYPE_VIDEO)
4771 fr = c->time_base.den * 1000 / c->time_base.num;
4775 } else if ((fr == 29970) || (fr == 23976)) {
4780 if (norm != UNKNOWN)
4784 if (norm != UNKNOWN)
4785 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4788 if (norm == UNKNOWN) {
4789 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4790 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4791 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
4795 if (!strcmp(arg, "vcd")) {
4796 opt_video_codec(o, "c:v", "mpeg1video");
4797 opt_audio_codec(o, "c:a", "mp2");
4798 parse_option(o, "f", "vcd", options);
4800 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
4801 parse_option(o, "r", frame_rates[norm], options);
4802 opt_default("g", norm == PAL ? "15" : "18");
4804 opt_default("b:v", "1150000");
4805 opt_default("maxrate", "1150000");
4806 opt_default("minrate", "1150000");
4807 opt_default("bufsize", "327680"); // 40*1024*8;
4809 opt_default("b:a", "224000");
4810 parse_option(o, "ar", "44100", options);
4811 parse_option(o, "ac", "2", options);
4813 opt_default("packetsize", "2324");
4814 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4816 /* We have to offset the PTS, so that it is consistent with the SCR.
4817 SCR starts at 36000, but the first two packs contain only padding
4818 and the first pack from the other stream, respectively, may also have
4819 been written before.
4820 So the real data starts at SCR 36000+3*1200. */
4821 o->mux_preload = (36000 + 3 * 1200) / 90000.0; // 0.44
4822 } else if (!strcmp(arg, "svcd")) {
4824 opt_video_codec(o, "c:v", "mpeg2video");
4825 opt_audio_codec(o, "c:a", "mp2");
4826 parse_option(o, "f", "svcd", options);
4828 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
4829 parse_option(o, "r", frame_rates[norm], options);
4830 parse_option(o, "pix_fmt", "yuv420p", options);
4831 opt_default("g", norm == PAL ? "15" : "18");
4833 opt_default("b:v", "2040000");
4834 opt_default("maxrate", "2516000");
4835 opt_default("minrate", "0"); // 1145000;
4836 opt_default("bufsize", "1835008"); // 224*1024*8;
4837 opt_default("scan_offset", "1");
4840 opt_default("b:a", "224000");
4841 parse_option(o, "ar", "44100", options);
4843 opt_default("packetsize", "2324");
4845 } else if (!strcmp(arg, "dvd")) {
4847 opt_video_codec(o, "c:v", "mpeg2video");
4848 opt_audio_codec(o, "c:a", "ac3");
4849 parse_option(o, "f", "dvd", options);
4851 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4852 parse_option(o, "r", frame_rates[norm], options);
4853 parse_option(o, "pix_fmt", "yuv420p", options);
4854 opt_default("g", norm == PAL ? "15" : "18");
4856 opt_default("b:v", "6000000");
4857 opt_default("maxrate", "9000000");
4858 opt_default("minrate", "0"); // 1500000;
4859 opt_default("bufsize", "1835008"); // 224*1024*8;
4861 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4862 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4864 opt_default("b:a", "448000");
4865 parse_option(o, "ar", "48000", options);
4867 } else if (!strncmp(arg, "dv", 2)) {
4869 parse_option(o, "f", "dv", options);
4871 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
4872 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4873 norm == PAL ? "yuv420p" : "yuv411p", options);
4874 parse_option(o, "r", frame_rates[norm], options);
4876 parse_option(o, "ar", "48000", options);
4877 parse_option(o, "ac", "2", options);
4880 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
4881 return AVERROR(EINVAL);
4886 static int opt_vstats_file(const char *opt, const char *arg)
4888 av_free (vstats_filename);
4889 vstats_filename = av_strdup (arg);
4893 static int opt_vstats(const char *opt, const char *arg)
4896 time_t today2 = time(NULL);
4897 struct tm *today = localtime(&today2);
4899 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4901 return opt_vstats_file(opt, filename);
4904 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
4906 return parse_option(o, "frames:v", arg, options);
4909 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
4911 return parse_option(o, "frames:a", arg, options);
4914 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
4916 return parse_option(o, "frames:d", arg, options);
4919 static int opt_preset(OptionsContext *o, const char *opt, const char *arg)
4922 char filename[1000], tmp[1000], tmp2[1000], line[1000];
4923 const char *codec_name = *opt == 'v' ? video_codec_name :
4924 *opt == 'a' ? audio_codec_name :
4925 subtitle_codec_name;
4927 if (!(f = get_preset_file(filename, sizeof(filename), arg, *opt == 'f', codec_name))) {
4928 if(!strncmp(arg, "libx264-lossless", strlen("libx264-lossless"))){
4929 av_log(NULL, AV_LOG_FATAL, "Please use -preset <speed> -qp 0\n");
4931 av_log(NULL, AV_LOG_FATAL, "File for preset '%s' not found\n", arg);
4936 int e= fscanf(f, "%999[^\n]\n", line) - 1;
4937 if(line[0] == '#' && !e)
4939 e|= sscanf(line, "%999[^=]=%999[^\n]\n", tmp, tmp2) - 2;
4941 av_log(NULL, AV_LOG_FATAL, "%s: Invalid syntax: '%s'\n", filename, line);
4944 if(!strcmp(tmp, "acodec")){
4945 opt_audio_codec(o, tmp, tmp2);
4946 }else if(!strcmp(tmp, "vcodec")){
4947 opt_video_codec(o, tmp, tmp2);
4948 }else if(!strcmp(tmp, "scodec")){
4949 opt_subtitle_codec(o, tmp, tmp2);
4950 }else if(!strcmp(tmp, "dcodec")){
4951 opt_data_codec(o, tmp, tmp2);
4952 }else if(opt_default(tmp, tmp2) < 0){
4953 av_log(NULL, AV_LOG_FATAL, "%s: Invalid option or argument: '%s', parsed as '%s' = '%s'\n", filename, line, tmp, tmp2);
4963 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4967 static int opt_passlogfile(const char *opt, const char *arg)
4969 pass_logfilename_prefix = arg;
4970 #if CONFIG_LIBX264_ENCODER
4971 return opt_default(opt, arg);
4977 static int opt_old2new(OptionsContext *o, const char *opt, const char *arg)
4979 char *s = av_asprintf("%s:%c", opt + 1, *opt);
4980 int ret = parse_option(o, s, arg, options);
4985 static int opt_bitrate(OptionsContext *o, const char *opt, const char *arg)
4987 if(!strcmp(opt, "b")){
4988 av_log(NULL, AV_LOG_WARNING, "Please use -b:a or -b:v, -b is ambiguous\n");
4989 return parse_option(o, "b:v", arg, options);
4991 return opt_default(opt, arg);
4994 static int opt_qscale(OptionsContext *o, const char *opt, const char *arg)
4998 if(!strcmp(opt, "qscale")){
4999 av_log(NULL, AV_LOG_WARNING, "Please use -q:a or -q:v, -qscale is ambiguous\n");
5000 return parse_option(o, "q:v", arg, options);
5002 s = av_asprintf("q%s", opt + 6);
5003 ret = parse_option(o, s, arg, options);
5008 static int opt_profile(OptionsContext *o, const char *opt, const char *arg)
5010 if(!strcmp(opt, "profile")){
5011 av_log(NULL, AV_LOG_WARNING, "Please use -profile:a or -profile:v, -profile is ambiguous\n");
5012 return parse_option(o, "profile:v", arg, options);
5014 return opt_default(opt, arg);
5017 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
5019 return parse_option(o, "filter:v", arg, options);
5022 static int opt_vsync(const char *opt, const char *arg)
5024 if (!av_strcasecmp(arg, "cfr")) video_sync_method = VSYNC_CFR;
5025 else if (!av_strcasecmp(arg, "vfr")) video_sync_method = VSYNC_VFR;
5026 else if (!av_strcasecmp(arg, "passthrough")) video_sync_method = VSYNC_PASSTHROUGH;
5027 else if (!av_strcasecmp(arg, "drop")) video_sync_method = VSYNC_DROP;
5029 if (video_sync_method == VSYNC_AUTO)
5030 video_sync_method = parse_number_or_die("vsync", arg, OPT_INT, VSYNC_AUTO, VSYNC_VFR);
5034 static int opt_deinterlace(const char *opt, const char *arg)
5036 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -filter:v yadif instead\n", opt);
5041 static void parse_cpuflags(int argc, char **argv, const OptionDef *options)
5043 int idx = locate_option(argc, argv, options, "cpuflags");
5044 if (idx && argv[idx + 1])
5045 opt_cpuflags("cpuflags", argv[idx + 1]);
5048 #define OFFSET(x) offsetof(OptionsContext, x)
5049 static const OptionDef options[] = {
5051 #include "cmdutils_common_opts.h"
5052 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
5053 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
5054 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
5055 { "n", OPT_BOOL, {(void*)&no_file_overwrite}, "do not overwrite output files" },
5056 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5057 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
5058 { "pre", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(presets)}, "preset name", "preset" },
5059 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "[-]input_file_id[:stream_specifier][,sync_file_id[:stream_specifier]]" },
5060 { "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]" },
5061 { "map_metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata_map)}, "set metadata information of outfile from infile",
5062 "outfile[,metadata]:infile[,metadata]" },
5063 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
5064 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
5065 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
5066 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
5067 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
5068 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
5069 { "timestamp", HAS_ARG | OPT_FUNC2, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
5070 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
5071 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
5072 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
5073 "add timings for benchmarking" },
5074 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
5075 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
5076 "dump each input packet" },
5077 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
5078 "when dumping packets, also dump the payload" },
5079 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
5080 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
5081 { "vsync", HAS_ARG | OPT_EXPERT, {(void*)opt_vsync}, "video sync method", "" },
5082 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
5083 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
5084 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
5085 { "copytb", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying", "mode" },
5086 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
5087 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
5088 { "dts_error_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_error_threshold}, "timestamp error delta threshold", "threshold" },
5089 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
5090 { "copyinkf", OPT_BOOL | OPT_EXPERT | OPT_SPEC, {.off = OFFSET(copy_initial_nonkeyframes)}, "copy initial non-keyframes" },
5091 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
5092 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
5093 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
5094 { "qscale", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_qscale}, "use fixed quality scale (VBR)", "q" },
5095 { "profile", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_profile}, "set profile", "profile" },
5097 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
5099 { "stats", OPT_BOOL, {&print_stats}, "print progress report during encoding", },
5100 { "attach", HAS_ARG | OPT_FUNC2, {(void*)opt_attach}, "add an attachment to the output file", "filename" },
5101 { "dump_attachment", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(dump_attachment)}, "extract an attachment into a file", "filename" },
5102 { "debug_ts", OPT_BOOL | OPT_EXPERT, {&debug_ts}, "print timestamp debugging info" },
5105 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
5106 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
5107 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
5108 { "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" },
5109 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
5110 { "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" },
5111 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5112 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5113 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5114 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
5115 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5116 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5117 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5118 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
5119 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
5120 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "deprecated use -g 1"},
5121 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
5122 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
5123 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
5124 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
5125 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
5126 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
5127 "use same quantizer as source (implies VBR)" },
5128 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
5129 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
5130 { "deinterlace", OPT_EXPERT | OPT_VIDEO, {(void*)opt_deinterlace},
5131 "this option is deprecated, use the yadif filter instead" },
5132 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
5133 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
5134 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
5136 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
5138 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
5139 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
5140 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
5141 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
5142 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_old2new}, "force video tag/fourcc", "fourcc/tag" },
5143 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
5144 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
5145 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
5146 { "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" },
5147 { "b", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_bitrate}, "video bitrate (please use -b:v)", "bitrate" },
5150 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
5151 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
5152 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
5153 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
5154 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
5155 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
5156 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_old2new}, "force audio tag/fourcc", "fourcc/tag" },
5157 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
5158 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
5159 { "rmvol", HAS_ARG | OPT_AUDIO | OPT_FLOAT | OPT_SPEC, {.off = OFFSET(rematrix_volume)}, "rematrix volume (as factor)", "volume" },
5161 /* subtitle options */
5162 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
5163 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
5164 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_old2new}, "force subtitle tag/fourcc", "fourcc/tag" },
5167 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
5168 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
5169 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
5172 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
5173 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
5175 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
5176 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "audio bitstream_filters" },
5177 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_old2new}, "deprecated", "video bitstream_filters" },
5179 { "apre", HAS_ARG | OPT_AUDIO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the audio options to the indicated preset", "preset" },
5180 { "vpre", HAS_ARG | OPT_VIDEO | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the video options to the indicated preset", "preset" },
5181 { "spre", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set the subtitle options to the indicated preset", "preset" },
5182 { "fpre", HAS_ARG | OPT_EXPERT| OPT_FUNC2, {(void*)opt_preset}, "set options from indicated preset file", "filename" },
5183 /* data codec support */
5184 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
5185 { "dn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(data_disable)}, "disable data" },
5187 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
5191 int main(int argc, char **argv)
5193 OptionsContext o = { 0 };
5196 reset_options(&o, 0);
5198 av_log_set_flags(AV_LOG_SKIP_REPEATED);
5199 parse_loglevel(argc, argv, options);
5201 if(argc>1 && !strcmp(argv[1], "-d")){
5203 av_log_set_callback(log_callback_null);
5208 avcodec_register_all();
5210 avdevice_register_all();
5213 avfilter_register_all();
5216 avformat_network_init();
5218 show_banner(argc, argv, options);
5222 parse_cpuflags(argc, argv, options);
5225 parse_options(&o, argc, argv, options, opt_output_file);
5227 if (nb_output_files <= 0 && nb_input_files == 0) {
5229 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
5233 /* file converter / grab */
5234 if (nb_output_files <= 0) {
5235 av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
5239 if (nb_input_files == 0) {
5240 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
5245 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
5247 ti = getutime() - ti;
5249 int maxrss = getmaxrss() / 1024;
5250 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);