3 * Copyright (c) 2000-2011 The libav developers.
5 * This file is part of Libav.
7 * Libav is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
12 * Libav is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with Libav; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
31 #include "libavformat/avformat.h"
32 #include "libavdevice/avdevice.h"
33 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
35 #include "libavcodec/audioconvert.h"
36 #include "libavutil/audioconvert.h"
37 #include "libavutil/parseutils.h"
38 #include "libavutil/samplefmt.h"
39 #include "libavutil/colorspace.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavformat/os_support.h"
50 # include "libavfilter/avfilter.h"
51 # include "libavfilter/avfiltergraph.h"
52 # include "libavfilter/vsrc_buffer.h"
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
62 #if HAVE_GETPROCESSMEMORYINFO
68 #include <sys/select.h>
75 #include "libavutil/avassert.h"
77 const char program_name[] = "avconv";
78 const int program_birth_year = 2000;
80 /* select an input stream for an output stream */
81 typedef struct StreamMap {
82 int disabled; /** 1 is this mapping is disabled by a negative map */
86 int sync_stream_index;
90 * select an input file for an output file
92 typedef struct MetadataMap {
93 int file; ///< file index
94 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
95 int index; ///< stream/chapter/program number
98 static const OptionDef options[];
100 static int video_discard = 0;
101 static int same_quant = 0;
102 static int do_deinterlace = 0;
103 static int intra_dc_precision = 8;
104 static int qp_hist = 0;
106 static int file_overwrite = 0;
107 static int do_benchmark = 0;
108 static int do_hex_dump = 0;
109 static int do_pkt_dump = 0;
110 static int do_pass = 0;
111 static char *pass_logfilename_prefix = NULL;
112 static int video_sync_method= -1;
113 static int audio_sync_method= 0;
114 static float audio_drift_threshold= 0.1;
115 static int copy_ts= 0;
117 static int opt_shortest = 0;
118 static char *vstats_filename;
119 static FILE *vstats_file;
120 static int copy_initial_nonkeyframes = 0;
122 static int audio_volume = 256;
124 static int exit_on_error = 0;
125 static int using_stdin = 0;
126 static int64_t video_size = 0;
127 static int64_t audio_size = 0;
128 static int64_t extra_size = 0;
129 static int nb_frames_dup = 0;
130 static int nb_frames_drop = 0;
131 static int input_sync;
133 static float dts_delta_threshold = 10;
135 static uint8_t *audio_buf;
136 static uint8_t *audio_out;
137 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
139 static short *samples;
141 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
143 typedef struct InputStream {
146 int discard; /* true if stream data should be discarded */
147 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
150 int64_t start; /* time when read started */
151 int64_t next_pts; /* synthetic pts for cases where pkt.pts
153 int64_t pts; /* current pts */
154 PtsCorrectionContext pts_ctx;
156 int is_start; /* is 1 at the start and after a discontinuity */
157 int showed_multi_packet_warning;
161 typedef struct InputFile {
162 AVFormatContext *ctx;
163 int eof_reached; /* true if eof reached */
164 int ist_index; /* index of first stream in ist_table */
165 int buffer_size; /* current total buffer size */
167 int nb_streams; /* number of stream that avconv is aware of; may be different
168 from ctx.nb_streams if new streams appear during av_read_frame() */
172 typedef struct OutputStream {
173 int file_index; /* file index */
174 int index; /* stream index in the output file */
175 int source_index; /* InputStream index */
176 AVStream *st; /* stream in the output file */
177 int encoding_needed; /* true if encoding needed for this stream */
179 /* input pts and corresponding output pts
181 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
182 struct InputStream *sync_ist; /* input stream to sync against */
183 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
184 AVBitStreamFilterContext *bitstream_filters;
190 AVFrame pict_tmp; /* temporary image for resampling */
191 struct SwsContext *img_resample_ctx; /* for image resampling */
194 int resample_pix_fmt;
195 AVRational frame_rate;
199 float frame_aspect_ratio;
201 /* forced key frames */
202 int64_t *forced_kf_pts;
208 ReSampleContext *resample; /* for audio resampling */
209 int resample_sample_fmt;
210 int resample_channels;
211 int resample_sample_rate;
213 AVAudioConvert *reformat_ctx;
214 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
218 AVFilterContext *output_video_filter;
219 AVFilterContext *input_video_filter;
220 AVFilterBufferRef *picref;
222 AVFilterGraph *graph;
227 int is_past_recording_time;
231 typedef struct OutputFile {
232 AVFormatContext *ctx;
234 int ost_index; /* index of the first stream in output_streams */
235 int64_t recording_time; /* desired length of the resulting file in microseconds */
236 int64_t start_time; /* start time in microseconds */
237 uint64_t limit_filesize;
240 static InputStream *input_streams = NULL;
241 static int nb_input_streams = 0;
242 static InputFile *input_files = NULL;
243 static int nb_input_files = 0;
245 static OutputStream *output_streams = NULL;
246 static int nb_output_streams = 0;
247 static OutputFile *output_files = NULL;
248 static int nb_output_files = 0;
250 typedef struct OptionsContext {
251 /* input/output options */
255 SpecifierOpt *codec_names;
257 SpecifierOpt *audio_channels;
258 int nb_audio_channels;
259 SpecifierOpt *audio_sample_rate;
260 int nb_audio_sample_rate;
261 SpecifierOpt *frame_rates;
263 SpecifierOpt *frame_sizes;
265 SpecifierOpt *frame_pix_fmts;
266 int nb_frame_pix_fmts;
269 int64_t input_ts_offset;
272 SpecifierOpt *ts_scale;
276 StreamMap *stream_maps;
278 /* first item specifies output metadata, second is input */
279 MetadataMap (*meta_data_maps)[2];
280 int nb_meta_data_maps;
281 int metadata_global_manual;
282 int metadata_streams_manual;
283 int metadata_chapters_manual;
285 int chapters_input_file;
287 int64_t recording_time;
288 uint64_t limit_filesize;
294 int subtitle_disable;
297 /* indexed by output file stream index */
301 SpecifierOpt *metadata;
303 SpecifierOpt *max_frames;
305 SpecifierOpt *bitstream_filters;
306 int nb_bitstream_filters;
307 SpecifierOpt *codec_tags;
309 SpecifierOpt *sample_fmts;
311 SpecifierOpt *qscale;
313 SpecifierOpt *forced_key_frames;
314 int nb_forced_key_frames;
315 SpecifierOpt *force_fps;
317 SpecifierOpt *frame_aspect_ratios;
318 int nb_frame_aspect_ratios;
319 SpecifierOpt *rc_overrides;
321 SpecifierOpt *intra_matrices;
322 int nb_intra_matrices;
323 SpecifierOpt *inter_matrices;
324 int nb_inter_matrices;
325 SpecifierOpt *top_field_first;
326 int nb_top_field_first;
328 SpecifierOpt *filters;
333 #define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)\
336 for (i = 0; i < o->nb_ ## name; i++) {\
337 char *spec = o->name[i].specifier;\
338 if ((ret = check_stream_specifier(fmtctx, st, spec)) > 0)\
339 outvar = o->name[i].u.type;\
345 static void reset_options(OptionsContext *o)
347 const OptionDef *po = options;
349 /* all OPT_SPEC and OPT_STRING can be freed in generic way */
351 void *dst = (uint8_t*)o + po->u.off;
353 if (po->flags & OPT_SPEC) {
354 SpecifierOpt **so = dst;
355 int i, *count = (int*)(so + 1);
356 for (i = 0; i < *count; i++) {
357 av_freep(&(*so)[i].specifier);
358 if (po->flags & OPT_STRING)
359 av_freep(&(*so)[i].u.str);
363 } else if (po->flags & OPT_OFFSET && po->flags & OPT_STRING)
368 av_freep(&o->stream_maps);
369 av_freep(&o->meta_data_maps);
370 av_freep(&o->streamid_map);
372 memset(o, 0, sizeof(*o));
374 o->mux_preload = 0.5;
375 o->mux_max_delay = 0.7;
376 o->recording_time = INT64_MAX;
377 o->limit_filesize = UINT64_MAX;
378 o->chapters_input_file = INT_MAX;
386 static int configure_video_filters(InputStream *ist, OutputStream *ost)
388 AVFilterContext *last_filter, *filter;
389 /** filter graph containing all filters including input & output */
390 AVCodecContext *codec = ost->st->codec;
391 AVCodecContext *icodec = ist->st->codec;
392 FFSinkContext ffsink_ctx = { .pix_fmt = codec->pix_fmt };
393 AVRational sample_aspect_ratio;
397 ost->graph = avfilter_graph_alloc();
399 if (ist->st->sample_aspect_ratio.num){
400 sample_aspect_ratio = ist->st->sample_aspect_ratio;
402 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
404 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
405 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
406 sample_aspect_ratio.num, sample_aspect_ratio.den);
408 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
409 "src", args, NULL, ost->graph);
412 ret = avfilter_graph_create_filter(&ost->output_video_filter, &ffsink,
413 "out", NULL, &ffsink_ctx, ost->graph);
416 last_filter = ost->input_video_filter;
418 if (codec->width != icodec->width || codec->height != icodec->height) {
419 snprintf(args, 255, "%d:%d:flags=0x%X",
423 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
424 NULL, args, NULL, ost->graph)) < 0)
426 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
428 last_filter = filter;
431 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
432 ost->graph->scale_sws_opts = av_strdup(args);
435 AVFilterInOut *outputs = av_malloc(sizeof(AVFilterInOut));
436 AVFilterInOut *inputs = av_malloc(sizeof(AVFilterInOut));
438 outputs->name = av_strdup("in");
439 outputs->filter_ctx = last_filter;
440 outputs->pad_idx = 0;
441 outputs->next = NULL;
443 inputs->name = av_strdup("out");
444 inputs->filter_ctx = ost->output_video_filter;
448 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, inputs, outputs, NULL)) < 0)
450 av_freep(&ost->avfilter);
452 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
456 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
459 codec->width = ost->output_video_filter->inputs[0]->w;
460 codec->height = ost->output_video_filter->inputs[0]->h;
461 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
462 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
463 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
464 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
468 #endif /* CONFIG_AVFILTER */
470 static void term_exit(void)
472 av_log(NULL, AV_LOG_QUIET, "");
475 static volatile int received_sigterm = 0;
476 static volatile int received_nb_signals = 0;
479 sigterm_handler(int sig)
481 received_sigterm = sig;
482 received_nb_signals++;
486 static void term_init(void)
488 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
489 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
491 signal(SIGXCPU, sigterm_handler);
495 static int decode_interrupt_cb(void)
497 return received_nb_signals > 1;
500 void exit_program(int ret)
505 for(i=0;i<nb_output_files;i++) {
506 AVFormatContext *s = output_files[i].ctx;
507 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
509 avformat_free_context(s);
510 av_dict_free(&output_files[i].opts);
512 for(i=0;i<nb_input_files;i++) {
513 av_close_input_file(input_files[i].ctx);
515 for (i = 0; i < nb_input_streams; i++)
516 av_dict_free(&input_streams[i].opts);
520 av_free(vstats_filename);
522 av_freep(&input_streams);
523 av_freep(&input_files);
524 av_freep(&output_streams);
525 av_freep(&output_files);
530 allocated_audio_buf_size= allocated_audio_out_size= 0;
537 if (received_sigterm) {
538 av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
539 (int) received_sigterm);
543 exit(ret); /* not all OS-es handle main() return value */
546 static void assert_avoptions(AVDictionary *m)
548 AVDictionaryEntry *t;
549 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
550 av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
555 static void assert_codec_experimental(AVCodecContext *c, int encoder)
557 const char *codec_string = encoder ? "encoder" : "decoder";
559 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
560 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
561 av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
562 "results.\nAdd '-strict experimental' if you want to use it.\n",
563 codec_string, c->codec->name);
564 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
565 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
566 av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
567 codec_string, codec->name);
572 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
574 if(codec && codec->sample_fmts){
575 const enum AVSampleFormat *p= codec->sample_fmts;
577 if(*p == st->codec->sample_fmt)
581 av_log(NULL, AV_LOG_WARNING,
582 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
583 av_get_sample_fmt_name(st->codec->sample_fmt),
585 av_get_sample_fmt_name(codec->sample_fmts[0]));
586 st->codec->sample_fmt = codec->sample_fmts[0];
592 * Update the requested input sample format based on the output sample format.
593 * This is currently only used to request float output from decoders which
594 * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
595 * Ideally this will be removed in the future when decoders do not do format
596 * conversion and only output in their native format.
598 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
601 /* if sample formats match or a decoder sample format has already been
602 requested, just return */
603 if (enc->sample_fmt == dec->sample_fmt ||
604 dec->request_sample_fmt > AV_SAMPLE_FMT_NONE)
607 /* if decoder supports more than one output format */
608 if (dec_codec && dec_codec->sample_fmts &&
609 dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
610 dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
611 const enum AVSampleFormat *p;
612 int min_dec = -1, min_inc = -1;
614 /* find a matching sample format in the encoder */
615 for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
616 if (*p == enc->sample_fmt) {
617 dec->request_sample_fmt = *p;
619 } else if (*p > enc->sample_fmt) {
620 min_inc = FFMIN(min_inc, *p - enc->sample_fmt);
622 min_dec = FFMIN(min_dec, enc->sample_fmt - *p);
625 /* if none match, provide the one that matches quality closest */
626 dec->request_sample_fmt = min_inc > 0 ? enc->sample_fmt + min_inc :
627 enc->sample_fmt - min_dec;
631 static void choose_sample_rate(AVStream *st, AVCodec *codec)
633 if(codec && codec->supported_samplerates){
634 const int *p= codec->supported_samplerates;
636 int best_dist=INT_MAX;
638 int dist= abs(st->codec->sample_rate - *p);
639 if(dist < best_dist){
645 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
647 st->codec->sample_rate= best;
651 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
653 if(codec && codec->pix_fmts){
654 const enum PixelFormat *p= codec->pix_fmts;
655 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
656 if(st->codec->codec_id==CODEC_ID_MJPEG){
657 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
658 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
659 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUVJ444P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_YUV444P, PIX_FMT_BGRA, PIX_FMT_NONE};
663 if(*p == st->codec->pix_fmt)
667 if(st->codec->pix_fmt != PIX_FMT_NONE)
668 av_log(NULL, AV_LOG_WARNING,
669 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
670 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
672 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
673 st->codec->pix_fmt = codec->pix_fmts[0];
679 get_sync_ipts(const OutputStream *ost)
681 const InputStream *ist = ost->sync_ist;
682 OutputFile *of = &output_files[ost->file_index];
683 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
686 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
690 AVPacket new_pkt= *pkt;
691 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
692 &new_pkt.data, &new_pkt.size,
693 pkt->data, pkt->size,
694 pkt->flags & AV_PKT_FLAG_KEY);
697 new_pkt.destruct= av_destruct_packet;
699 av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
700 bsfc->filter->name, pkt->stream_index,
701 avctx->codec ? avctx->codec->name : "copy");
711 ret= av_interleaved_write_frame(s, pkt);
713 print_error("av_interleaved_write_frame()", ret);
718 static void do_audio_out(AVFormatContext *s,
721 unsigned char *buf, int size)
724 int64_t audio_out_size, audio_buf_size;
725 int64_t allocated_for_size= size;
727 int size_out, frame_bytes, ret, resample_changed;
728 AVCodecContext *enc= ost->st->codec;
729 AVCodecContext *dec= ist->st->codec;
730 int osize = av_get_bytes_per_sample(enc->sample_fmt);
731 int isize = av_get_bytes_per_sample(dec->sample_fmt);
732 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
735 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
736 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
737 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
738 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
739 audio_buf_size*= osize*enc->channels;
741 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
742 if(coded_bps > 8*osize)
743 audio_out_size= audio_out_size * coded_bps / (8*osize);
744 audio_out_size += FF_MIN_BUFFER_SIZE;
746 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
747 av_log(NULL, AV_LOG_FATAL, "Buffer sizes too large\n");
751 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
752 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
753 if (!audio_buf || !audio_out){
754 av_log(NULL, AV_LOG_FATAL, "Out of memory in do_audio_out\n");
758 if (enc->channels != dec->channels || enc->sample_rate != dec->sample_rate)
759 ost->audio_resample = 1;
761 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
762 ost->resample_channels != dec->channels ||
763 ost->resample_sample_rate != dec->sample_rate;
765 if ((ost->audio_resample && !ost->resample) || resample_changed) {
766 if (resample_changed) {
767 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",
768 ist->file_index, ist->st->index,
769 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
770 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
771 ost->resample_sample_fmt = dec->sample_fmt;
772 ost->resample_channels = dec->channels;
773 ost->resample_sample_rate = dec->sample_rate;
775 audio_resample_close(ost->resample);
777 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
778 if (audio_sync_method <= 1 &&
779 ost->resample_sample_fmt == enc->sample_fmt &&
780 ost->resample_channels == enc->channels &&
781 ost->resample_sample_rate == enc->sample_rate) {
782 ost->resample = NULL;
783 ost->audio_resample = 0;
784 } else if (ost->audio_resample) {
785 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
786 av_log(NULL, AV_LOG_WARNING, "Using s16 intermediate sample format for resampling\n");
787 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
788 enc->sample_rate, dec->sample_rate,
789 enc->sample_fmt, dec->sample_fmt,
791 if (!ost->resample) {
792 av_log(NULL, AV_LOG_FATAL, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
793 dec->channels, dec->sample_rate,
794 enc->channels, enc->sample_rate);
800 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
801 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
802 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
803 if (ost->reformat_ctx)
804 av_audio_convert_free(ost->reformat_ctx);
805 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
806 dec->sample_fmt, 1, NULL, 0);
807 if (!ost->reformat_ctx) {
808 av_log(NULL, AV_LOG_FATAL, "Cannot convert %s sample format to %s sample format\n",
809 av_get_sample_fmt_name(dec->sample_fmt),
810 av_get_sample_fmt_name(enc->sample_fmt));
813 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
816 if(audio_sync_method){
817 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
818 - av_fifo_size(ost->fifo)/(enc->channels * 2);
819 double idelta= delta*dec->sample_rate / enc->sample_rate;
820 int byte_delta= ((int)idelta)*2*dec->channels;
822 //FIXME resample delay
823 if(fabs(delta) > 50){
824 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
826 byte_delta= FFMAX(byte_delta, -size);
829 av_log(NULL, AV_LOG_VERBOSE, "discarding %d audio samples\n", (int)-delta);
834 static uint8_t *input_tmp= NULL;
835 input_tmp= av_realloc(input_tmp, byte_delta + size);
837 if(byte_delta > allocated_for_size - size){
838 allocated_for_size= byte_delta + (int64_t)size;
843 memset(input_tmp, 0, byte_delta);
844 memcpy(input_tmp + byte_delta, buf, size);
847 av_log(NULL, AV_LOG_VERBOSE, "adding %d audio samples of silence\n", (int)delta);
849 }else if(audio_sync_method>1){
850 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
851 av_assert0(ost->audio_resample);
852 av_log(NULL, AV_LOG_VERBOSE, "compensating audio timestamp drift:%f compensation:%d in:%d\n",
853 delta, comp, enc->sample_rate);
854 // 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));
855 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
859 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
860 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
862 if (ost->audio_resample) {
864 size_out = audio_resample(ost->resample,
865 (short *)buftmp, (short *)buf,
866 size / (dec->channels * isize));
867 size_out = size_out * enc->channels * osize;
873 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
874 const void *ibuf[6]= {buftmp};
875 void *obuf[6]= {audio_buf};
876 int istride[6]= {isize};
877 int ostride[6]= {osize};
878 int len= size_out/istride[0];
879 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
880 printf("av_audio_convert() failed\n");
886 size_out = len*osize;
889 /* now encode as many frames as possible */
890 if (enc->frame_size > 1) {
891 /* output resampled raw samples */
892 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
893 av_log(NULL, AV_LOG_FATAL, "av_fifo_realloc2() failed\n");
896 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
898 frame_bytes = enc->frame_size * osize * enc->channels;
900 while (av_fifo_size(ost->fifo) >= frame_bytes) {
902 av_init_packet(&pkt);
904 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
906 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
908 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
911 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
915 pkt.stream_index= ost->index;
918 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
919 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
920 pkt.flags |= AV_PKT_FLAG_KEY;
921 write_frame(s, &pkt, enc, ost->bitstream_filters);
923 ost->sync_opts += enc->frame_size;
927 av_init_packet(&pkt);
929 ost->sync_opts += size_out / (osize * enc->channels);
931 /* output a pcm frame */
932 /* determine the size of the coded buffer */
935 size_out = size_out*coded_bps/8;
937 if(size_out > audio_out_size){
938 av_log(NULL, AV_LOG_FATAL, "Internal error, buffer size too small\n");
942 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
943 ret = avcodec_encode_audio(enc, audio_out, size_out,
946 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
950 pkt.stream_index= ost->index;
953 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
954 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
955 pkt.flags |= AV_PKT_FLAG_KEY;
956 write_frame(s, &pkt, enc, ost->bitstream_filters);
960 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
964 AVPicture picture_tmp;
967 dec = ist->st->codec;
969 /* deinterlace : must be done before any resize */
970 if (do_deinterlace) {
973 /* create temporary picture */
974 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
975 buf = av_malloc(size);
979 picture2 = &picture_tmp;
980 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
982 if(avpicture_deinterlace(picture2, picture,
983 dec->pix_fmt, dec->width, dec->height) < 0) {
984 /* if error, do not deinterlace */
985 av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
994 if (picture != picture2)
995 *picture = *picture2;
999 static void do_subtitle_out(AVFormatContext *s,
1005 static uint8_t *subtitle_out = NULL;
1006 int subtitle_out_max_size = 1024 * 1024;
1007 int subtitle_out_size, nb, i;
1008 AVCodecContext *enc;
1011 if (pts == AV_NOPTS_VALUE) {
1012 av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
1018 enc = ost->st->codec;
1020 if (!subtitle_out) {
1021 subtitle_out = av_malloc(subtitle_out_max_size);
1024 /* Note: DVB subtitle need one packet to draw them and one other
1025 packet to clear them */
1026 /* XXX: signal it in the codec context ? */
1027 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1032 for(i = 0; i < nb; i++) {
1033 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1034 // start_display_time is required to be 0
1035 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1036 sub->end_display_time -= sub->start_display_time;
1037 sub->start_display_time = 0;
1038 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1039 subtitle_out_max_size, sub);
1040 if (subtitle_out_size < 0) {
1041 av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1045 av_init_packet(&pkt);
1046 pkt.stream_index = ost->index;
1047 pkt.data = subtitle_out;
1048 pkt.size = subtitle_out_size;
1049 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1050 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1051 /* XXX: the pts correction is handled here. Maybe handling
1052 it in the codec would be better */
1054 pkt.pts += 90 * sub->start_display_time;
1056 pkt.pts += 90 * sub->end_display_time;
1058 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1062 static int bit_buffer_size= 1024*256;
1063 static uint8_t *bit_buffer= NULL;
1065 static void do_video_resample(OutputStream *ost,
1067 AVFrame *in_picture,
1068 AVFrame **out_picture)
1070 int resample_changed = 0;
1071 AVCodecContext *dec = ist->st->codec;
1072 *out_picture = in_picture;
1074 resample_changed = ost->resample_width != dec->width ||
1075 ost->resample_height != dec->height ||
1076 ost->resample_pix_fmt != dec->pix_fmt;
1078 if (resample_changed) {
1079 av_log(NULL, AV_LOG_INFO,
1080 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1081 ist->file_index, ist->st->index,
1082 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1083 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1084 if(!ost->video_resample)
1085 ost->video_resample = 1;
1088 #if !CONFIG_AVFILTER
1089 if (ost->video_resample) {
1090 *out_picture = &ost->pict_tmp;
1091 if (resample_changed) {
1092 /* initialize a new scaler context */
1093 sws_freeContext(ost->img_resample_ctx);
1094 ost->img_resample_ctx = sws_getContext(
1095 ist->st->codec->width,
1096 ist->st->codec->height,
1097 ist->st->codec->pix_fmt,
1098 ost->st->codec->width,
1099 ost->st->codec->height,
1100 ost->st->codec->pix_fmt,
1101 ost->sws_flags, NULL, NULL, NULL);
1102 if (ost->img_resample_ctx == NULL) {
1103 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
1107 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1108 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1111 if (resample_changed) {
1112 avfilter_graph_free(&ost->graph);
1113 if (configure_video_filters(ist, ost)) {
1114 av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1119 if (resample_changed) {
1120 ost->resample_width = dec->width;
1121 ost->resample_height = dec->height;
1122 ost->resample_pix_fmt = dec->pix_fmt;
1127 static void do_video_out(AVFormatContext *s,
1130 AVFrame *in_picture,
1131 int *frame_size, float quality)
1133 int nb_frames, i, ret, format_video_sync;
1134 AVFrame *final_picture;
1135 AVCodecContext *enc;
1138 enc = ost->st->codec;
1140 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1142 /* by default, we output a single frame */
1147 format_video_sync = video_sync_method;
1148 if (format_video_sync < 0)
1149 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1151 if (format_video_sync) {
1152 double vdelta = sync_ipts - ost->sync_opts;
1153 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1156 else if (format_video_sync == 2) {
1159 }else if(vdelta>0.6)
1160 ost->sync_opts= lrintf(sync_ipts);
1161 }else if (vdelta > 1.1)
1162 nb_frames = lrintf(vdelta);
1163 //fprintf(stderr, "vdelta:%f, ost->sync_opts:%"PRId64", ost->sync_ipts:%f nb_frames:%d\n", vdelta, ost->sync_opts, get_sync_ipts(ost), nb_frames);
1164 if (nb_frames == 0){
1166 av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
1167 }else if (nb_frames > 1) {
1168 nb_frames_dup += nb_frames - 1;
1169 av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames-1);
1172 ost->sync_opts= lrintf(sync_ipts);
1174 nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1178 do_video_resample(ost, ist, in_picture, &final_picture);
1180 /* duplicates frame if needed */
1181 for(i=0;i<nb_frames;i++) {
1183 av_init_packet(&pkt);
1184 pkt.stream_index= ost->index;
1186 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1187 /* raw pictures are written as AVPicture structure to
1188 avoid any copies. We support temporarily the older
1190 enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
1191 enc->coded_frame->top_field_first = in_picture->top_field_first;
1192 pkt.data= (uint8_t *)final_picture;
1193 pkt.size= sizeof(AVPicture);
1194 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1195 pkt.flags |= AV_PKT_FLAG_KEY;
1197 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1199 AVFrame big_picture;
1201 big_picture= *final_picture;
1202 /* better than nothing: use input picture interlaced
1204 big_picture.interlaced_frame = in_picture->interlaced_frame;
1205 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1206 if (ost->top_field_first == -1)
1207 big_picture.top_field_first = in_picture->top_field_first;
1209 big_picture.top_field_first = !!ost->top_field_first;
1212 /* handles same_quant here. This is not correct because it may
1213 not be a global option */
1214 big_picture.quality = quality;
1215 if (!enc->me_threshold)
1216 big_picture.pict_type = 0;
1217 // big_picture.pts = AV_NOPTS_VALUE;
1218 big_picture.pts= ost->sync_opts;
1219 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1220 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1221 if (ost->forced_kf_index < ost->forced_kf_count &&
1222 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1223 big_picture.pict_type = AV_PICTURE_TYPE_I;
1224 ost->forced_kf_index++;
1226 ret = avcodec_encode_video(enc,
1227 bit_buffer, bit_buffer_size,
1230 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1235 pkt.data= bit_buffer;
1237 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1238 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1239 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1240 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1241 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1243 if(enc->coded_frame->key_frame)
1244 pkt.flags |= AV_PKT_FLAG_KEY;
1245 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1248 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1249 // enc->frame_number-1, ret, enc->pict_type);
1250 /* if two pass, output log */
1251 if (ost->logfile && enc->stats_out) {
1252 fprintf(ost->logfile, "%s", enc->stats_out);
1257 ost->frame_number++;
1261 static double psnr(double d){
1262 return -10.0*log(d)/log(10.0);
1265 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1268 AVCodecContext *enc;
1270 double ti1, bitrate, avg_bitrate;
1272 /* this is executed just the first time do_video_stats is called */
1274 vstats_file = fopen(vstats_filename, "w");
1281 enc = ost->st->codec;
1282 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1283 frame_number = ost->frame_number;
1284 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1285 if (enc->flags&CODEC_FLAG_PSNR)
1286 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1288 fprintf(vstats_file,"f_size= %6d ", frame_size);
1289 /* compute pts value */
1290 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1294 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1295 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1296 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1297 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1298 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1302 static void print_report(OutputFile *output_files,
1303 OutputStream *ost_table, int nb_ostreams,
1304 int is_last_report, int64_t timer_start)
1308 AVFormatContext *oc;
1310 AVCodecContext *enc;
1311 int frame_number, vid, i;
1312 double bitrate, ti1, pts;
1313 static int64_t last_time = -1;
1314 static int qp_histogram[52];
1316 if (!is_last_report) {
1318 /* display the report every 0.5 seconds */
1319 cur_time = av_gettime();
1320 if (last_time == -1) {
1321 last_time = cur_time;
1324 if ((cur_time - last_time) < 500000)
1326 last_time = cur_time;
1330 oc = output_files[0].ctx;
1332 total_size = avio_size(oc->pb);
1333 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1334 total_size= avio_tell(oc->pb);
1339 for(i=0;i<nb_ostreams;i++) {
1341 ost = &ost_table[i];
1342 enc = ost->st->codec;
1343 if (!ost->st->stream_copy && enc->coded_frame)
1344 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1345 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1346 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1348 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1349 float t = (av_gettime()-timer_start) / 1000000.0;
1351 frame_number = ost->frame_number;
1352 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1353 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1355 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1359 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1362 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1364 if (enc->flags&CODEC_FLAG_PSNR){
1366 double error, error_sum=0;
1367 double scale, scale_sum=0;
1368 char type[3]= {'Y','U','V'};
1369 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1372 error= enc->error[j];
1373 scale= enc->width*enc->height*255.0*255.0*frame_number;
1375 error= enc->coded_frame->error[j];
1376 scale= enc->width*enc->height*255.0*255.0;
1381 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1383 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1387 /* compute min output value */
1388 pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
1389 if ((pts < ti1) && (pts > 0))
1395 bitrate = (double)(total_size * 8) / ti1 / 1000.0;
1397 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1398 "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
1399 (double)total_size / 1024, ti1, bitrate);
1401 if (nb_frames_dup || nb_frames_drop)
1402 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1403 nb_frames_dup, nb_frames_drop);
1405 av_log(NULL, is_last_report ? AV_LOG_WARNING : AV_LOG_INFO, "%s \r", buf);
1409 if (is_last_report) {
1410 int64_t raw= audio_size + video_size + extra_size;
1411 av_log(NULL, AV_LOG_INFO, "\n");
1412 av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1416 100.0*(total_size - raw)/raw
1421 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1423 int fill_char = 0x00;
1424 if (sample_fmt == AV_SAMPLE_FMT_U8)
1426 memset(buf, fill_char, size);
1429 static void flush_encoders(OutputStream *ost_table, int nb_ostreams)
1433 for (i = 0; i < nb_ostreams; i++) {
1434 OutputStream *ost = &ost_table[i];
1435 AVCodecContext *enc = ost->st->codec;
1436 AVFormatContext *os = output_files[ost->file_index].ctx;
1438 if (!ost->encoding_needed)
1441 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1443 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1449 av_init_packet(&pkt);
1450 pkt.stream_index= ost->index;
1452 switch (ost->st->codec->codec_type) {
1453 case AVMEDIA_TYPE_AUDIO:
1454 fifo_bytes = av_fifo_size(ost->fifo);
1456 /* encode any samples remaining in fifo */
1457 if (fifo_bytes > 0) {
1458 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1459 int fs_tmp = enc->frame_size;
1461 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1462 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1463 enc->frame_size = fifo_bytes / (osize * enc->channels);
1465 int frame_bytes = enc->frame_size*osize*enc->channels;
1466 if (allocated_audio_buf_size < frame_bytes)
1468 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1471 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1472 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1473 ost->st->time_base.num, enc->sample_rate);
1474 enc->frame_size = fs_tmp;
1477 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1480 av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
1484 pkt.flags |= AV_PKT_FLAG_KEY;
1486 case AVMEDIA_TYPE_VIDEO:
1487 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1489 av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1493 if(enc->coded_frame && enc->coded_frame->key_frame)
1494 pkt.flags |= AV_PKT_FLAG_KEY;
1495 if (ost->logfile && enc->stats_out) {
1496 fprintf(ost->logfile, "%s", enc->stats_out);
1505 pkt.data = bit_buffer;
1507 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1508 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1509 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1514 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1515 static int output_packet(InputStream *ist, int ist_index,
1516 OutputStream *ost_table, int nb_ostreams,
1517 const AVPacket *pkt)
1519 AVFormatContext *os;
1523 void *buffer_to_free = NULL;
1524 static unsigned int samples_size= 0;
1525 AVSubtitle subtitle, *subtitle_to_free;
1526 int64_t pkt_pts = AV_NOPTS_VALUE;
1528 int frame_available;
1533 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1535 if(ist->next_pts == AV_NOPTS_VALUE)
1536 ist->next_pts= ist->pts;
1540 av_init_packet(&avpkt);
1548 if(pkt->dts != AV_NOPTS_VALUE)
1549 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1550 if(pkt->pts != AV_NOPTS_VALUE)
1551 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1553 //while we have more to decode or while the decoder did output something on EOF
1554 while (avpkt.size > 0 || (!pkt && got_output)) {
1555 uint8_t *data_buf, *decoded_data_buf;
1556 int data_size, decoded_data_size;
1557 AVFrame *decoded_frame, *filtered_frame;
1559 ist->pts= ist->next_pts;
1561 if(avpkt.size && avpkt.size != pkt->size)
1562 av_log(NULL, ist->showed_multi_packet_warning ? AV_LOG_VERBOSE : AV_LOG_WARNING,
1563 "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1564 ist->showed_multi_packet_warning=1;
1566 /* decode the packet if needed */
1567 decoded_frame = filtered_frame = NULL;
1568 decoded_data_buf = NULL; /* fail safe */
1569 decoded_data_size= 0;
1570 data_buf = avpkt.data;
1571 data_size = avpkt.size;
1572 subtitle_to_free = NULL;
1573 if (ist->decoding_needed) {
1574 switch(ist->st->codec->codec_type) {
1575 case AVMEDIA_TYPE_AUDIO:{
1576 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1577 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1579 samples= av_malloc(samples_size);
1581 decoded_data_size= samples_size;
1582 /* XXX: could avoid copy if PCM 16 bits with same
1583 endianness as CPU */
1584 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1591 got_output = decoded_data_size > 0;
1592 /* Some bug in mpeg audio decoder gives */
1593 /* decoded_data_size < 0, it seems they are overflows */
1595 /* no audio frame */
1598 decoded_data_buf = (uint8_t *)samples;
1599 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1600 (ist->st->codec->sample_rate * ist->st->codec->channels);
1602 case AVMEDIA_TYPE_VIDEO:
1603 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1604 if (!(decoded_frame = avcodec_alloc_frame()))
1605 return AVERROR(ENOMEM);
1606 avpkt.pts = pkt_pts;
1607 avpkt.dts = ist->pts;
1608 pkt_pts = AV_NOPTS_VALUE;
1610 ret = avcodec_decode_video2(ist->st->codec,
1611 decoded_frame, &got_output, &avpkt);
1612 quality = same_quant ? decoded_frame->quality : 0;
1616 /* no picture yet */
1617 av_freep(&decoded_frame);
1618 goto discard_packet;
1620 ist->next_pts = ist->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1621 decoded_frame->pkt_dts);
1622 if (ist->st->codec->time_base.num != 0) {
1623 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1624 ist->next_pts += ((int64_t)AV_TIME_BASE *
1625 ist->st->codec->time_base.num * ticks) /
1626 ist->st->codec->time_base.den;
1629 buffer_to_free = NULL;
1630 pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1632 case AVMEDIA_TYPE_SUBTITLE:
1633 ret = avcodec_decode_subtitle2(ist->st->codec,
1634 &subtitle, &got_output, &avpkt);
1638 goto discard_packet;
1640 subtitle_to_free = &subtitle;
1647 switch(ist->st->codec->codec_type) {
1648 case AVMEDIA_TYPE_AUDIO:
1649 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1650 ist->st->codec->sample_rate;
1652 case AVMEDIA_TYPE_VIDEO:
1653 if (ist->st->codec->time_base.num != 0) {
1654 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1655 ist->next_pts += ((int64_t)AV_TIME_BASE *
1656 ist->st->codec->time_base.num * ticks) /
1657 ist->st->codec->time_base.den;
1664 // preprocess audio (volume)
1665 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1666 if (audio_volume != 256) {
1669 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1670 int v = ((*volp) * audio_volume + 128) >> 8;
1671 *volp++ = av_clip_int16(v);
1676 /* frame rate emulation */
1677 if (input_files[ist->file_index].rate_emu) {
1678 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1679 int64_t now = av_gettime() - ist->start;
1683 /* if output time reached then transcode raw format,
1684 encode packets and output them */
1685 for (i = 0; i < nb_ostreams; i++) {
1686 OutputFile *of = &output_files[ost_table[i].file_index];
1689 ost = &ost_table[i];
1690 if (ost->source_index != ist_index)
1693 if (of->start_time && ist->pts < of->start_time)
1696 if (of->recording_time != INT64_MAX &&
1697 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1698 (AVRational){1, 1000000}) >= 0) {
1699 ost->is_past_recording_time = 1;
1704 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1705 ost->input_video_filter) {
1707 if (ist->st->sample_aspect_ratio.num)
1708 sar = ist->st->sample_aspect_ratio;
1710 sar = ist->st->codec->sample_aspect_ratio;
1711 av_vsrc_buffer_add_frame(ost->input_video_filter, decoded_frame, ist->pts, sar);
1712 if (!(filtered_frame = avcodec_alloc_frame())) {
1713 ret = AVERROR(ENOMEM);
1717 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1718 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1719 while (frame_available) {
1720 AVRational ist_pts_tb;
1721 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter)
1722 get_filtered_video_frame(ost->output_video_filter, filtered_frame, &ost->picref, &ist_pts_tb);
1724 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1726 filtered_frame = decoded_frame;
1728 os = output_files[ost->file_index].ctx;
1730 /* set the input output pts pairs */
1731 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1733 if (ost->encoding_needed) {
1734 av_assert0(ist->decoding_needed);
1735 switch(ost->st->codec->codec_type) {
1736 case AVMEDIA_TYPE_AUDIO:
1737 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1739 case AVMEDIA_TYPE_VIDEO:
1741 if (ost->picref->video && !ost->frame_aspect_ratio)
1742 ost->st->codec->sample_aspect_ratio = ost->picref->video->pixel_aspect;
1744 do_video_out(os, ost, ist, filtered_frame, &frame_size,
1745 same_quant ? quality : ost->st->codec->global_quality);
1746 if (vstats_filename && frame_size)
1747 do_video_stats(os, ost, frame_size);
1749 case AVMEDIA_TYPE_SUBTITLE:
1750 do_subtitle_out(os, ost, ist, &subtitle,
1758 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1760 av_init_packet(&opkt);
1762 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1763 #if !CONFIG_AVFILTER
1769 /* no reencoding needed : output the packet directly */
1770 /* force the input stream PTS */
1772 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1773 audio_size += data_size;
1774 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1775 video_size += data_size;
1779 opkt.stream_index= ost->index;
1780 if(pkt->pts != AV_NOPTS_VALUE)
1781 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1783 opkt.pts= AV_NOPTS_VALUE;
1785 if (pkt->dts == AV_NOPTS_VALUE)
1786 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1788 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1789 opkt.dts -= ost_tb_start_time;
1791 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1792 opkt.flags= pkt->flags;
1794 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1795 if( ost->st->codec->codec_id != CODEC_ID_H264
1796 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1797 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1799 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1800 opkt.destruct= av_destruct_packet;
1802 opkt.data = data_buf;
1803 opkt.size = data_size;
1806 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1807 ost->st->codec->frame_number++;
1808 ost->frame_number++;
1809 av_free_packet(&opkt);
1813 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1814 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1816 avfilter_unref_buffer(ost->picref);
1818 av_freep(&filtered_frame);
1823 av_free(buffer_to_free);
1824 /* XXX: allocate the subtitles in the codec ? */
1825 if (subtitle_to_free) {
1826 avsubtitle_free(subtitle_to_free);
1827 subtitle_to_free = NULL;
1829 av_freep(&decoded_frame);
1838 static void print_sdp(OutputFile *output_files, int n)
1842 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1846 for (i = 0; i < n; i++)
1847 avc[i] = output_files[i].ctx;
1849 av_sdp_create(avc, n, sdp, sizeof(sdp));
1850 printf("SDP:\n%s\n", sdp);
1855 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1856 char *error, int error_len)
1859 InputStream *ist = &input_streams[ist_index];
1860 if (ist->decoding_needed) {
1861 AVCodec *codec = ist->dec;
1863 snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d.%d",
1864 ist->st->codec->codec_id, ist->file_index, ist->st->index);
1865 return AVERROR(EINVAL);
1868 /* update requested sample format for the decoder based on the
1869 corresponding encoder sample format */
1870 for (i = 0; i < nb_output_streams; i++) {
1871 OutputStream *ost = &output_streams[i];
1872 if (ost->source_index == ist_index) {
1873 update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1878 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1879 snprintf(error, error_len, "Error while opening decoder for input stream #%d.%d",
1880 ist->file_index, ist->st->index);
1881 return AVERROR(EINVAL);
1883 assert_codec_experimental(ist->st->codec, 0);
1884 assert_avoptions(ist->opts);
1887 ist->pts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames*AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1888 ist->next_pts = AV_NOPTS_VALUE;
1889 init_pts_correction(&ist->pts_ctx);
1895 static int transcode_init(OutputFile *output_files,
1896 int nb_output_files,
1897 InputFile *input_files,
1900 int ret = 0, i, j, k;
1901 AVFormatContext *os;
1902 AVCodecContext *codec, *icodec;
1908 /* init framerate emulation */
1909 for (i = 0; i < nb_input_files; i++) {
1910 InputFile *ifile = &input_files[i];
1911 if (ifile->rate_emu)
1912 for (j = 0; j < ifile->nb_streams; j++)
1913 input_streams[j + ifile->ist_index].start = av_gettime();
1916 /* output stream init */
1917 for(i=0;i<nb_output_files;i++) {
1918 os = output_files[i].ctx;
1919 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1920 av_dump_format(os, i, os->filename, 1);
1921 av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
1922 return AVERROR(EINVAL);
1926 /* for each output stream, we compute the right encoding parameters */
1927 for (i = 0; i < nb_output_streams; i++) {
1928 ost = &output_streams[i];
1929 os = output_files[ost->file_index].ctx;
1930 ist = &input_streams[ost->source_index];
1932 codec = ost->st->codec;
1933 icodec = ist->st->codec;
1935 ost->st->disposition = ist->st->disposition;
1936 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1937 codec->chroma_sample_location = icodec->chroma_sample_location;
1939 if (ost->st->stream_copy) {
1940 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1942 if (extra_size > INT_MAX) {
1943 return AVERROR(EINVAL);
1946 /* if stream_copy is selected, no need to decode or encode */
1947 codec->codec_id = icodec->codec_id;
1948 codec->codec_type = icodec->codec_type;
1950 if(!codec->codec_tag){
1951 if( !os->oformat->codec_tag
1952 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1953 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1954 codec->codec_tag = icodec->codec_tag;
1957 codec->bit_rate = icodec->bit_rate;
1958 codec->rc_max_rate = icodec->rc_max_rate;
1959 codec->rc_buffer_size = icodec->rc_buffer_size;
1960 codec->extradata= av_mallocz(extra_size);
1961 if (!codec->extradata) {
1962 return AVERROR(ENOMEM);
1964 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1965 codec->extradata_size= icodec->extradata_size;
1966 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
1967 codec->time_base = icodec->time_base;
1968 codec->time_base.num *= icodec->ticks_per_frame;
1969 av_reduce(&codec->time_base.num, &codec->time_base.den,
1970 codec->time_base.num, codec->time_base.den, INT_MAX);
1972 codec->time_base = ist->st->time_base;
1973 switch(codec->codec_type) {
1974 case AVMEDIA_TYPE_AUDIO:
1975 if(audio_volume != 256) {
1976 av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
1979 codec->channel_layout = icodec->channel_layout;
1980 codec->sample_rate = icodec->sample_rate;
1981 codec->channels = icodec->channels;
1982 codec->frame_size = icodec->frame_size;
1983 codec->audio_service_type = icodec->audio_service_type;
1984 codec->block_align= icodec->block_align;
1985 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
1986 codec->block_align= 0;
1987 if(codec->codec_id == CODEC_ID_AC3)
1988 codec->block_align= 0;
1990 case AVMEDIA_TYPE_VIDEO:
1991 codec->pix_fmt = icodec->pix_fmt;
1992 codec->width = icodec->width;
1993 codec->height = icodec->height;
1994 codec->has_b_frames = icodec->has_b_frames;
1995 if (!codec->sample_aspect_ratio.num) {
1996 codec->sample_aspect_ratio =
1997 ost->st->sample_aspect_ratio =
1998 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
1999 ist->st->codec->sample_aspect_ratio.num ?
2000 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2003 case AVMEDIA_TYPE_SUBTITLE:
2004 codec->width = icodec->width;
2005 codec->height = icodec->height;
2007 case AVMEDIA_TYPE_DATA:
2008 case AVMEDIA_TYPE_ATTACHMENT:
2015 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2016 switch(codec->codec_type) {
2017 case AVMEDIA_TYPE_AUDIO:
2018 ost->fifo= av_fifo_alloc(1024);
2020 return AVERROR(ENOMEM);
2022 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2023 if (!codec->sample_rate) {
2024 codec->sample_rate = icodec->sample_rate;
2026 codec->sample_rate >>= icodec->lowres;
2028 choose_sample_rate(ost->st, ost->enc);
2029 codec->time_base = (AVRational){1, codec->sample_rate};
2030 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2031 codec->sample_fmt = icodec->sample_fmt;
2032 choose_sample_fmt(ost->st, ost->enc);
2033 if (!codec->channels)
2034 codec->channels = icodec->channels;
2035 codec->channel_layout = icodec->channel_layout;
2036 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2037 codec->channel_layout = 0;
2038 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2039 icodec->request_channels = codec->channels;
2040 ist->decoding_needed = 1;
2041 ost->encoding_needed = 1;
2042 ost->resample_sample_fmt = icodec->sample_fmt;
2043 ost->resample_sample_rate = icodec->sample_rate;
2044 ost->resample_channels = icodec->channels;
2046 case AVMEDIA_TYPE_VIDEO:
2047 if (codec->pix_fmt == PIX_FMT_NONE)
2048 codec->pix_fmt = icodec->pix_fmt;
2049 choose_pixel_fmt(ost->st, ost->enc);
2051 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2052 av_log(NULL, AV_LOG_FATAL, "Video pixel format is unknown, stream cannot be encoded\n");
2056 if (!codec->width || !codec->height) {
2057 codec->width = icodec->width;
2058 codec->height = icodec->height;
2061 ost->video_resample = codec->width != icodec->width ||
2062 codec->height != icodec->height ||
2063 codec->pix_fmt != icodec->pix_fmt;
2064 if (ost->video_resample) {
2065 #if !CONFIG_AVFILTER
2066 avcodec_get_frame_defaults(&ost->pict_tmp);
2067 if(avpicture_alloc((AVPicture*)&ost->pict_tmp, codec->pix_fmt,
2068 codec->width, codec->height)) {
2069 av_log(NULL, AV_LOG_FATAL, "Cannot allocate temp picture, check pix fmt\n");
2072 ost->img_resample_ctx = sws_getContext(
2079 ost->sws_flags, NULL, NULL, NULL);
2080 if (ost->img_resample_ctx == NULL) {
2081 av_log(NULL, AV_LOG_FATAL, "Cannot get resampling context\n");
2085 codec->bits_per_raw_sample= 0;
2088 ost->resample_height = icodec->height;
2089 ost->resample_width = icodec->width;
2090 ost->resample_pix_fmt= icodec->pix_fmt;
2091 ost->encoding_needed = 1;
2092 ist->decoding_needed = 1;
2094 if (!ost->frame_rate.num)
2095 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2096 if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
2097 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2098 ost->frame_rate = ost->enc->supported_framerates[idx];
2100 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2103 if (configure_video_filters(ist, ost)) {
2104 av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
2109 case AVMEDIA_TYPE_SUBTITLE:
2110 ost->encoding_needed = 1;
2111 ist->decoding_needed = 1;
2118 if (ost->encoding_needed &&
2119 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2120 char logfilename[1024];
2123 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2124 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2126 if (codec->flags & CODEC_FLAG_PASS1) {
2127 f = fopen(logfilename, "wb");
2129 av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
2130 logfilename, strerror(errno));
2136 size_t logbuffer_size;
2137 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2138 av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
2142 codec->stats_in = logbuffer;
2146 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2147 int size= codec->width * codec->height;
2148 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 200);
2153 bit_buffer = av_malloc(bit_buffer_size);
2155 av_log(NULL, AV_LOG_ERROR, "Cannot allocate %d bytes output buffer\n",
2157 return AVERROR(ENOMEM);
2160 /* open each encoder */
2161 for (i = 0; i < nb_output_streams; i++) {
2162 ost = &output_streams[i];
2163 if (ost->encoding_needed) {
2164 AVCodec *codec = ost->enc;
2165 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2167 snprintf(error, sizeof(error), "Encoder (codec id %d) not found for output stream #%d.%d",
2168 ost->st->codec->codec_id, ost->file_index, ost->index);
2169 ret = AVERROR(EINVAL);
2172 if (dec->subtitle_header) {
2173 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2174 if (!ost->st->codec->subtitle_header) {
2175 ret = AVERROR(ENOMEM);
2178 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2179 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2181 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2182 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2183 ost->file_index, ost->index);
2184 ret = AVERROR(EINVAL);
2187 assert_codec_experimental(ost->st->codec, 1);
2188 assert_avoptions(ost->opts);
2189 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2190 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2191 "It takes bits/s as argument, not kbits/s\n");
2192 extra_size += ost->st->codec->extradata_size;
2194 if (ost->st->codec->me_threshold)
2195 input_streams[ost->source_index].st->codec->debug |= FF_DEBUG_MV;
2199 /* init input streams */
2200 for (i = 0; i < nb_input_streams; i++)
2201 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error))) < 0)
2204 /* discard unused programs */
2205 for (i = 0; i < nb_input_files; i++) {
2206 InputFile *ifile = &input_files[i];
2207 for (j = 0; j < ifile->ctx->nb_programs; j++) {
2208 AVProgram *p = ifile->ctx->programs[j];
2209 int discard = AVDISCARD_ALL;
2211 for (k = 0; k < p->nb_stream_indexes; k++)
2212 if (!input_streams[ifile->ist_index + p->stream_index[k]].discard) {
2213 discard = AVDISCARD_DEFAULT;
2216 p->discard = discard;
2220 /* open files and write file headers */
2221 for (i = 0; i < nb_output_files; i++) {
2222 os = output_files[i].ctx;
2223 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2224 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2225 ret = AVERROR(EINVAL);
2228 assert_avoptions(output_files[i].opts);
2229 if (strcmp(os->oformat->name, "rtp")) {
2235 /* dump the file output parameters - cannot be done before in case
2237 for(i=0;i<nb_output_files;i++) {
2238 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2241 /* dump the stream mapping */
2242 av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
2243 for (i = 0; i < nb_output_streams; i++) {
2244 ost = &output_streams[i];
2245 av_log(NULL, AV_LOG_INFO, " Stream #%d.%d -> #%d.%d",
2246 input_streams[ost->source_index].file_index,
2247 input_streams[ost->source_index].st->index,
2250 if (ost->sync_ist != &input_streams[ost->source_index])
2251 av_log(NULL, AV_LOG_INFO, " [sync #%d.%d]",
2252 ost->sync_ist->file_index,
2253 ost->sync_ist->st->index);
2254 if (ost->st->stream_copy)
2255 av_log(NULL, AV_LOG_INFO, " (copy)");
2257 av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index].dec ?
2258 input_streams[ost->source_index].dec->name : "?",
2259 ost->enc ? ost->enc->name : "?");
2260 av_log(NULL, AV_LOG_INFO, "\n");
2264 av_log(NULL, AV_LOG_ERROR, "%s\n", error);
2269 print_sdp(output_files, nb_output_files);
2276 * The following code is the main loop of the file converter
2278 static int transcode(OutputFile *output_files,
2279 int nb_output_files,
2280 InputFile *input_files,
2284 AVFormatContext *is, *os;
2288 int no_packet_count=0;
2289 int64_t timer_start;
2291 if (!(no_packet = av_mallocz(nb_input_files)))
2294 ret = transcode_init(output_files, nb_output_files, input_files, nb_input_files);
2298 av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2301 timer_start = av_gettime();
2303 for(; received_sigterm == 0;) {
2304 int file_index, ist_index;
2309 ipts_min = INT64_MAX;
2312 /* select the stream that we must read now by looking at the
2313 smallest output pts */
2315 for (i = 0; i < nb_output_streams; i++) {
2319 ost = &output_streams[i];
2320 of = &output_files[ost->file_index];
2321 os = output_files[ost->file_index].ctx;
2322 ist = &input_streams[ost->source_index];
2323 if (ost->is_past_recording_time || no_packet[ist->file_index] ||
2324 (os->pb && avio_tell(os->pb) >= of->limit_filesize))
2326 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2328 if (!input_files[ist->file_index].eof_reached){
2329 if(ipts < ipts_min) {
2331 if(input_sync ) file_index = ist->file_index;
2333 if(opts < opts_min) {
2335 if(!input_sync) file_index = ist->file_index;
2338 if (ost->frame_number >= ost->max_frames) {
2340 for (j = 0; j < of->ctx->nb_streams; j++)
2341 output_streams[of->ost_index + j].is_past_recording_time = 1;
2345 /* if none, if is finished */
2346 if (file_index < 0) {
2347 if(no_packet_count){
2349 memset(no_packet, 0, nb_input_files);
2356 /* read a frame from it and output it in the fifo */
2357 is = input_files[file_index].ctx;
2358 ret= av_read_frame(is, &pkt);
2359 if(ret == AVERROR(EAGAIN)){
2360 no_packet[file_index]=1;
2365 input_files[file_index].eof_reached = 1;
2373 memset(no_packet, 0, nb_input_files);
2376 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2377 is->streams[pkt.stream_index]);
2379 /* the following test is needed in case new streams appear
2380 dynamically in stream : we ignore them */
2381 if (pkt.stream_index >= input_files[file_index].nb_streams)
2382 goto discard_packet;
2383 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2384 ist = &input_streams[ist_index];
2386 goto discard_packet;
2388 if (pkt.dts != AV_NOPTS_VALUE)
2389 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2390 if (pkt.pts != AV_NOPTS_VALUE)
2391 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2393 if(pkt.pts != AV_NOPTS_VALUE)
2394 pkt.pts *= ist->ts_scale;
2395 if(pkt.dts != AV_NOPTS_VALUE)
2396 pkt.dts *= ist->ts_scale;
2398 // fprintf(stderr, "next:%"PRId64" dts:%"PRId64" off:%"PRId64" %d\n", ist->next_pts, pkt.dts, input_files[ist->file_index].ts_offset, ist->st->codec->codec_type);
2399 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2400 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2401 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2402 int64_t delta= pkt_dts - ist->next_pts;
2403 if((FFABS(delta) > 1LL*dts_delta_threshold*AV_TIME_BASE || pkt_dts+1<ist->pts)&& !copy_ts){
2404 input_files[ist->file_index].ts_offset -= delta;
2405 av_log(NULL, AV_LOG_DEBUG, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2406 delta, input_files[ist->file_index].ts_offset);
2407 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2408 if(pkt.pts != AV_NOPTS_VALUE)
2409 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2413 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2414 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2416 av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d.%d\n",
2417 ist->file_index, ist->st->index);
2420 av_free_packet(&pkt);
2425 av_free_packet(&pkt);
2427 /* dump report by using the output first video and audio streams */
2428 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2431 /* at the end of stream, we must flush the decoder buffers */
2432 for (i = 0; i < nb_input_streams; i++) {
2433 ist = &input_streams[i];
2434 if (ist->decoding_needed) {
2435 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2438 flush_encoders(output_streams, nb_output_streams);
2442 /* write the trailer if needed and close file */
2443 for(i=0;i<nb_output_files;i++) {
2444 os = output_files[i].ctx;
2445 av_write_trailer(os);
2448 /* dump report by using the first video and audio streams */
2449 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2451 /* close each encoder */
2452 for (i = 0; i < nb_output_streams; i++) {
2453 ost = &output_streams[i];
2454 if (ost->encoding_needed) {
2455 av_freep(&ost->st->codec->stats_in);
2456 avcodec_close(ost->st->codec);
2459 avfilter_graph_free(&ost->graph);
2463 /* close each decoder */
2464 for (i = 0; i < nb_input_streams; i++) {
2465 ist = &input_streams[i];
2466 if (ist->decoding_needed) {
2467 avcodec_close(ist->st->codec);
2475 av_freep(&bit_buffer);
2476 av_freep(&no_packet);
2478 if (output_streams) {
2479 for (i = 0; i < nb_output_streams; i++) {
2480 ost = &output_streams[i];
2482 if (ost->st->stream_copy)
2483 av_freep(&ost->st->codec->extradata);
2485 fclose(ost->logfile);
2486 ost->logfile = NULL;
2488 av_fifo_free(ost->fifo); /* works even if fifo is not
2489 initialized but set to zero */
2490 av_freep(&ost->st->codec->subtitle_header);
2491 av_free(ost->pict_tmp.data[0]);
2492 av_free(ost->forced_kf_pts);
2493 if (ost->video_resample)
2494 sws_freeContext(ost->img_resample_ctx);
2496 audio_resample_close(ost->resample);
2497 if (ost->reformat_ctx)
2498 av_audio_convert_free(ost->reformat_ctx);
2499 av_dict_free(&ost->opts);
2506 static int opt_verbose(const char *opt, const char *arg)
2508 av_log(NULL, AV_LOG_WARNING, "-%s is deprecated, use -loglevel\n", opt);
2512 static double parse_frame_aspect_ratio(const char *arg)
2519 p = strchr(arg, ':');
2521 x = strtol(arg, &end, 10);
2523 y = strtol(end+1, &end, 10);
2525 ar = (double)x / (double)y;
2527 ar = strtod(arg, NULL);
2530 av_log(NULL, AV_LOG_FATAL, "Incorrect aspect ratio specification.\n");
2536 static int opt_audio_codec(OptionsContext *o, const char *opt, const char *arg)
2538 return parse_option(o, "codec:a", arg, options);
2541 static int opt_video_codec(OptionsContext *o, const char *opt, const char *arg)
2543 return parse_option(o, "codec:v", arg, options);
2546 static int opt_subtitle_codec(OptionsContext *o, const char *opt, const char *arg)
2548 return parse_option(o, "codec:s", arg, options);
2551 static int opt_data_codec(OptionsContext *o, const char *opt, const char *arg)
2553 return parse_option(o, "codec:d", arg, options);
2556 static int opt_map(OptionsContext *o, const char *opt, const char *arg)
2558 StreamMap *m = NULL;
2559 int i, negative = 0, file_idx;
2560 int sync_file_idx = -1, sync_stream_idx;
2568 map = av_strdup(arg);
2570 /* parse sync stream first, just pick first matching stream */
2571 if (sync = strchr(map, ',')) {
2573 sync_file_idx = strtol(sync + 1, &sync, 0);
2574 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2575 av_log(NULL, AV_LOG_FATAL, "Invalid sync file index: %d.\n", sync_file_idx);
2580 for (i = 0; i < input_files[sync_file_idx].nb_streams; i++)
2581 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2582 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2583 sync_stream_idx = i;
2586 if (i == input_files[sync_file_idx].nb_streams) {
2587 av_log(NULL, AV_LOG_FATAL, "Sync stream specification in map %s does not "
2588 "match any streams.\n", arg);
2594 file_idx = strtol(map, &p, 0);
2595 if (file_idx >= nb_input_files || file_idx < 0) {
2596 av_log(NULL, AV_LOG_FATAL, "Invalid input file index: %d.\n", file_idx);
2600 /* disable some already defined maps */
2601 for (i = 0; i < o->nb_stream_maps; i++) {
2602 m = &o->stream_maps[i];
2603 if (check_stream_specifier(input_files[m->file_index].ctx,
2604 input_files[m->file_index].ctx->streams[m->stream_index],
2605 *p == ':' ? p + 1 : p) > 0)
2609 for (i = 0; i < input_files[file_idx].nb_streams; i++) {
2610 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2611 *p == ':' ? p + 1 : p) <= 0)
2613 o->stream_maps = grow_array(o->stream_maps, sizeof(*o->stream_maps),
2614 &o->nb_stream_maps, o->nb_stream_maps + 1);
2615 m = &o->stream_maps[o->nb_stream_maps - 1];
2617 m->file_index = file_idx;
2618 m->stream_index = i;
2620 if (sync_file_idx >= 0) {
2621 m->sync_file_index = sync_file_idx;
2622 m->sync_stream_index = sync_stream_idx;
2624 m->sync_file_index = file_idx;
2625 m->sync_stream_index = i;
2630 av_log(NULL, AV_LOG_FATAL, "Stream map '%s' matches no streams.\n", arg);
2638 static void parse_meta_type(char *arg, char *type, int *index)
2648 if (*(++arg) == ':')
2649 *index = strtol(++arg, NULL, 0);
2652 av_log(NULL, AV_LOG_FATAL, "Invalid metadata type %c.\n", *arg);
2659 static int opt_map_metadata(OptionsContext *o, const char *opt, const char *arg)
2661 MetadataMap *m, *m1;
2664 o->meta_data_maps = grow_array(o->meta_data_maps, sizeof(*o->meta_data_maps),
2665 &o->nb_meta_data_maps, o->nb_meta_data_maps + 1);
2667 m = &o->meta_data_maps[o->nb_meta_data_maps - 1][1];
2668 m->file = strtol(arg, &p, 0);
2669 parse_meta_type(*p ? p + 1 : p, &m->type, &m->index);
2671 m1 = &o->meta_data_maps[o->nb_meta_data_maps - 1][0];
2672 if (p = strchr(opt, ':'))
2673 parse_meta_type(p + 1, &m1->type, &m1->index);
2677 if (m->type == 'g' || m1->type == 'g')
2678 o->metadata_global_manual = 1;
2679 if (m->type == 's' || m1->type == 's')
2680 o->metadata_streams_manual = 1;
2681 if (m->type == 'c' || m1->type == 'c')
2682 o->metadata_chapters_manual = 1;
2687 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2689 const char *codec_string = encoder ? "encoder" : "decoder";
2693 return CODEC_ID_NONE;
2695 avcodec_find_encoder_by_name(name) :
2696 avcodec_find_decoder_by_name(name);
2698 av_log(NULL, AV_LOG_FATAL, "Unknown %s '%s'\n", codec_string, name);
2701 if(codec->type != type) {
2702 av_log(NULL, AV_LOG_FATAL, "Invalid %s type '%s'\n", codec_string, name);
2708 static AVCodec *choose_codec(OptionsContext *o, AVFormatContext *s, AVStream *st, enum AVMediaType type)
2710 char *codec_name = NULL;
2712 MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
2716 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
2717 return avcodec_find_encoder(st->codec->codec_id);
2719 } else if (!strcmp(codec_name, "copy"))
2720 st->stream_copy = 1;
2722 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
2723 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
2724 avcodec_find_decoder_by_name(codec_name);
2731 * Add all the streams from the given input file to the global
2732 * list of input streams.
2734 static void add_input_streams(OptionsContext *o, AVFormatContext *ic)
2736 int i, rfps, rfps_base;
2738 for (i = 0; i < ic->nb_streams; i++) {
2739 AVStream *st = ic->streams[i];
2740 AVCodecContext *dec = st->codec;
2744 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
2745 ist = &input_streams[nb_input_streams - 1];
2747 ist->file_index = nb_input_files;
2749 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
2751 MATCH_PER_STREAM_OPT(ts_scale, dbl, scale, ic, st);
2752 ist->ts_scale = scale;
2754 ist->dec = choose_codec(o, ic, st, dec->codec_type);
2756 ist->dec = avcodec_find_decoder(dec->codec_id);
2758 switch (dec->codec_type) {
2759 case AVMEDIA_TYPE_AUDIO:
2760 if (o->audio_disable)
2761 st->discard= AVDISCARD_ALL;
2763 case AVMEDIA_TYPE_VIDEO:
2764 rfps = ic->streams[i]->r_frame_rate.num;
2765 rfps_base = ic->streams[i]->r_frame_rate.den;
2767 dec->flags |= CODEC_FLAG_EMU_EDGE;
2768 dec->height >>= dec->lowres;
2769 dec->width >>= dec->lowres;
2772 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
2774 av_log(NULL, AV_LOG_INFO,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
2775 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
2776 (float)rfps / rfps_base, rfps, rfps_base);
2779 if (o->video_disable)
2780 st->discard= AVDISCARD_ALL;
2781 else if(video_discard)
2782 st->discard= video_discard;
2784 case AVMEDIA_TYPE_DATA:
2786 case AVMEDIA_TYPE_SUBTITLE:
2787 if (o->subtitle_disable)
2788 st->discard = AVDISCARD_ALL;
2790 case AVMEDIA_TYPE_ATTACHMENT:
2791 case AVMEDIA_TYPE_UNKNOWN:
2799 static int opt_input_file(OptionsContext *o, const char *opt, const char *filename)
2801 AVFormatContext *ic;
2802 AVInputFormat *file_iformat = NULL;
2806 AVDictionary **opts;
2807 int orig_nb_streams; // number of streams before avformat_find_stream_info
2810 if (!(file_iformat = av_find_input_format(o->format))) {
2811 av_log(NULL, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
2816 if (!strcmp(filename, "-"))
2819 using_stdin |= !strncmp(filename, "pipe:", 5) ||
2820 !strcmp(filename, "/dev/stdin");
2822 /* get default parameters from command line */
2823 ic = avformat_alloc_context();
2825 print_error(filename, AVERROR(ENOMEM));
2828 if (o->nb_audio_sample_rate) {
2829 snprintf(buf, sizeof(buf), "%d", o->audio_sample_rate[o->nb_audio_sample_rate - 1].u.i);
2830 av_dict_set(&format_opts, "sample_rate", buf, 0);
2832 if (o->nb_audio_channels) {
2833 snprintf(buf, sizeof(buf), "%d", o->audio_channels[o->nb_audio_channels - 1].u.i);
2834 av_dict_set(&format_opts, "channels", buf, 0);
2836 if (o->nb_frame_rates) {
2837 av_dict_set(&format_opts, "framerate", o->frame_rates[o->nb_frame_rates - 1].u.str, 0);
2839 if (o->nb_frame_sizes) {
2840 av_dict_set(&format_opts, "video_size", o->frame_sizes[o->nb_frame_sizes - 1].u.str, 0);
2842 if (o->nb_frame_pix_fmts)
2843 av_dict_set(&format_opts, "pixel_format", o->frame_pix_fmts[o->nb_frame_pix_fmts - 1].u.str, 0);
2845 ic->flags |= AVFMT_FLAG_NONBLOCK;
2847 /* open the input file with generic libav function */
2848 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
2850 print_error(filename, err);
2853 assert_avoptions(format_opts);
2855 /* apply forced codec ids */
2856 for (i = 0; i < ic->nb_streams; i++)
2857 choose_codec(o, ic, ic->streams[i], ic->streams[i]->codec->codec_type);
2859 /* Set AVCodecContext options for avformat_find_stream_info */
2860 opts = setup_find_stream_info_opts(ic, codec_opts);
2861 orig_nb_streams = ic->nb_streams;
2863 /* If not enough info to get the stream parameters, we decode the
2864 first frames to get it. (used in mpeg case for example) */
2865 ret = avformat_find_stream_info(ic, opts);
2867 av_log(NULL, AV_LOG_FATAL, "%s: could not find codec parameters\n", filename);
2868 av_close_input_file(ic);
2872 timestamp = o->start_time;
2873 /* add the stream start time */
2874 if (ic->start_time != AV_NOPTS_VALUE)
2875 timestamp += ic->start_time;
2877 /* if seeking requested, we execute it */
2878 if (o->start_time != 0) {
2879 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
2881 av_log(NULL, AV_LOG_WARNING, "%s: could not seek to position %0.3f\n",
2882 filename, (double)timestamp / AV_TIME_BASE);
2886 /* update the current parameters so that they match the one of the input stream */
2887 add_input_streams(o, ic);
2889 /* dump the file content */
2890 av_dump_format(ic, nb_input_files, filename, 0);
2892 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
2893 input_files[nb_input_files - 1].ctx = ic;
2894 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
2895 input_files[nb_input_files - 1].ts_offset = o->input_ts_offset - (copy_ts ? 0 : timestamp);
2896 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
2897 input_files[nb_input_files - 1].rate_emu = o->rate_emu;
2899 for (i = 0; i < orig_nb_streams; i++)
2900 av_dict_free(&opts[i]);
2907 static void parse_forced_key_frames(char *kf, OutputStream *ost,
2908 AVCodecContext *avctx)
2914 for (p = kf; *p; p++)
2917 ost->forced_kf_count = n;
2918 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
2919 if (!ost->forced_kf_pts) {
2920 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
2923 for (i = 0; i < n; i++) {
2924 p = i ? strchr(p, ',') + 1 : kf;
2925 t = parse_time_or_die("force_key_frames", p, 1);
2926 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
2930 static OutputStream *new_output_stream(OptionsContext *o, AVFormatContext *oc, enum AVMediaType type)
2933 AVStream *st = av_new_stream(oc, oc->nb_streams < o->nb_streamid_map ? o->streamid_map[oc->nb_streams] : 0);
2934 int idx = oc->nb_streams - 1;
2935 int64_t max_frames = INT64_MAX;
2936 char *bsf = NULL, *next, *codec_tag = NULL;
2937 AVBitStreamFilterContext *bsfc, *bsfc_prev = NULL;
2941 av_log(NULL, AV_LOG_FATAL, "Could not alloc stream.\n");
2945 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
2946 nb_output_streams + 1);
2947 ost = &output_streams[nb_output_streams - 1];
2948 ost->file_index = nb_output_files;
2951 st->codec->codec_type = type;
2952 ost->enc = choose_codec(o, oc, st, type);
2954 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
2957 avcodec_get_context_defaults3(st->codec, ost->enc);
2958 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
2960 MATCH_PER_STREAM_OPT(max_frames, i64, max_frames, oc, st);
2961 ost->max_frames = max_frames;
2963 MATCH_PER_STREAM_OPT(bitstream_filters, str, bsf, oc, st);
2965 if (next = strchr(bsf, ','))
2967 if (!(bsfc = av_bitstream_filter_init(bsf))) {
2968 av_log(NULL, AV_LOG_FATAL, "Unknown bitstream filter %s\n", bsf);
2972 bsfc_prev->next = bsfc;
2974 ost->bitstream_filters = bsfc;
2980 MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, oc, st);
2982 uint32_t tag = strtol(codec_tag, &next, 0);
2984 tag = AV_RL32(codec_tag);
2985 st->codec->codec_tag = tag;
2988 MATCH_PER_STREAM_OPT(qscale, dbl, qscale, oc, st);
2989 if (qscale >= 0 || same_quant) {
2990 st->codec->flags |= CODEC_FLAG_QSCALE;
2991 st->codec->global_quality = FF_QP2LAMBDA * qscale;
2994 if (oc->oformat->flags & AVFMT_GLOBALHEADER)
2995 st->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
2997 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3001 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3004 const char *p = str;
3011 av_log(NULL, AV_LOG_FATAL, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3018 static OutputStream *new_video_stream(OptionsContext *o, AVFormatContext *oc)
3022 AVCodecContext *video_enc;
3024 ost = new_output_stream(o, oc, AVMEDIA_TYPE_VIDEO);
3026 video_enc = st->codec;
3028 if (!st->stream_copy) {
3029 const char *p = NULL;
3030 char *forced_key_frames = NULL, *frame_rate = NULL, *frame_size = NULL;
3031 char *frame_aspect_ratio = NULL, *frame_pix_fmt = NULL;
3032 char *intra_matrix = NULL, *inter_matrix = NULL, *filters = NULL;
3033 int i, force_fps = 0, top_field_first = -1;
3035 MATCH_PER_STREAM_OPT(frame_rates, str, frame_rate, oc, st);
3036 if (frame_rate && av_parse_video_rate(&ost->frame_rate, frame_rate) < 0) {
3037 av_log(NULL, AV_LOG_FATAL, "Invalid framerate value: %s\n", frame_rate);
3041 MATCH_PER_STREAM_OPT(frame_sizes, str, frame_size, oc, st);
3042 if (frame_size && av_parse_video_size(&video_enc->width, &video_enc->height, frame_size) < 0) {
3043 av_log(NULL, AV_LOG_FATAL, "Invalid frame size: %s.\n", frame_size);
3047 MATCH_PER_STREAM_OPT(frame_aspect_ratios, str, frame_aspect_ratio, oc, st);
3048 if (frame_aspect_ratio)
3049 ost->frame_aspect_ratio = parse_frame_aspect_ratio(frame_aspect_ratio);
3051 MATCH_PER_STREAM_OPT(frame_pix_fmts, str, frame_pix_fmt, oc, st);
3052 if (frame_pix_fmt && (video_enc->pix_fmt = av_get_pix_fmt(frame_pix_fmt)) == PIX_FMT_NONE) {
3053 av_log(NULL, AV_LOG_FATAL, "Unknown pixel format requested: %s.\n", frame_pix_fmt);
3056 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3058 MATCH_PER_STREAM_OPT(intra_matrices, str, intra_matrix, oc, st);
3060 if (!(video_enc->intra_matrix = av_mallocz(sizeof(*video_enc->intra_matrix) * 64))) {
3061 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for intra matrix.\n");
3064 parse_matrix_coeffs(video_enc->intra_matrix, intra_matrix);
3066 MATCH_PER_STREAM_OPT(inter_matrices, str, inter_matrix, oc, st);
3068 if (!(video_enc->inter_matrix = av_mallocz(sizeof(*video_enc->inter_matrix) * 64))) {
3069 av_log(NULL, AV_LOG_FATAL, "Could not allocate memory for inter matrix.\n");
3072 parse_matrix_coeffs(video_enc->inter_matrix, inter_matrix);
3075 MATCH_PER_STREAM_OPT(rc_overrides, str, p, oc, st);
3078 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3080 av_log(NULL, AV_LOG_FATAL, "error parsing rc_override\n");
3083 video_enc->rc_override=
3084 av_realloc(video_enc->rc_override,
3085 sizeof(RcOverride)*(i+1));
3086 video_enc->rc_override[i].start_frame= start;
3087 video_enc->rc_override[i].end_frame = end;
3089 video_enc->rc_override[i].qscale= q;
3090 video_enc->rc_override[i].quality_factor= 1.0;
3093 video_enc->rc_override[i].qscale= 0;
3094 video_enc->rc_override[i].quality_factor= -q/100.0;
3099 video_enc->rc_override_count=i;
3100 if (!video_enc->rc_initial_buffer_occupancy)
3101 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3102 video_enc->intra_dc_precision= intra_dc_precision - 8;
3107 video_enc->flags |= CODEC_FLAG_PASS1;
3109 video_enc->flags |= CODEC_FLAG_PASS2;
3113 MATCH_PER_STREAM_OPT(forced_key_frames, str, forced_key_frames, oc, st);
3114 if (forced_key_frames)
3115 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3117 MATCH_PER_STREAM_OPT(force_fps, i, force_fps, oc, st);
3118 ost->force_fps = force_fps;
3120 MATCH_PER_STREAM_OPT(top_field_first, i, top_field_first, oc, st);
3121 ost->top_field_first = top_field_first;
3124 MATCH_PER_STREAM_OPT(filters, str, filters, oc, st);
3126 ost->avfilter = av_strdup(filters);
3133 static OutputStream *new_audio_stream(OptionsContext *o, AVFormatContext *oc)
3137 AVCodecContext *audio_enc;
3139 ost = new_output_stream(o, oc, AVMEDIA_TYPE_AUDIO);
3142 audio_enc = st->codec;
3143 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3145 if (!st->stream_copy) {
3146 char *sample_fmt = NULL;
3148 MATCH_PER_STREAM_OPT(audio_channels, i, audio_enc->channels, oc, st);
3150 MATCH_PER_STREAM_OPT(sample_fmts, str, sample_fmt, oc, st);
3152 (audio_enc->sample_fmt = av_get_sample_fmt(sample_fmt)) == AV_SAMPLE_FMT_NONE) {
3153 av_log(NULL, AV_LOG_FATAL, "Invalid sample format '%s'\n", sample_fmt);
3157 MATCH_PER_STREAM_OPT(audio_sample_rate, i, audio_enc->sample_rate, oc, st);
3163 static OutputStream *new_data_stream(OptionsContext *o, AVFormatContext *oc)
3168 ost = new_output_stream(o, oc, AVMEDIA_TYPE_DATA);
3170 if (!st->stream_copy) {
3171 av_log(NULL, AV_LOG_FATAL, "Data stream encoding not supported yet (only streamcopy)\n");
3178 static OutputStream *new_attachment_stream(OptionsContext *o, AVFormatContext *oc)
3180 OutputStream *ost = new_output_stream(o, oc, AVMEDIA_TYPE_ATTACHMENT);
3181 ost->st->stream_copy = 1;
3185 static OutputStream *new_subtitle_stream(OptionsContext *o, AVFormatContext *oc)
3189 AVCodecContext *subtitle_enc;
3191 ost = new_output_stream(o, oc, AVMEDIA_TYPE_SUBTITLE);
3193 subtitle_enc = st->codec;
3195 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3200 /* arg format is "output-stream-index:streamid-value". */
3201 static int opt_streamid(OptionsContext *o, const char *opt, const char *arg)
3207 av_strlcpy(idx_str, arg, sizeof(idx_str));
3208 p = strchr(idx_str, ':');
3210 av_log(NULL, AV_LOG_FATAL,
3211 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3216 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, INT_MAX);
3217 o->streamid_map = grow_array(o->streamid_map, sizeof(*o->streamid_map), &o->nb_streamid_map, idx+1);
3218 o->streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3222 static int copy_chapters(InputFile *ifile, OutputFile *ofile, int copy_metadata)
3224 AVFormatContext *is = ifile->ctx;
3225 AVFormatContext *os = ofile->ctx;
3228 for (i = 0; i < is->nb_chapters; i++) {
3229 AVChapter *in_ch = is->chapters[i], *out_ch;
3230 int64_t ts_off = av_rescale_q(ofile->start_time - ifile->ts_offset,
3231 AV_TIME_BASE_Q, in_ch->time_base);
3232 int64_t rt = (ofile->recording_time == INT64_MAX) ? INT64_MAX :
3233 av_rescale_q(ofile->recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3236 if (in_ch->end < ts_off)
3238 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3241 out_ch = av_mallocz(sizeof(AVChapter));
3243 return AVERROR(ENOMEM);
3245 out_ch->id = in_ch->id;
3246 out_ch->time_base = in_ch->time_base;
3247 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3248 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3251 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3254 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3256 return AVERROR(ENOMEM);
3257 os->chapters[os->nb_chapters - 1] = out_ch;
3262 static int read_avserver_streams(OptionsContext *o, AVFormatContext *s, const char *filename)
3265 AVFormatContext *ic = NULL;
3267 err = avformat_open_input(&ic, filename, NULL, NULL);
3270 /* copy stream format */
3271 for(i=0;i<ic->nb_streams;i++) {
3276 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3277 ost = new_output_stream(o, s, codec->type);
3280 // FIXME: a more elegant solution is needed
3281 memcpy(st, ic->streams[i], sizeof(AVStream));
3283 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3285 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3286 choose_sample_fmt(st, codec);
3287 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3288 choose_pixel_fmt(st, codec);
3291 av_close_input_file(ic);
3295 static void opt_output_file(void *optctx, const char *filename)
3297 OptionsContext *o = optctx;
3298 AVFormatContext *oc;
3300 AVOutputFormat *file_oformat;
3304 if (!strcmp(filename, "-"))
3307 oc = avformat_alloc_context();
3309 print_error(filename, AVERROR(ENOMEM));
3314 file_oformat = av_guess_format(o->format, NULL, NULL);
3315 if (!file_oformat) {
3316 av_log(NULL, AV_LOG_FATAL, "Requested output format '%s' is not a suitable output format\n", o->format);
3320 file_oformat = av_guess_format(NULL, filename, NULL);
3321 if (!file_oformat) {
3322 av_log(NULL, AV_LOG_FATAL, "Unable to find a suitable output format for '%s'\n",
3328 oc->oformat = file_oformat;
3329 av_strlcpy(oc->filename, filename, sizeof(oc->filename));
3331 if (!strcmp(file_oformat->name, "ffm") &&
3332 av_strstart(filename, "http:", NULL)) {
3333 /* special case for files sent to avserver: we get the stream
3334 parameters from avserver */
3335 int err = read_avserver_streams(o, oc, filename);
3337 print_error(filename, err);
3340 } else if (!o->nb_stream_maps) {
3341 /* pick the "best" stream of each type */
3342 #define NEW_STREAM(type, index)\
3344 ost = new_ ## type ## _stream(o, oc);\
3345 ost->source_index = index;\
3346 ost->sync_ist = &input_streams[index];\
3347 input_streams[index].discard = 0;\
3350 /* video: highest resolution */
3351 if (!o->video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3352 int area = 0, idx = -1;
3353 for (i = 0; i < nb_input_streams; i++) {
3354 ist = &input_streams[i];
3355 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3356 ist->st->codec->width * ist->st->codec->height > area) {
3357 area = ist->st->codec->width * ist->st->codec->height;
3361 NEW_STREAM(video, idx);
3364 /* audio: most channels */
3365 if (!o->audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3366 int channels = 0, idx = -1;
3367 for (i = 0; i < nb_input_streams; i++) {
3368 ist = &input_streams[i];
3369 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3370 ist->st->codec->channels > channels) {
3371 channels = ist->st->codec->channels;
3375 NEW_STREAM(audio, idx);
3378 /* subtitles: pick first */
3379 if (!o->subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3380 for (i = 0; i < nb_input_streams; i++)
3381 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3382 NEW_STREAM(subtitle, i);
3386 /* do something with data? */
3388 for (i = 0; i < o->nb_stream_maps; i++) {
3389 StreamMap *map = &o->stream_maps[i];
3394 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3395 switch (ist->st->codec->codec_type) {
3396 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(o, oc); break;
3397 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(o, oc); break;
3398 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(o, oc); break;
3399 case AVMEDIA_TYPE_DATA: ost = new_data_stream(o, oc); break;
3400 case AVMEDIA_TYPE_ATTACHMENT: ost = new_attachment_stream(o, oc); break;
3402 av_log(NULL, AV_LOG_FATAL, "Cannot map stream #%d.%d - unsupported type.\n",
3403 map->file_index, map->stream_index);
3407 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3408 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3409 map->sync_stream_index];
3414 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3415 output_files[nb_output_files - 1].ctx = oc;
3416 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3417 output_files[nb_output_files - 1].recording_time = o->recording_time;
3418 output_files[nb_output_files - 1].start_time = o->start_time;
3419 output_files[nb_output_files - 1].limit_filesize = o->limit_filesize;
3420 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3422 /* check filename in case of an image number is expected */
3423 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3424 if (!av_filename_number_test(oc->filename)) {
3425 print_error(oc->filename, AVERROR(EINVAL));
3430 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3431 /* test if it already exists to avoid loosing precious files */
3432 if (!file_overwrite &&
3433 (strchr(filename, ':') == NULL ||
3434 filename[1] == ':' ||
3435 av_strstart(filename, "file:", NULL))) {
3436 if (avio_check(filename, 0) == 0) {
3438 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3440 if (!read_yesno()) {
3441 fprintf(stderr, "Not overwriting - exiting\n");
3446 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3453 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3454 print_error(filename, err);
3459 oc->preload = (int)(o->mux_preload * AV_TIME_BASE);
3460 oc->max_delay = (int)(o->mux_max_delay * AV_TIME_BASE);
3461 oc->flags |= AVFMT_FLAG_NONBLOCK;
3464 if (o->chapters_input_file >= nb_input_files) {
3465 if (o->chapters_input_file == INT_MAX) {
3466 /* copy chapters from the first input file that has them*/
3467 o->chapters_input_file = -1;
3468 for (i = 0; i < nb_input_files; i++)
3469 if (input_files[i].ctx->nb_chapters) {
3470 o->chapters_input_file = i;
3474 av_log(NULL, AV_LOG_FATAL, "Invalid input file index %d in chapter mapping.\n",
3475 o->chapters_input_file);
3479 if (o->chapters_input_file >= 0)
3480 copy_chapters(&input_files[o->chapters_input_file], &output_files[nb_output_files - 1],
3481 !o->metadata_chapters_manual);
3484 for (i = 0; i < o->nb_meta_data_maps; i++) {
3485 AVFormatContext *files[2];
3486 AVDictionary **meta[2];
3489 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3490 if ((index) < 0 || (index) >= (nb_elems)) {\
3491 av_log(NULL, AV_LOG_FATAL, "Invalid %s index %d while processing metadata maps\n",\
3496 int in_file_index = o->meta_data_maps[i][1].file;
3497 if (in_file_index < 0)
3499 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3502 files[1] = input_files[in_file_index].ctx;
3504 for (j = 0; j < 2; j++) {
3505 MetadataMap *map = &o->meta_data_maps[i][j];
3507 switch (map->type) {
3509 meta[j] = &files[j]->metadata;
3512 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3513 meta[j] = &files[j]->streams[map->index]->metadata;
3516 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3517 meta[j] = &files[j]->chapters[map->index]->metadata;
3520 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3521 meta[j] = &files[j]->programs[map->index]->metadata;
3526 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3529 /* copy global metadata by default */
3530 if (!o->metadata_global_manual && nb_input_files)
3531 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3532 AV_DICT_DONT_OVERWRITE);
3533 if (!o->metadata_streams_manual)
3534 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3535 InputStream *ist = &input_streams[output_streams[i].source_index];
3536 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3539 /* process manually set metadata */
3540 for (i = 0; i < o->nb_metadata; i++) {
3545 val = strchr(o->metadata[i].u.str, '=');
3547 av_log(NULL, AV_LOG_FATAL, "No '=' character in metadata string %s.\n",
3548 o->metadata[i].u.str);
3553 parse_meta_type(o->metadata[i].specifier, &type, &index);
3559 if (index < 0 || index >= oc->nb_streams) {
3560 av_log(NULL, AV_LOG_FATAL, "Invalid stream index %d in metadata specifier.\n", index);
3563 m = &oc->streams[index]->metadata;
3566 if (index < 0 || index >= oc->nb_chapters) {
3567 av_log(NULL, AV_LOG_FATAL, "Invalid chapter index %d in metadata specifier.\n", index);
3570 m = &oc->chapters[index]->metadata;
3573 av_log(NULL, AV_LOG_FATAL, "Invalid metadata specifier %s.\n", o->metadata[i].specifier);
3577 av_dict_set(m, o->metadata[i].u.str, *val ? val : NULL, 0);
3583 /* same option as mencoder */
3584 static int opt_pass(const char *opt, const char *arg)
3586 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3590 static int64_t getutime(void)
3593 struct rusage rusage;
3595 getrusage(RUSAGE_SELF, &rusage);
3596 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3597 #elif HAVE_GETPROCESSTIMES
3599 FILETIME c, e, k, u;
3600 proc = GetCurrentProcess();
3601 GetProcessTimes(proc, &c, &e, &k, &u);
3602 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3604 return av_gettime();
3608 static int64_t getmaxrss(void)
3610 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3611 struct rusage rusage;
3612 getrusage(RUSAGE_SELF, &rusage);
3613 return (int64_t)rusage.ru_maxrss * 1024;
3614 #elif HAVE_GETPROCESSMEMORYINFO
3616 PROCESS_MEMORY_COUNTERS memcounters;
3617 proc = GetCurrentProcess();
3618 memcounters.cb = sizeof(memcounters);
3619 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3620 return memcounters.PeakPagefileUsage;
3626 static int opt_audio_qscale(OptionsContext *o, const char *opt, const char *arg)
3628 return parse_option(o, "q:a", arg, options);
3631 static void show_usage(void)
3633 printf("Hyper fast Audio and Video encoder\n");
3634 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3638 static void show_help(void)
3641 AVOutputFormat *oformat = NULL;
3642 AVInputFormat *iformat = NULL;
3643 const AVClass *class;
3645 av_log_set_callback(log_callback_help);
3647 show_help_options(options, "Main options:\n",
3648 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3649 show_help_options(options, "\nAdvanced options:\n",
3650 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3652 show_help_options(options, "\nVideo options:\n",
3653 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3655 show_help_options(options, "\nAdvanced Video options:\n",
3656 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3657 OPT_VIDEO | OPT_EXPERT);
3658 show_help_options(options, "\nAudio options:\n",
3659 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3661 show_help_options(options, "\nAdvanced Audio options:\n",
3662 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3663 OPT_AUDIO | OPT_EXPERT);
3664 show_help_options(options, "\nSubtitle options:\n",
3665 OPT_SUBTITLE | OPT_GRAB,
3667 show_help_options(options, "\nAudio/Video grab options:\n",
3671 class = avcodec_get_class();
3672 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3675 /* individual codec options */
3677 while ((c = av_codec_next(c))) {
3678 if (c->priv_class) {
3679 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3684 class = avformat_get_class();
3685 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3688 /* individual muxer options */
3689 while ((oformat = av_oformat_next(oformat))) {
3690 if (oformat->priv_class) {
3691 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
3696 /* individual demuxer options */
3697 while ((iformat = av_iformat_next(iformat))) {
3698 if (iformat->priv_class) {
3699 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
3704 class = sws_get_class();
3705 av_opt_show2(&class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3708 static int opt_target(OptionsContext *o, const char *opt, const char *arg)
3710 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
3711 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
3713 if(!strncmp(arg, "pal-", 4)) {
3716 } else if(!strncmp(arg, "ntsc-", 5)) {
3719 } else if(!strncmp(arg, "film-", 5)) {
3723 /* Try to determine PAL/NTSC by peeking in the input files */
3724 if(nb_input_files) {
3726 for (j = 0; j < nb_input_files; j++) {
3727 for (i = 0; i < input_files[j].nb_streams; i++) {
3728 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
3729 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
3731 fr = c->time_base.den * 1000 / c->time_base.num;
3735 } else if((fr == 29970) || (fr == 23976)) {
3744 if (norm != UNKNOWN)
3745 av_log(NULL, AV_LOG_INFO, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
3748 if(norm == UNKNOWN) {
3749 av_log(NULL, AV_LOG_FATAL, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
3750 av_log(NULL, AV_LOG_FATAL, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
3751 av_log(NULL, AV_LOG_FATAL, "or set a framerate with \"-r xxx\".\n");
3755 if(!strcmp(arg, "vcd")) {
3756 opt_video_codec(o, "c:v", "mpeg1video");
3757 opt_audio_codec(o, "c:a", "mp2");
3758 parse_option(o, "f", "vcd", options);
3760 parse_option(o, "s", norm == PAL ? "352x288" : "352x240", options);
3761 parse_option(o, "r", frame_rates[norm], options);
3762 opt_default("g", norm == PAL ? "15" : "18");
3764 opt_default("b", "1150000");
3765 opt_default("maxrate", "1150000");
3766 opt_default("minrate", "1150000");
3767 opt_default("bufsize", "327680"); // 40*1024*8;
3769 opt_default("b:a", "224000");
3770 parse_option(o, "ar", "44100", options);
3771 parse_option(o, "ac", "2", options);
3773 opt_default("packetsize", "2324");
3774 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
3776 /* We have to offset the PTS, so that it is consistent with the SCR.
3777 SCR starts at 36000, but the first two packs contain only padding
3778 and the first pack from the other stream, respectively, may also have
3779 been written before.
3780 So the real data starts at SCR 36000+3*1200. */
3781 o->mux_preload = (36000+3*1200) / 90000.0; //0.44
3782 } else if(!strcmp(arg, "svcd")) {
3784 opt_video_codec(o, "c:v", "mpeg2video");
3785 opt_audio_codec(o, "c:a", "mp2");
3786 parse_option(o, "f", "svcd", options);
3788 parse_option(o, "s", norm == PAL ? "480x576" : "480x480", options);
3789 parse_option(o, "r", frame_rates[norm], options);
3790 opt_default("g", norm == PAL ? "15" : "18");
3792 opt_default("b", "2040000");
3793 opt_default("maxrate", "2516000");
3794 opt_default("minrate", "0"); //1145000;
3795 opt_default("bufsize", "1835008"); //224*1024*8;
3796 opt_default("flags", "+scan_offset");
3799 opt_default("b:a", "224000");
3800 parse_option(o, "ar", "44100", options);
3802 opt_default("packetsize", "2324");
3804 } else if(!strcmp(arg, "dvd")) {
3806 opt_video_codec(o, "c:v", "mpeg2video");
3807 opt_audio_codec(o, "c:a", "ac3");
3808 parse_option(o, "f", "dvd", options);
3810 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3811 parse_option(o, "r", frame_rates[norm], options);
3812 opt_default("g", norm == PAL ? "15" : "18");
3814 opt_default("b", "6000000");
3815 opt_default("maxrate", "9000000");
3816 opt_default("minrate", "0"); //1500000;
3817 opt_default("bufsize", "1835008"); //224*1024*8;
3819 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
3820 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
3822 opt_default("b:a", "448000");
3823 parse_option(o, "ar", "48000", options);
3825 } else if(!strncmp(arg, "dv", 2)) {
3827 parse_option(o, "f", "dv", options);
3829 parse_option(o, "s", norm == PAL ? "720x576" : "720x480", options);
3830 parse_option(o, "pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
3831 norm == PAL ? "yuv420p" : "yuv411p", options);
3832 parse_option(o, "r", frame_rates[norm], options);
3834 parse_option(o, "ar", "48000", options);
3835 parse_option(o, "ac", "2", options);
3838 av_log(NULL, AV_LOG_ERROR, "Unknown target: %s\n", arg);
3839 return AVERROR(EINVAL);
3844 static int opt_vstats_file(const char *opt, const char *arg)
3846 av_free (vstats_filename);
3847 vstats_filename=av_strdup (arg);
3851 static int opt_vstats(const char *opt, const char *arg)
3854 time_t today2 = time(NULL);
3855 struct tm *today = localtime(&today2);
3857 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
3859 return opt_vstats_file(opt, filename);
3862 static int opt_video_frames(OptionsContext *o, const char *opt, const char *arg)
3864 return parse_option(o, "frames:v", arg, options);
3867 static int opt_audio_frames(OptionsContext *o, const char *opt, const char *arg)
3869 return parse_option(o, "frames:a", arg, options);
3872 static int opt_data_frames(OptionsContext *o, const char *opt, const char *arg)
3874 return parse_option(o, "frames:d", arg, options);
3877 static int opt_video_tag(OptionsContext *o, const char *opt, const char *arg)
3879 return parse_option(o, "tag:v", arg, options);
3882 static int opt_audio_tag(OptionsContext *o, const char *opt, const char *arg)
3884 return parse_option(o, "tag:a", arg, options);
3887 static int opt_subtitle_tag(OptionsContext *o, const char *opt, const char *arg)
3889 return parse_option(o, "tag:s", arg, options);
3892 static int opt_video_filters(OptionsContext *o, const char *opt, const char *arg)
3894 return parse_option(o, "filter:v", arg, options);
3897 #define OFFSET(x) offsetof(OptionsContext, x)
3898 static const OptionDef options[] = {
3900 #include "cmdutils_common_opts.h"
3901 { "f", HAS_ARG | OPT_STRING | OPT_OFFSET, {.off = OFFSET(format)}, "force format", "fmt" },
3902 { "i", HAS_ARG | OPT_FUNC2, {(void*)opt_input_file}, "input file name", "filename" },
3903 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
3904 { "c", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3905 { "codec", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(codec_names)}, "codec name", "codec" },
3906 { "map", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
3907 { "map_metadata", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
3908 "outfile[,metadata]:infile[,metadata]" },
3909 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(chapters_input_file)}, "set chapters mapping", "input_file_index" },
3910 { "t", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(recording_time)}, "record or transcode \"duration\" seconds of audio/video", "duration" },
3911 { "fs", HAS_ARG | OPT_INT64 | OPT_OFFSET, {.off = OFFSET(limit_filesize)}, "set the limit file size in bytes", "limit_size" }, //
3912 { "ss", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(start_time)}, "set the start time offset", "time_off" },
3913 { "itsoffset", HAS_ARG | OPT_TIME | OPT_OFFSET, {.off = OFFSET(input_ts_offset)}, "set the input ts offset", "time_off" },
3914 { "itsscale", HAS_ARG | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(ts_scale)}, "set the input ts scale", "scale" },
3915 { "metadata", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(metadata)}, "add metadata", "string=string" },
3916 { "dframes", HAS_ARG | OPT_FUNC2, {(void*)opt_data_frames}, "set the number of data frames to record", "number" },
3917 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
3918 "add timings for benchmarking" },
3919 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
3920 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
3921 "dump each input packet" },
3922 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
3923 "when dumping packets, also dump the payload" },
3924 { "re", OPT_BOOL | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(rate_emu)}, "read input at native frame rate", "" },
3925 { "v", HAS_ARG, {(void*)opt_verbose}, "deprecated, use -loglevel instead", "number" },
3926 { "target", HAS_ARG | OPT_FUNC2, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
3927 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
3928 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
3929 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
3930 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
3931 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
3932 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
3933 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
3934 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
3935 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
3936 { "frames", OPT_INT64 | HAS_ARG | OPT_SPEC, {.off = OFFSET(max_frames)}, "set the number of frames to record", "number" },
3937 { "tag", OPT_STRING | HAS_ARG | OPT_SPEC, {.off = OFFSET(codec_tags)}, "force codec tag/fourcc", "fourcc/tag" },
3938 { "q", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
3939 { "qscale", HAS_ARG | OPT_EXPERT | OPT_DOUBLE | OPT_SPEC, {.off = OFFSET(qscale)}, "use fixed quality scale (VBR)", "q" },
3941 { "filter", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(filters)}, "set stream filterchain", "filter_list" },
3945 { "vframes", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_frames}, "set the number of video frames to record", "number" },
3946 { "r", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_rates)}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
3947 { "s", HAS_ARG | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_sizes)}, "set frame size (WxH or abbreviation)", "size" },
3948 { "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" },
3949 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(frame_pix_fmts)}, "set pixel format", "format" },
3950 { "vn", OPT_BOOL | OPT_VIDEO | OPT_OFFSET, {.off = OFFSET(video_disable)}, "disable video" },
3951 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
3952 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(rc_overrides)}, "rate control override for specific intervals", "override" },
3953 { "vcodec", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
3954 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant},
3955 "use same quantizer as source (implies VBR)" },
3956 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
3957 { "passlogfile", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void*)&pass_logfilename_prefix}, "select two pass log file name prefix", "prefix" },
3958 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
3959 "deinterlace pictures" },
3960 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
3961 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
3963 { "vf", HAS_ARG | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_filters}, "video filters", "filter list" },
3965 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(intra_matrices)}, "specify intra matrix coeffs", "matrix" },
3966 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_STRING | OPT_SPEC, {.off = OFFSET(inter_matrices)}, "specify inter matrix coeffs", "matrix" },
3967 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_INT| OPT_SPEC, {.off = OFFSET(top_field_first)}, "top=1/bottom=0/auto=-1 field first", "" },
3968 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
3969 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_FUNC2, {(void*)opt_video_tag}, "force video tag/fourcc", "fourcc/tag" },
3970 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
3971 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO | OPT_SPEC, {.off = OFFSET(force_fps)}, "force the selected framerate, disable the best supported framerate selection" },
3972 { "streamid", HAS_ARG | OPT_EXPERT | OPT_FUNC2, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
3973 { "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" },
3976 { "aframes", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_frames}, "set the number of audio frames to record", "number" },
3977 { "aq", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_qscale}, "set audio quality (codec-specific)", "quality", },
3978 { "ar", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_sample_rate)}, "set audio sampling rate (in Hz)", "rate" },
3979 { "ac", HAS_ARG | OPT_AUDIO | OPT_INT | OPT_SPEC, {.off = OFFSET(audio_channels)}, "set number of audio channels", "channels" },
3980 { "an", OPT_BOOL | OPT_AUDIO | OPT_OFFSET, {.off = OFFSET(audio_disable)}, "disable audio" },
3981 { "acodec", HAS_ARG | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
3982 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_FUNC2, {(void*)opt_audio_tag}, "force audio tag/fourcc", "fourcc/tag" },
3983 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
3984 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO | OPT_SPEC | OPT_STRING, {.off = OFFSET(sample_fmts)}, "set sample format", "format" },
3986 /* subtitle options */
3987 { "sn", OPT_BOOL | OPT_SUBTITLE | OPT_OFFSET, {.off = OFFSET(subtitle_disable)}, "disable subtitle" },
3988 { "scodec", HAS_ARG | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
3989 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE | OPT_FUNC2, {(void*)opt_subtitle_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
3992 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
3995 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_max_delay)}, "set the maximum demux-decode delay", "seconds" },
3996 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT | OPT_OFFSET, {.off = OFFSET(mux_preload)}, "set the initial demux-decode delay", "seconds" },
3998 { "bsf", HAS_ARG | OPT_STRING | OPT_SPEC, {.off = OFFSET(bitstream_filters)}, "A comma-separated list of bitstream filters", "bitstream_filters" },
4000 /* data codec support */
4001 { "dcodec", HAS_ARG | OPT_DATA | OPT_FUNC2, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4003 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4007 int main(int argc, char **argv)
4009 OptionsContext o = { 0 };
4014 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4015 parse_loglevel(argc, argv, options);
4017 avcodec_register_all();
4019 avdevice_register_all();
4022 avfilter_register_all();
4026 avio_set_interrupt_cb(decode_interrupt_cb);
4031 parse_options(&o, argc, argv, options, opt_output_file);
4033 if(nb_output_files <= 0 && nb_input_files == 0) {
4035 av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4039 /* file converter / grab */
4040 if (nb_output_files <= 0) {
4041 fprintf(stderr, "At least one output file must be specified\n");
4045 if (nb_input_files == 0) {
4046 av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4051 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4053 ti = getutime() - ti;
4055 int maxrss = getmaxrss() / 1024;
4056 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);