3 * Copyright (c) 2000-2003 Fabrice Bellard
5 * This file is part of FFmpeg.
7 * FFmpeg 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 * FFmpeg 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 FFmpeg; 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"
49 #include "libavformat/ffm.h" // not public API
52 # include "libavfilter/avcodec.h"
53 # include "libavfilter/avfilter.h"
54 # include "libavfilter/avfiltergraph.h"
55 # include "libavfilter/vsink_buffer.h"
56 # include "libavfilter/vsrc_buffer.h"
59 #if HAVE_SYS_RESOURCE_H
60 #include <sys/types.h>
62 #include <sys/resource.h>
63 #elif HAVE_GETPROCESSTIMES
66 #if HAVE_GETPROCESSMEMORYINFO
72 #include <sys/select.h>
77 #include <sys/ioctl.h>
87 #include "libavutil/avassert.h"
89 const char program_name[] = "ffmpeg";
90 const int program_birth_year = 2000;
92 /* select an input stream for an output stream */
93 typedef struct StreamMap {
94 int disabled; /** 1 is this mapping is disabled by a negative map */
98 int sync_stream_index;
102 * select an input file for an output file
104 typedef struct MetadataMap {
105 int file; ///< file index
106 char type; ///< type of metadata to copy -- (g)lobal, (s)tream, (c)hapter or (p)rogram
107 int index; ///< stream/chapter/program number
110 static const OptionDef options[];
112 #define MAX_STREAMS 1024 /* arbitrary sanity check value */
113 static const char *last_asked_format = NULL;
114 static AVDictionary *ts_scale;
116 static StreamMap *stream_maps = NULL;
117 static int nb_stream_maps;
119 static AVDictionary *codec_names;
121 /* first item specifies output metadata, second is input */
122 static MetadataMap (*meta_data_maps)[2] = NULL;
123 static int nb_meta_data_maps;
124 static int metadata_global_autocopy = 1;
125 static int metadata_streams_autocopy = 1;
126 static int metadata_chapters_autocopy = 1;
128 static int chapters_input_file = INT_MAX;
130 /* indexed by output file stream index */
131 static int *streamid_map = NULL;
132 static int nb_streamid_map = 0;
134 static int frame_width = 0;
135 static int frame_height = 0;
136 static float frame_aspect_ratio = 0;
137 static enum PixelFormat frame_pix_fmt = PIX_FMT_NONE;
138 static int frame_bits_per_raw_sample = 0;
139 static enum AVSampleFormat audio_sample_fmt = AV_SAMPLE_FMT_NONE;
140 static int max_frames[4] = {INT_MAX, INT_MAX, INT_MAX, INT_MAX};
141 static AVRational frame_rate;
142 static float video_qscale = 0;
143 static uint16_t *intra_matrix = NULL;
144 static uint16_t *inter_matrix = NULL;
145 static const char *video_rc_override_string=NULL;
146 static int video_disable = 0;
147 static int video_discard = 0;
148 static unsigned int video_codec_tag = 0;
149 static char *video_language = NULL;
150 static int same_quant = 0;
151 static int do_deinterlace = 0;
152 static int top_field_first = -1;
153 static int me_threshold = 0;
154 static int intra_dc_precision = 8;
155 static int loop_input = 0;
156 static int loop_output = AVFMT_NOOUTPUTLOOP;
157 static int qp_hist = 0;
159 static char *vfilters = NULL;
162 static int intra_only = 0;
163 static int audio_sample_rate = 0;
164 #define QSCALE_NONE -99999
165 static float audio_qscale = QSCALE_NONE;
166 static int audio_disable = 0;
167 static int audio_channels = 0;
168 static unsigned int audio_codec_tag = 0;
169 static char *audio_language = NULL;
171 static int subtitle_disable = 0;
172 static char *subtitle_language = NULL;
173 static unsigned int subtitle_codec_tag = 0;
175 static int data_disable = 0;
176 static unsigned int data_codec_tag = 0;
178 static float mux_preload= 0.5;
179 static float mux_max_delay= 0.7;
181 static int64_t recording_time = INT64_MAX;
182 static int64_t start_time = 0;
183 static int64_t input_ts_offset = 0;
184 static int file_overwrite = 0;
185 static AVDictionary *metadata;
186 static int do_benchmark = 0;
187 static int do_hex_dump = 0;
188 static int do_pkt_dump = 0;
189 static int do_psnr = 0;
190 static int do_pass = 0;
191 static const char *pass_logfilename_prefix;
192 static int video_sync_method= -1;
193 static int audio_sync_method= 0;
194 static float audio_drift_threshold= 0.1;
195 static int copy_ts= 0;
196 static int copy_tb= 0;
197 static int opt_shortest = 0;
198 static char *vstats_filename;
199 static FILE *vstats_file;
200 static int opt_programid = 0;
201 static int copy_initial_nonkeyframes = 0;
203 static int rate_emu = 0;
205 static int audio_volume = 256;
207 static int exit_on_error = 0;
208 static int using_stdin = 0;
209 static int verbose = 1;
210 static int run_as_daemon = 0;
211 static int thread_count= 1;
212 static int q_pressed = 0;
213 static int64_t video_size = 0;
214 static int64_t audio_size = 0;
215 static int64_t extra_size = 0;
216 static int nb_frames_dup = 0;
217 static int nb_frames_drop = 0;
218 static int input_sync;
219 static uint64_t limit_filesize = 0;
220 static int force_fps = 0;
221 static char *forced_key_frames = NULL;
223 static float dts_delta_threshold = 10;
225 static uint8_t *audio_buf;
226 static uint8_t *audio_out;
227 static unsigned int allocated_audio_out_size, allocated_audio_buf_size;
229 static short *samples;
231 static AVBitStreamFilterContext *video_bitstream_filters=NULL;
232 static AVBitStreamFilterContext *audio_bitstream_filters=NULL;
233 static AVBitStreamFilterContext *subtitle_bitstream_filters=NULL;
235 #define DEFAULT_PASS_LOGFILENAME_PREFIX "ffmpeg2pass"
237 typedef struct InputStream {
240 int discard; /* true if stream data should be discarded */
241 int decoding_needed; /* true if the packets must be decoded in 'raw_fifo' */
244 int64_t start; /* time when read started */
245 int64_t next_pts; /* synthetic pts for cases where pkt.pts
247 int64_t pts; /* current pts */
249 int is_start; /* is 1 at the start and after a discontinuity */
250 int showed_multi_packet_warning;
254 typedef struct InputFile {
255 AVFormatContext *ctx;
256 int eof_reached; /* true if eof reached */
257 int ist_index; /* index of first stream in ist_table */
258 int buffer_size; /* current total buffer size */
263 typedef struct OutputStream {
264 int file_index; /* file index */
265 int index; /* stream index in the output file */
266 int source_index; /* InputStream index */
267 AVStream *st; /* stream in the output file */
268 int encoding_needed; /* true if encoding needed for this stream */
270 /* input pts and corresponding output pts
272 //double sync_ipts; /* dts from the AVPacket of the demuxer in second units */
273 struct InputStream *sync_ist; /* input stream to sync against */
274 int64_t sync_opts; /* output frame counter, could be changed to some true timestamp */ //FIXME look at frame_number
275 AVBitStreamFilterContext *bitstream_filters;
280 AVFrame resample_frame; /* temporary frame for image resampling */
281 struct SwsContext *img_resample_ctx; /* for image resampling */
284 int resample_pix_fmt;
285 AVRational frame_rate;
287 float frame_aspect_ratio;
289 /* forced key frames */
290 int64_t *forced_kf_pts;
296 ReSampleContext *resample; /* for audio resampling */
297 int resample_sample_fmt;
298 int resample_channels;
299 int resample_sample_rate;
301 AVAudioConvert *reformat_ctx;
302 AVFifoBuffer *fifo; /* for compression: one audio fifo per codec */
306 AVFilterContext *output_video_filter;
307 AVFilterContext *input_video_filter;
308 AVFilterBufferRef *picref;
310 AVFilterGraph *graph;
315 int is_past_recording_time;
321 /* init terminal so that we can grab keys */
322 static struct termios oldtty;
325 typedef struct OutputFile {
326 AVFormatContext *ctx;
328 int ost_index; /* index of the first stream in output_streams */
329 int64_t recording_time; /* desired length of the resulting file in microseconds */
330 int64_t start_time; /* start time in microseconds */
333 static InputStream *input_streams = NULL;
334 static int nb_input_streams = 0;
335 static InputFile *input_files = NULL;
336 static int nb_input_files = 0;
338 static OutputStream *output_streams = NULL;
339 static int nb_output_streams = 0;
340 static OutputFile *output_files = NULL;
341 static int nb_output_files = 0;
345 static int configure_video_filters(InputStream *ist, OutputStream *ost)
347 AVFilterContext *last_filter, *filter;
348 /** filter graph containing all filters including input & output */
349 AVCodecContext *codec = ost->st->codec;
350 AVCodecContext *icodec = ist->st->codec;
351 enum PixelFormat pix_fmts[] = { codec->pix_fmt, PIX_FMT_NONE };
352 AVRational sample_aspect_ratio;
356 ost->graph = avfilter_graph_alloc();
358 if (ist->st->sample_aspect_ratio.num){
359 sample_aspect_ratio = ist->st->sample_aspect_ratio;
361 sample_aspect_ratio = ist->st->codec->sample_aspect_ratio;
363 snprintf(args, 255, "%d:%d:%d:%d:%d:%d:%d", ist->st->codec->width,
364 ist->st->codec->height, ist->st->codec->pix_fmt, 1, AV_TIME_BASE,
365 sample_aspect_ratio.num, sample_aspect_ratio.den);
367 ret = avfilter_graph_create_filter(&ost->input_video_filter, avfilter_get_by_name("buffer"),
368 "src", args, NULL, ost->graph);
371 ret = avfilter_graph_create_filter(&ost->output_video_filter, avfilter_get_by_name("buffersink"),
372 "out", NULL, pix_fmts, ost->graph);
375 last_filter = ost->input_video_filter;
377 if (codec->width != icodec->width || codec->height != icodec->height) {
378 snprintf(args, 255, "%d:%d:flags=0x%X",
382 if ((ret = avfilter_graph_create_filter(&filter, avfilter_get_by_name("scale"),
383 NULL, args, NULL, ost->graph)) < 0)
385 if ((ret = avfilter_link(last_filter, 0, filter, 0)) < 0)
387 last_filter = filter;
390 snprintf(args, sizeof(args), "flags=0x%X", ost->sws_flags);
391 ost->graph->scale_sws_opts = av_strdup(args);
394 AVFilterInOut *outputs = avfilter_inout_alloc();
395 AVFilterInOut *inputs = avfilter_inout_alloc();
397 outputs->name = av_strdup("in");
398 outputs->filter_ctx = last_filter;
399 outputs->pad_idx = 0;
400 outputs->next = NULL;
402 inputs->name = av_strdup("out");
403 inputs->filter_ctx = ost->output_video_filter;
407 if ((ret = avfilter_graph_parse(ost->graph, ost->avfilter, &inputs, &outputs, NULL)) < 0)
409 av_freep(&ost->avfilter);
411 if ((ret = avfilter_link(last_filter, 0, ost->output_video_filter, 0)) < 0)
415 if ((ret = avfilter_graph_config(ost->graph, NULL)) < 0)
418 codec->width = ost->output_video_filter->inputs[0]->w;
419 codec->height = ost->output_video_filter->inputs[0]->h;
420 codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
421 ost->frame_aspect_ratio ? // overridden by the -aspect cli option
422 av_d2q(ost->frame_aspect_ratio*codec->height/codec->width, 255) :
423 ost->output_video_filter->inputs[0]->sample_aspect_ratio;
427 #endif /* CONFIG_AVFILTER */
429 static void term_exit(void)
431 av_log(NULL, AV_LOG_QUIET, "%s", "");
434 tcsetattr (0, TCSANOW, &oldtty);
438 static volatile int received_sigterm = 0;
441 sigterm_handler(int sig)
443 received_sigterm = sig;
448 static void term_init(void)
458 tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
459 |INLCR|IGNCR|ICRNL|IXON);
460 tty.c_oflag |= OPOST;
461 tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
462 tty.c_cflag &= ~(CSIZE|PARENB);
467 tcsetattr (0, TCSANOW, &tty);
468 signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
472 signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
473 signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
475 signal(SIGXCPU, sigterm_handler);
479 /* read a key without blocking */
480 static int read_key(void)
495 n = select(1, &rfds, NULL, NULL, &tv);
510 static int decode_interrupt_cb(void)
512 q_pressed += read_key() == 'q';
513 return q_pressed > 1;
516 static int exit_program(int ret)
521 for(i=0;i<nb_output_files;i++) {
522 AVFormatContext *s = output_files[i].ctx;
523 if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
525 avformat_free_context(s);
526 av_dict_free(&output_files[i].opts);
528 for(i=0;i<nb_input_files;i++) {
529 av_close_input_file(input_files[i].ctx);
531 for (i = 0; i < nb_input_streams; i++)
532 av_dict_free(&input_streams[i].opts);
534 av_free(intra_matrix);
535 av_free(inter_matrix);
539 av_free(vstats_filename);
541 av_free(meta_data_maps);
543 av_freep(&input_streams);
544 av_freep(&input_files);
545 av_freep(&output_streams);
546 av_freep(&output_files);
551 allocated_audio_buf_size= allocated_audio_out_size= 0;
558 if (received_sigterm) {
560 "Received signal %d: terminating.\n",
561 (int) received_sigterm);
565 exit(ret); /* not all OS-es handle main() return value */
569 static void assert_avoptions(AVDictionary *m)
571 AVDictionaryEntry *t;
572 if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
573 av_log(NULL, AV_LOG_ERROR, "Option %s not found.\n", t->key);
578 static void assert_codec_experimental(AVCodecContext *c, int encoder)
580 const char *codec_string = encoder ? "encoder" : "decoder";
582 if (c->codec->capabilities & CODEC_CAP_EXPERIMENTAL &&
583 c->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
584 av_log(NULL, AV_LOG_ERROR, "%s '%s' is experimental and might produce bad "
585 "results.\nAdd '-strict experimental' if you want to use it.\n",
586 codec_string, c->codec->name);
587 codec = encoder ? avcodec_find_encoder(c->codec->id) : avcodec_find_decoder(c->codec->id);
588 if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
589 av_log(NULL, AV_LOG_ERROR, "Or use the non experimental %s '%s'.\n",
590 codec_string, codec->name);
595 /* similar to ff_dynarray_add() and av_fast_realloc() */
596 static void *grow_array(void *array, int elem_size, int *size, int new_size)
598 if (new_size >= INT_MAX / elem_size) {
599 fprintf(stderr, "Array too big.\n");
602 if (*size < new_size) {
603 uint8_t *tmp = av_realloc(array, new_size*elem_size);
605 fprintf(stderr, "Could not alloc buffer.\n");
608 memset(tmp + *size*elem_size, 0, (new_size-*size) * elem_size);
615 static void choose_sample_fmt(AVStream *st, AVCodec *codec)
617 if(codec && codec->sample_fmts){
618 const enum AVSampleFormat *p= codec->sample_fmts;
620 if(*p == st->codec->sample_fmt)
624 if((codec->capabilities & CODEC_CAP_LOSSLESS) && av_get_sample_fmt_name(st->codec->sample_fmt) > av_get_sample_fmt_name(codec->sample_fmts[0]))
625 av_log(NULL, AV_LOG_ERROR, "Convertion will not be lossless'\n");
626 if(av_get_sample_fmt_name(st->codec->sample_fmt))
627 av_log(NULL, AV_LOG_WARNING,
628 "Incompatible sample format '%s' for codec '%s', auto-selecting format '%s'\n",
629 av_get_sample_fmt_name(st->codec->sample_fmt),
631 av_get_sample_fmt_name(codec->sample_fmts[0]));
632 st->codec->sample_fmt = codec->sample_fmts[0];
637 static void choose_sample_rate(AVStream *st, AVCodec *codec)
639 if(codec && codec->supported_samplerates){
640 const int *p= codec->supported_samplerates;
642 int best_dist=INT_MAX;
644 int dist= abs(st->codec->sample_rate - *p);
645 if(dist < best_dist){
651 av_log(st->codec, AV_LOG_WARNING, "Requested sampling rate unsupported using closest supported (%d)\n", best);
653 st->codec->sample_rate= best;
657 static void choose_pixel_fmt(AVStream *st, AVCodec *codec)
659 if(codec && codec->pix_fmts){
660 const enum PixelFormat *p= codec->pix_fmts;
661 if(st->codec->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL){
662 if(st->codec->codec_id==CODEC_ID_MJPEG){
663 p= (const enum PixelFormat[]){PIX_FMT_YUVJ420P, PIX_FMT_YUVJ422P, PIX_FMT_YUV420P, PIX_FMT_YUV422P, PIX_FMT_NONE};
664 }else if(st->codec->codec_id==CODEC_ID_LJPEG){
665 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};
669 if(*p == st->codec->pix_fmt)
673 if(st->codec->pix_fmt != PIX_FMT_NONE)
674 av_log(NULL, AV_LOG_WARNING,
675 "Incompatible pixel format '%s' for codec '%s', auto-selecting format '%s'\n",
676 av_pix_fmt_descriptors[st->codec->pix_fmt].name,
678 av_pix_fmt_descriptors[codec->pix_fmts[0]].name);
679 st->codec->pix_fmt = codec->pix_fmts[0];
685 get_sync_ipts(const OutputStream *ost)
687 const InputStream *ist = ost->sync_ist;
688 OutputFile *of = &output_files[ost->file_index];
689 return (double)(ist->pts - of->start_time)/AV_TIME_BASE;
692 static void write_frame(AVFormatContext *s, AVPacket *pkt, AVCodecContext *avctx, AVBitStreamFilterContext *bsfc){
696 AVPacket new_pkt= *pkt;
697 int a= av_bitstream_filter_filter(bsfc, avctx, NULL,
698 &new_pkt.data, &new_pkt.size,
699 pkt->data, pkt->size,
700 pkt->flags & AV_PKT_FLAG_KEY);
703 new_pkt.destruct= av_destruct_packet;
705 fprintf(stderr, "%s failed for stream %d, codec %s",
706 bsfc->filter->name, pkt->stream_index,
707 avctx->codec ? avctx->codec->name : "copy");
717 ret= av_interleaved_write_frame(s, pkt);
719 print_error("av_interleaved_write_frame()", ret);
724 static void do_audio_out(AVFormatContext *s,
727 unsigned char *buf, int size)
730 int64_t audio_out_size, audio_buf_size;
731 int64_t allocated_for_size= size;
733 int size_out, frame_bytes, ret, resample_changed;
734 AVCodecContext *enc= ost->st->codec;
735 AVCodecContext *dec= ist->st->codec;
736 int osize = av_get_bytes_per_sample(enc->sample_fmt);
737 int isize = av_get_bytes_per_sample(dec->sample_fmt);
738 const int coded_bps = av_get_bits_per_sample(enc->codec->id);
741 audio_buf_size= (allocated_for_size + isize*dec->channels - 1) / (isize*dec->channels);
742 audio_buf_size= (audio_buf_size*enc->sample_rate + dec->sample_rate) / dec->sample_rate;
743 audio_buf_size= audio_buf_size*2 + 10000; //safety factors for the deprecated resampling API
744 audio_buf_size= FFMAX(audio_buf_size, enc->frame_size);
745 audio_buf_size*= osize*enc->channels;
747 audio_out_size= FFMAX(audio_buf_size, enc->frame_size * osize * enc->channels);
748 if(coded_bps > 8*osize)
749 audio_out_size= audio_out_size * coded_bps / (8*osize);
750 audio_out_size += FF_MIN_BUFFER_SIZE;
752 if(audio_out_size > INT_MAX || audio_buf_size > INT_MAX){
753 fprintf(stderr, "Buffer sizes too large\n");
757 av_fast_malloc(&audio_buf, &allocated_audio_buf_size, audio_buf_size);
758 av_fast_malloc(&audio_out, &allocated_audio_out_size, audio_out_size);
759 if (!audio_buf || !audio_out){
760 fprintf(stderr, "Out of memory in do_audio_out\n");
764 if (enc->channels != dec->channels)
765 ost->audio_resample = 1;
767 resample_changed = ost->resample_sample_fmt != dec->sample_fmt ||
768 ost->resample_channels != dec->channels ||
769 ost->resample_sample_rate != dec->sample_rate;
771 if ((ost->audio_resample && !ost->resample) || resample_changed) {
772 if (resample_changed) {
773 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",
774 ist->file_index, ist->st->index,
775 ost->resample_sample_rate, av_get_sample_fmt_name(ost->resample_sample_fmt), ost->resample_channels,
776 dec->sample_rate, av_get_sample_fmt_name(dec->sample_fmt), dec->channels);
777 ost->resample_sample_fmt = dec->sample_fmt;
778 ost->resample_channels = dec->channels;
779 ost->resample_sample_rate = dec->sample_rate;
781 audio_resample_close(ost->resample);
783 /* if audio_sync_method is >1 the resampler is needed for audio drift compensation */
784 if (audio_sync_method <= 1 &&
785 ost->resample_sample_fmt == enc->sample_fmt &&
786 ost->resample_channels == enc->channels &&
787 ost->resample_sample_rate == enc->sample_rate) {
788 ost->resample = NULL;
789 ost->audio_resample = 0;
791 if (dec->sample_fmt != AV_SAMPLE_FMT_S16)
792 fprintf(stderr, "Warning, using s16 intermediate sample format for resampling\n");
793 ost->resample = av_audio_resample_init(enc->channels, dec->channels,
794 enc->sample_rate, dec->sample_rate,
795 enc->sample_fmt, dec->sample_fmt,
797 if (!ost->resample) {
798 fprintf(stderr, "Can not resample %d channels @ %d Hz to %d channels @ %d Hz\n",
799 dec->channels, dec->sample_rate,
800 enc->channels, enc->sample_rate);
806 #define MAKE_SFMT_PAIR(a,b) ((a)+AV_SAMPLE_FMT_NB*(b))
807 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt &&
808 MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt)!=ost->reformat_pair) {
809 if (ost->reformat_ctx)
810 av_audio_convert_free(ost->reformat_ctx);
811 ost->reformat_ctx = av_audio_convert_alloc(enc->sample_fmt, 1,
812 dec->sample_fmt, 1, NULL, 0);
813 if (!ost->reformat_ctx) {
814 fprintf(stderr, "Cannot convert %s sample format to %s sample format\n",
815 av_get_sample_fmt_name(dec->sample_fmt),
816 av_get_sample_fmt_name(enc->sample_fmt));
819 ost->reformat_pair=MAKE_SFMT_PAIR(enc->sample_fmt,dec->sample_fmt);
822 if(audio_sync_method){
823 double delta = get_sync_ipts(ost) * enc->sample_rate - ost->sync_opts
824 - av_fifo_size(ost->fifo)/(enc->channels * 2);
825 double idelta= delta*dec->sample_rate / enc->sample_rate;
826 int byte_delta= ((int)idelta)*2*dec->channels;
828 //FIXME resample delay
829 if(fabs(delta) > 50){
830 if(ist->is_start || fabs(delta) > audio_drift_threshold*enc->sample_rate){
832 byte_delta= FFMAX(byte_delta, -size);
836 fprintf(stderr, "discarding %d audio samples\n", (int)-delta);
841 static uint8_t *input_tmp= NULL;
842 input_tmp= av_realloc(input_tmp, byte_delta + size);
844 if(byte_delta > allocated_for_size - size){
845 allocated_for_size= byte_delta + (int64_t)size;
850 memset(input_tmp, 0, byte_delta);
851 memcpy(input_tmp + byte_delta, buf, size);
855 fprintf(stderr, "adding %d audio samples of silence\n", (int)delta);
857 }else if(audio_sync_method>1){
858 int comp= av_clip(delta, -audio_sync_method, audio_sync_method);
859 av_assert0(ost->audio_resample);
861 fprintf(stderr, "compensating audio timestamp drift:%f compensation:%d in:%d\n", delta, comp, enc->sample_rate);
862 // 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));
863 av_resample_compensate(*(struct AVResampleContext**)ost->resample, comp, enc->sample_rate);
867 ost->sync_opts= lrintf(get_sync_ipts(ost) * enc->sample_rate)
868 - av_fifo_size(ost->fifo)/(enc->channels * 2); //FIXME wrong
870 if (ost->audio_resample) {
872 size_out = audio_resample(ost->resample,
873 (short *)buftmp, (short *)buf,
874 size / (dec->channels * isize));
875 size_out = size_out * enc->channels * osize;
881 if (!ost->audio_resample && dec->sample_fmt!=enc->sample_fmt) {
882 const void *ibuf[6]= {buftmp};
883 void *obuf[6]= {audio_buf};
884 int istride[6]= {isize};
885 int ostride[6]= {osize};
886 int len= size_out/istride[0];
887 if (av_audio_convert(ost->reformat_ctx, obuf, ostride, ibuf, istride, len)<0) {
888 printf("av_audio_convert() failed\n");
894 size_out = len*osize;
897 /* now encode as many frames as possible */
898 if (enc->frame_size > 1) {
899 /* output resampled raw samples */
900 if (av_fifo_realloc2(ost->fifo, av_fifo_size(ost->fifo) + size_out) < 0) {
901 fprintf(stderr, "av_fifo_realloc2() failed\n");
904 av_fifo_generic_write(ost->fifo, buftmp, size_out, NULL);
906 frame_bytes = enc->frame_size * osize * enc->channels;
908 while (av_fifo_size(ost->fifo) >= frame_bytes) {
910 av_init_packet(&pkt);
912 av_fifo_generic_read(ost->fifo, audio_buf, frame_bytes, NULL);
914 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
916 ret = avcodec_encode_audio(enc, audio_out, audio_out_size,
919 fprintf(stderr, "Audio encoding failed\n");
923 pkt.stream_index= ost->index;
926 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
927 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
928 pkt.flags |= AV_PKT_FLAG_KEY;
929 write_frame(s, &pkt, enc, ost->bitstream_filters);
931 ost->sync_opts += enc->frame_size;
935 av_init_packet(&pkt);
937 ost->sync_opts += size_out / (osize * enc->channels);
939 /* output a pcm frame */
940 /* determine the size of the coded buffer */
943 size_out = size_out*coded_bps/8;
945 if(size_out > audio_out_size){
946 fprintf(stderr, "Internal error, buffer size too small\n");
950 //FIXME pass ost->sync_opts as AVFrame.pts in avcodec_encode_audio()
951 ret = avcodec_encode_audio(enc, audio_out, size_out,
954 fprintf(stderr, "Audio encoding failed\n");
958 pkt.stream_index= ost->index;
961 if(enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
962 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
963 pkt.flags |= AV_PKT_FLAG_KEY;
964 write_frame(s, &pkt, enc, ost->bitstream_filters);
968 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
972 AVPicture picture_tmp;
975 dec = ist->st->codec;
977 /* deinterlace : must be done before any resize */
978 if (do_deinterlace) {
981 /* create temporary picture */
982 size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
983 buf = av_malloc(size);
987 picture2 = &picture_tmp;
988 avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
990 if(avpicture_deinterlace(picture2, picture,
991 dec->pix_fmt, dec->width, dec->height) < 0) {
992 /* if error, do not deinterlace */
993 fprintf(stderr, "Deinterlacing failed\n");
1002 if (picture != picture2)
1003 *picture = *picture2;
1007 static void do_subtitle_out(AVFormatContext *s,
1013 static uint8_t *subtitle_out = NULL;
1014 int subtitle_out_max_size = 1024 * 1024;
1015 int subtitle_out_size, nb, i;
1016 AVCodecContext *enc;
1019 if (pts == AV_NOPTS_VALUE) {
1020 fprintf(stderr, "Subtitle packets must have a pts\n");
1026 enc = ost->st->codec;
1028 if (!subtitle_out) {
1029 subtitle_out = av_malloc(subtitle_out_max_size);
1032 /* Note: DVB subtitle need one packet to draw them and one other
1033 packet to clear them */
1034 /* XXX: signal it in the codec context ? */
1035 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE)
1040 for(i = 0; i < nb; i++) {
1041 sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
1042 // start_display_time is required to be 0
1043 sub->pts += av_rescale_q(sub->start_display_time, (AVRational){1, 1000}, AV_TIME_BASE_Q);
1044 sub->end_display_time -= sub->start_display_time;
1045 sub->start_display_time = 0;
1046 subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1047 subtitle_out_max_size, sub);
1048 if (subtitle_out_size < 0) {
1049 fprintf(stderr, "Subtitle encoding failed\n");
1053 av_init_packet(&pkt);
1054 pkt.stream_index = ost->index;
1055 pkt.data = subtitle_out;
1056 pkt.size = subtitle_out_size;
1057 pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
1058 if (enc->codec_id == CODEC_ID_DVB_SUBTITLE) {
1059 /* XXX: the pts correction is handled here. Maybe handling
1060 it in the codec would be better */
1062 pkt.pts += 90 * sub->start_display_time;
1064 pkt.pts += 90 * sub->end_display_time;
1066 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1070 static int bit_buffer_size= 1024*256;
1071 static uint8_t *bit_buffer= NULL;
1073 static void do_video_resample(OutputStream *ost,
1075 AVFrame *in_picture,
1076 AVFrame **out_picture)
1078 int resample_changed = 0;
1079 AVCodecContext *dec = ist->st->codec;
1080 *out_picture = in_picture;
1081 #if !CONFIG_AVFILTER
1082 resample_changed = ost->resample_width != dec->width ||
1083 ost->resample_height != dec->height ||
1084 ost->resample_pix_fmt != dec->pix_fmt;
1086 if (resample_changed) {
1087 av_log(NULL, AV_LOG_INFO,
1088 "Input stream #%d.%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1089 ist->file_index, ist->st->index,
1090 ost->resample_width, ost->resample_height, av_get_pix_fmt_name(ost->resample_pix_fmt),
1091 dec->width , dec->height , av_get_pix_fmt_name(dec->pix_fmt));
1092 ost->resample_width = dec->width;
1093 ost->resample_height = dec->height;
1094 ost->resample_pix_fmt = dec->pix_fmt;
1097 ost->video_resample = dec->width != enc->width ||
1098 dec->height != enc->height ||
1099 dec->pix_fmt != enc->pix_fmt;
1101 if (ost->video_resample) {
1102 *out_picture = &ost->resample_frame;
1103 if (!ost->img_resample_ctx || resample_changed) {
1104 /* initialize the destination picture */
1105 if (!ost->resample_frame.data[0]) {
1106 avcodec_get_frame_defaults(&ost->resample_frame);
1107 if (avpicture_alloc((AVPicture *)&ost->resample_frame, enc->pix_fmt,
1108 enc->width, enc->height)) {
1109 fprintf(stderr, "Cannot allocate temp picture, check pix fmt\n");
1113 /* initialize a new scaler context */
1114 sws_freeContext(ost->img_resample_ctx);
1115 ost->img_resample_ctx = sws_getContext(dec->width, dec->height, dec->pix_fmt,
1116 enc->width, enc->height, enc->pix_fmt,
1117 ost->sws_flags, NULL, NULL, NULL);
1118 if (ost->img_resample_ctx == NULL) {
1119 fprintf(stderr, "Cannot get resampling context\n");
1123 sws_scale(ost->img_resample_ctx, in_picture->data, in_picture->linesize,
1124 0, ost->resample_height, (*out_picture)->data, (*out_picture)->linesize);
1130 static void do_video_out(AVFormatContext *s,
1133 AVFrame *in_picture,
1134 int *frame_size, float quality)
1136 int nb_frames, i, ret, format_video_sync;
1137 AVFrame *final_picture;
1138 AVCodecContext *enc, *dec;
1141 enc = ost->st->codec;
1142 dec = ist->st->codec;
1144 sync_ipts = get_sync_ipts(ost) / av_q2d(enc->time_base);
1146 /* by default, we output a single frame */
1151 format_video_sync = video_sync_method;
1152 if (format_video_sync < 0)
1153 format_video_sync = (s->oformat->flags & AVFMT_VARIABLE_FPS) ? 2 : 1;
1155 if (format_video_sync) {
1156 double vdelta = sync_ipts - ost->sync_opts;
1157 //FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1160 else if (format_video_sync == 2) {
1163 }else if(vdelta>0.6)
1164 ost->sync_opts= lrintf(sync_ipts);
1165 }else if (vdelta > 1.1)
1166 nb_frames = lrintf(vdelta);
1167 //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);
1168 if (nb_frames == 0){
1171 fprintf(stderr, "*** drop!\n");
1172 }else if (nb_frames > 1) {
1173 nb_frames_dup += nb_frames - 1;
1175 fprintf(stderr, "*** %d dup!\n", nb_frames-1);
1178 ost->sync_opts= lrintf(sync_ipts);
1180 nb_frames= FFMIN(nb_frames, max_frames[AVMEDIA_TYPE_VIDEO] - ost->frame_number);
1184 do_video_resample(ost, ist, in_picture, &final_picture);
1186 /* duplicates frame if needed */
1187 for(i=0;i<nb_frames;i++) {
1189 av_init_packet(&pkt);
1190 pkt.stream_index= ost->index;
1192 if (s->oformat->flags & AVFMT_RAWPICTURE) {
1193 /* raw pictures are written as AVPicture structure to
1194 avoid any copies. We support temporarily the older
1196 AVFrame* old_frame = enc->coded_frame;
1197 enc->coded_frame = dec->coded_frame; //FIXME/XXX remove this hack
1198 pkt.data= (uint8_t *)final_picture;
1199 pkt.size= sizeof(AVPicture);
1200 pkt.pts= av_rescale_q(ost->sync_opts, enc->time_base, ost->st->time_base);
1201 pkt.flags |= AV_PKT_FLAG_KEY;
1203 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1204 enc->coded_frame = old_frame;
1206 AVFrame big_picture;
1208 big_picture= *final_picture;
1209 /* better than nothing: use input picture interlaced
1211 big_picture.interlaced_frame = in_picture->interlaced_frame;
1212 if (ost->st->codec->flags & (CODEC_FLAG_INTERLACED_DCT|CODEC_FLAG_INTERLACED_ME)) {
1213 if(top_field_first == -1)
1214 big_picture.top_field_first = in_picture->top_field_first;
1216 big_picture.top_field_first = top_field_first;
1219 /* handles same_quant here. This is not correct because it may
1220 not be a global option */
1221 big_picture.quality = quality;
1223 big_picture.pict_type = 0;
1224 // big_picture.pts = AV_NOPTS_VALUE;
1225 big_picture.pts= ost->sync_opts;
1226 // big_picture.pts= av_rescale(ost->sync_opts, AV_TIME_BASE*(int64_t)enc->time_base.num, enc->time_base.den);
1227 //av_log(NULL, AV_LOG_DEBUG, "%"PRId64" -> encoder\n", ost->sync_opts);
1228 if (ost->forced_kf_index < ost->forced_kf_count &&
1229 big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1230 big_picture.pict_type = AV_PICTURE_TYPE_I;
1231 ost->forced_kf_index++;
1233 ret = avcodec_encode_video(enc,
1234 bit_buffer, bit_buffer_size,
1237 fprintf(stderr, "Video encoding failed\n");
1242 pkt.data= bit_buffer;
1244 if(enc->coded_frame->pts != AV_NOPTS_VALUE)
1245 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1246 /*av_log(NULL, AV_LOG_DEBUG, "encoder -> %"PRId64"/%"PRId64"\n",
1247 pkt.pts != AV_NOPTS_VALUE ? av_rescale(pkt.pts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1,
1248 pkt.dts != AV_NOPTS_VALUE ? av_rescale(pkt.dts, enc->time_base.den, AV_TIME_BASE*(int64_t)enc->time_base.num) : -1);*/
1250 if(enc->coded_frame->key_frame)
1251 pkt.flags |= AV_PKT_FLAG_KEY;
1252 write_frame(s, &pkt, ost->st->codec, ost->bitstream_filters);
1255 //fprintf(stderr,"\nFrame: %3d size: %5d type: %d",
1256 // enc->frame_number-1, ret, enc->pict_type);
1257 /* if two pass, output log */
1258 if (ost->logfile && enc->stats_out) {
1259 fprintf(ost->logfile, "%s", enc->stats_out);
1264 ost->frame_number++;
1268 static double psnr(double d){
1269 return -10.0*log(d)/log(10.0);
1272 static void do_video_stats(AVFormatContext *os, OutputStream *ost,
1275 AVCodecContext *enc;
1277 double ti1, bitrate, avg_bitrate;
1279 /* this is executed just the first time do_video_stats is called */
1281 vstats_file = fopen(vstats_filename, "w");
1288 enc = ost->st->codec;
1289 if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1290 frame_number = ost->frame_number;
1291 fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality/(float)FF_QP2LAMBDA);
1292 if (enc->flags&CODEC_FLAG_PSNR)
1293 fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0]/(enc->width*enc->height*255.0*255.0)));
1295 fprintf(vstats_file,"f_size= %6d ", frame_size);
1296 /* compute pts value */
1297 ti1 = ost->sync_opts * av_q2d(enc->time_base);
1301 bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1302 avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
1303 fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1304 (double)video_size / 1024, ti1, bitrate, avg_bitrate);
1305 fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
1309 static void print_report(OutputFile *output_files,
1310 OutputStream *ost_table, int nb_ostreams,
1311 int is_last_report, int64_t timer_start)
1315 AVFormatContext *oc;
1317 AVCodecContext *enc;
1318 int frame_number, vid, i;
1320 int64_t pts = INT64_MAX;
1321 static int64_t last_time = -1;
1322 static int qp_histogram[52];
1324 if (!is_last_report) {
1326 /* display the report every 0.5 seconds */
1327 cur_time = av_gettime();
1328 if (last_time == -1) {
1329 last_time = cur_time;
1332 if ((cur_time - last_time) < 500000)
1334 last_time = cur_time;
1338 oc = output_files[0].ctx;
1340 total_size = avio_size(oc->pb);
1341 if(total_size<0) // FIXME improve avio_size() so it works with non seekable output too
1342 total_size= avio_tell(oc->pb);
1346 for(i=0;i<nb_ostreams;i++) {
1348 ost = &ost_table[i];
1349 enc = ost->st->codec;
1350 if (!ost->st->stream_copy && enc->coded_frame)
1351 q = enc->coded_frame->quality/(float)FF_QP2LAMBDA;
1352 if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1353 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
1355 if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1356 float t = (av_gettime()-timer_start) / 1000000.0;
1358 frame_number = ost->frame_number;
1359 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
1360 frame_number, (t>1)?(int)(frame_number/t+0.5) : 0, q);
1362 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
1366 if(qp>=0 && qp<FF_ARRAY_ELEMS(qp_histogram))
1369 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log(qp_histogram[j]+1)/log(2)));
1371 if (enc->flags&CODEC_FLAG_PSNR){
1373 double error, error_sum=0;
1374 double scale, scale_sum=0;
1375 char type[3]= {'Y','U','V'};
1376 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
1379 error= enc->error[j];
1380 scale= enc->width*enc->height*255.0*255.0*frame_number;
1382 error= enc->coded_frame->error[j];
1383 scale= enc->width*enc->height*255.0*255.0;
1388 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error/scale));
1390 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum/scale_sum));
1394 /* compute min output value */
1395 pts = FFMIN(pts, av_rescale_q(ost->st->pts.val,
1396 ost->st->time_base, AV_TIME_BASE_Q));
1399 if (verbose > 0 || is_last_report) {
1400 int hours, mins, secs, us;
1401 secs = pts / AV_TIME_BASE;
1402 us = pts % AV_TIME_BASE;
1408 bitrate = pts ? total_size * 8 / (pts / 1000.0) : 0;
1410 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1411 "size=%8.0fkB time=", total_size / 1024.0);
1412 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1413 "%02d:%02d:%02d.%02d ", hours, mins, secs,
1414 (100 * us) / AV_TIME_BASE);
1415 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
1416 "bitrate=%6.1fkbits/s", bitrate);
1418 if (nb_frames_dup || nb_frames_drop)
1419 snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
1420 nb_frames_dup, nb_frames_drop);
1423 fprintf(stderr, "%s \r", buf);
1428 if (is_last_report && verbose >= 0){
1429 int64_t raw= audio_size + video_size + extra_size;
1430 fprintf(stderr, "\n");
1431 fprintf(stderr, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
1435 100.0*(total_size - raw)/raw
1440 static void generate_silence(uint8_t* buf, enum AVSampleFormat sample_fmt, size_t size)
1442 int fill_char = 0x00;
1443 if (sample_fmt == AV_SAMPLE_FMT_U8)
1445 memset(buf, fill_char, size);
1448 static void flush_encoders(int ist_index, OutputStream *ost_table, int nb_ostreams)
1452 for (i = 0; i < nb_ostreams; i++) {
1453 OutputStream *ost = &ost_table[i];
1454 AVCodecContext *enc = ost->st->codec;
1455 AVFormatContext *os = output_files[ost->file_index].ctx;
1457 if (ost->source_index != ist_index || !ost->encoding_needed)
1460 if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <=1)
1462 if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && (os->oformat->flags & AVFMT_RAWPICTURE))
1468 av_init_packet(&pkt);
1469 pkt.stream_index= ost->index;
1471 switch (ost->st->codec->codec_type) {
1472 case AVMEDIA_TYPE_AUDIO:
1473 fifo_bytes = av_fifo_size(ost->fifo);
1475 /* encode any samples remaining in fifo */
1476 if (fifo_bytes > 0) {
1477 int osize = av_get_bytes_per_sample(enc->sample_fmt);
1478 int fs_tmp = enc->frame_size;
1480 av_fifo_generic_read(ost->fifo, audio_buf, fifo_bytes, NULL);
1481 if (enc->codec->capabilities & CODEC_CAP_SMALL_LAST_FRAME) {
1482 enc->frame_size = fifo_bytes / (osize * enc->channels);
1484 int frame_bytes = enc->frame_size*osize*enc->channels;
1485 if (allocated_audio_buf_size < frame_bytes)
1487 generate_silence(audio_buf+fifo_bytes, enc->sample_fmt, frame_bytes - fifo_bytes);
1490 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, (short *)audio_buf);
1491 pkt.duration = av_rescale((int64_t)enc->frame_size*ost->st->time_base.den,
1492 ost->st->time_base.num, enc->sample_rate);
1493 enc->frame_size = fs_tmp;
1496 ret = avcodec_encode_audio(enc, bit_buffer, bit_buffer_size, NULL);
1499 fprintf(stderr, "Audio encoding failed\n");
1503 pkt.flags |= AV_PKT_FLAG_KEY;
1505 case AVMEDIA_TYPE_VIDEO:
1506 ret = avcodec_encode_video(enc, bit_buffer, bit_buffer_size, NULL);
1508 fprintf(stderr, "Video encoding failed\n");
1512 if(enc->coded_frame && enc->coded_frame->key_frame)
1513 pkt.flags |= AV_PKT_FLAG_KEY;
1514 if (ost->logfile && enc->stats_out) {
1515 fprintf(ost->logfile, "%s", enc->stats_out);
1524 pkt.data = bit_buffer;
1526 if (enc->coded_frame && enc->coded_frame->pts != AV_NOPTS_VALUE)
1527 pkt.pts= av_rescale_q(enc->coded_frame->pts, enc->time_base, ost->st->time_base);
1528 write_frame(os, &pkt, ost->st->codec, ost->bitstream_filters);
1533 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1534 static int output_packet(InputStream *ist, int ist_index,
1535 OutputStream *ost_table, int nb_ostreams,
1536 const AVPacket *pkt)
1538 AVFormatContext *os;
1543 void *buffer_to_free = NULL;
1544 static unsigned int samples_size= 0;
1545 AVSubtitle subtitle, *subtitle_to_free;
1546 int64_t pkt_pts = AV_NOPTS_VALUE;
1548 int frame_available;
1553 int bps = av_get_bytes_per_sample(ist->st->codec->sample_fmt);
1555 if(ist->next_pts == AV_NOPTS_VALUE)
1556 ist->next_pts= ist->pts;
1560 av_init_packet(&avpkt);
1568 if(pkt->dts != AV_NOPTS_VALUE)
1569 ist->next_pts = ist->pts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1570 if(pkt->pts != AV_NOPTS_VALUE)
1571 pkt_pts = av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
1573 //while we have more to decode or while the decoder did output something on EOF
1574 while (avpkt.size > 0 || (!pkt && got_output)) {
1575 uint8_t *data_buf, *decoded_data_buf;
1576 int data_size, decoded_data_size;
1578 ist->pts= ist->next_pts;
1580 if(avpkt.size && avpkt.size != pkt->size &&
1581 ((!ist->showed_multi_packet_warning && verbose>0) || verbose>1)){
1582 fprintf(stderr, "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1583 ist->showed_multi_packet_warning=1;
1586 /* decode the packet if needed */
1587 decoded_data_buf = NULL; /* fail safe */
1588 decoded_data_size= 0;
1589 data_buf = avpkt.data;
1590 data_size = avpkt.size;
1591 subtitle_to_free = NULL;
1592 if (ist->decoding_needed) {
1593 switch(ist->st->codec->codec_type) {
1594 case AVMEDIA_TYPE_AUDIO:{
1595 if(pkt && samples_size < FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE)) {
1596 samples_size = FFMAX(pkt->size*sizeof(*samples), AVCODEC_MAX_AUDIO_FRAME_SIZE);
1598 samples= av_malloc(samples_size);
1600 decoded_data_size= samples_size;
1601 /* XXX: could avoid copy if PCM 16 bits with same
1602 endianness as CPU */
1603 ret = avcodec_decode_audio3(ist->st->codec, samples, &decoded_data_size,
1610 got_output = decoded_data_size > 0;
1611 /* Some bug in mpeg audio decoder gives */
1612 /* decoded_data_size < 0, it seems they are overflows */
1614 /* no audio frame */
1617 decoded_data_buf = (uint8_t *)samples;
1618 ist->next_pts += ((int64_t)AV_TIME_BASE/bps * decoded_data_size) /
1619 (ist->st->codec->sample_rate * ist->st->codec->channels);
1621 case AVMEDIA_TYPE_VIDEO:
1622 decoded_data_size = (ist->st->codec->width * ist->st->codec->height * 3) / 2;
1623 /* XXX: allocate picture correctly */
1624 avcodec_get_frame_defaults(&picture);
1625 avpkt.pts = pkt_pts;
1626 avpkt.dts = ist->pts;
1627 pkt_pts = AV_NOPTS_VALUE;
1629 ret = avcodec_decode_video2(ist->st->codec,
1630 &picture, &got_output, &avpkt);
1631 quality = same_quant ? picture.quality : 0;
1635 /* no picture yet */
1636 goto discard_packet;
1638 ist->next_pts = ist->pts = picture.best_effort_timestamp;
1639 if (ist->st->codec->time_base.num != 0) {
1640 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1641 ist->next_pts += ((int64_t)AV_TIME_BASE *
1642 ist->st->codec->time_base.num * ticks) /
1643 ist->st->codec->time_base.den;
1646 buffer_to_free = NULL;
1647 pre_process_video_frame(ist, (AVPicture *)&picture, &buffer_to_free);
1649 case AVMEDIA_TYPE_SUBTITLE:
1650 ret = avcodec_decode_subtitle2(ist->st->codec,
1651 &subtitle, &got_output, &avpkt);
1655 goto discard_packet;
1657 subtitle_to_free = &subtitle;
1664 switch(ist->st->codec->codec_type) {
1665 case AVMEDIA_TYPE_AUDIO:
1666 ist->next_pts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1667 ist->st->codec->sample_rate;
1669 case AVMEDIA_TYPE_VIDEO:
1670 if (ist->st->codec->time_base.num != 0) {
1671 int ticks= ist->st->parser ? ist->st->parser->repeat_pict+1 : ist->st->codec->ticks_per_frame;
1672 ist->next_pts += ((int64_t)AV_TIME_BASE *
1673 ist->st->codec->time_base.num * ticks) /
1674 ist->st->codec->time_base.den;
1683 if(ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO)
1684 if (start_time == 0 || ist->pts >= start_time) {
1685 for(i=0;i<nb_ostreams;i++) {
1686 ost = &ost_table[i];
1687 if (ost->input_video_filter && ost->source_index == ist_index) {
1688 if (!picture.sample_aspect_ratio.num)
1689 picture.sample_aspect_ratio = ist->st->sample_aspect_ratio;
1690 picture.pts = ist->pts;
1692 av_vsrc_buffer_add_frame(ost->input_video_filter, &picture, AV_VSRC_BUF_FLAG_OVERWRITE);
1698 // preprocess audio (volume)
1699 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
1700 if (audio_volume != 256) {
1703 for(i=0;i<(decoded_data_size / sizeof(short));i++) {
1704 int v = ((*volp) * audio_volume + 128) >> 8;
1705 if (v < -32768) v = -32768;
1706 if (v > 32767) v = 32767;
1712 /* frame rate emulation */
1714 int64_t pts = av_rescale(ist->pts, 1000000, AV_TIME_BASE);
1715 int64_t now = av_gettime() - ist->start;
1719 /* if output time reached then transcode raw format,
1720 encode packets and output them */
1721 for (i = 0; i < nb_ostreams; i++) {
1722 OutputFile *of = &output_files[ost_table[i].file_index];
1725 ost = &ost_table[i];
1726 if (ost->source_index != ist_index)
1729 if (of->start_time && ist->pts < of->start_time)
1732 if (of->recording_time != INT64_MAX &&
1733 av_compare_ts(ist->pts, AV_TIME_BASE_Q, of->recording_time + of->start_time,
1734 (AVRational){1, 1000000}) >= 0) {
1735 ost->is_past_recording_time = 1;
1740 frame_available = ist->st->codec->codec_type != AVMEDIA_TYPE_VIDEO ||
1741 !ost->output_video_filter || avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1742 while (frame_available) {
1743 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO && ost->output_video_filter) {
1744 AVRational ist_pts_tb = ost->output_video_filter->inputs[0]->time_base;
1745 if (av_vsink_buffer_get_video_buffer_ref(ost->output_video_filter, &ost->picref, 0) < 0)
1748 avfilter_fill_frame_from_video_buffer_ref(&picture, ost->picref);
1749 ist->pts = av_rescale_q(ost->picref->pts, ist_pts_tb, AV_TIME_BASE_Q);
1753 os = output_files[ost->file_index].ctx;
1755 /* set the input output pts pairs */
1756 //ost->sync_ipts = (double)(ist->pts + input_files[ist->file_index].ts_offset - start_time)/ AV_TIME_BASE;
1758 if (ost->encoding_needed) {
1759 av_assert0(ist->decoding_needed);
1760 switch(ost->st->codec->codec_type) {
1761 case AVMEDIA_TYPE_AUDIO:
1762 do_audio_out(os, ost, ist, decoded_data_buf, decoded_data_size);
1764 case AVMEDIA_TYPE_VIDEO:
1766 if (ost->picref->video && !ost->frame_aspect_ratio)
1767 ost->st->codec->sample_aspect_ratio = ost->picref->video->sample_aspect_ratio;
1769 do_video_out(os, ost, ist, &picture, &frame_size,
1770 same_quant ? quality : ost->st->codec->global_quality);
1771 if (vstats_filename && frame_size)
1772 do_video_stats(os, ost, frame_size);
1774 case AVMEDIA_TYPE_SUBTITLE:
1775 do_subtitle_out(os, ost, ist, &subtitle,
1782 AVFrame avframe; //FIXME/XXX remove this
1785 int64_t ost_tb_start_time= av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
1786 av_init_packet(&opkt);
1788 if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) && !copy_initial_nonkeyframes)
1789 #if !CONFIG_AVFILTER
1795 /* no reencoding needed : output the packet directly */
1796 /* force the input stream PTS */
1798 avcodec_get_frame_defaults(&avframe);
1799 ost->st->codec->coded_frame= &avframe;
1800 avframe.key_frame = pkt->flags & AV_PKT_FLAG_KEY;
1802 if(ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1803 audio_size += data_size;
1804 else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1805 video_size += data_size;
1809 opkt.stream_index= ost->index;
1810 if(pkt->pts != AV_NOPTS_VALUE)
1811 opkt.pts= av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1813 opkt.pts= AV_NOPTS_VALUE;
1815 if (pkt->dts == AV_NOPTS_VALUE)
1816 opkt.dts = av_rescale_q(ist->pts, AV_TIME_BASE_Q, ost->st->time_base);
1818 opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1819 opkt.dts -= ost_tb_start_time;
1821 opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1822 opkt.flags= pkt->flags;
1824 //FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1825 if( ost->st->codec->codec_id != CODEC_ID_H264
1826 && ost->st->codec->codec_id != CODEC_ID_MPEG1VIDEO
1827 && ost->st->codec->codec_id != CODEC_ID_MPEG2VIDEO
1829 if(av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, data_buf, data_size, pkt->flags & AV_PKT_FLAG_KEY))
1830 opkt.destruct= av_destruct_packet;
1832 opkt.data = data_buf;
1833 opkt.size = data_size;
1836 if (os->oformat->flags & AVFMT_RAWPICTURE) {
1837 /* store AVPicture in AVPacket, as expected by the output format */
1838 avpicture_fill(&pict, opkt.data, ost->st->codec->pix_fmt, ost->st->codec->width, ost->st->codec->height);
1839 opkt.data = (uint8_t *)&pict;
1840 opkt.size = sizeof(AVPicture);
1841 opkt.flags |= AV_PKT_FLAG_KEY;
1843 write_frame(os, &opkt, ost->st->codec, ost->bitstream_filters);
1844 ost->st->codec->frame_number++;
1845 ost->frame_number++;
1846 av_free_packet(&opkt);
1850 frame_available = (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) &&
1851 ost->output_video_filter && avfilter_poll_frame(ost->output_video_filter->inputs[0]);
1852 avfilter_unref_buffer(ost->picref);
1857 av_free(buffer_to_free);
1858 /* XXX: allocate the subtitles in the codec ? */
1859 if (subtitle_to_free) {
1860 avsubtitle_free(subtitle_to_free);
1861 subtitle_to_free = NULL;
1867 flush_encoders(ist_index, ost_table, nb_ostreams);
1873 static void print_sdp(OutputFile *output_files, int n)
1877 AVFormatContext **avc = av_malloc(sizeof(*avc)*n);
1881 for (i = 0; i < n; i++)
1882 avc[i] = output_files[i].ctx;
1884 av_sdp_create(avc, n, sdp, sizeof(sdp));
1885 printf("SDP:\n%s\n", sdp);
1890 static int init_input_stream(int ist_index, OutputStream *output_streams, int nb_output_streams,
1891 char *error, int error_len)
1894 InputStream *ist = &input_streams[ist_index];
1895 if (ist->decoding_needed) {
1896 AVCodec *codec = ist->dec;
1898 codec = avcodec_find_decoder(ist->st->codec->codec_id);
1900 snprintf(error, sizeof(error), "Decoder (codec %s) not found for input stream #%d.%d",
1901 avcodec_get_name(ist->st->codec->codec_id), ist->file_index, ist->st->index);
1902 return AVERROR(EINVAL);
1904 if (avcodec_open2(ist->st->codec, codec, &ist->opts) < 0) {
1905 snprintf(error, sizeof(error), "Error while opening decoder for input stream #%d.%d",
1906 ist->file_index, ist->st->index);
1907 return AVERROR(EINVAL);
1909 assert_codec_experimental(ist->st->codec, 0);
1910 assert_avoptions(ist->opts);
1913 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;
1914 ist->next_pts = AV_NOPTS_VALUE;
1921 * The following code is the main loop of the file converter
1923 static int transcode(OutputFile *output_files,
1924 int nb_output_files,
1925 InputFile *input_files,
1929 AVFormatContext *is, *os;
1930 AVCodecContext *codec, *icodec;
1937 int no_packet_count=0;
1938 int64_t timer_start;
1940 if (!(no_packet = av_mallocz(nb_input_files)))
1944 for (i = 0; i < nb_input_streams; i++)
1945 input_streams[i].start = av_gettime();
1947 /* output stream init */
1948 for(i=0;i<nb_output_files;i++) {
1949 os = output_files[i].ctx;
1950 if (!os->nb_streams && !(os->oformat->flags & AVFMT_NOSTREAMS)) {
1951 av_dump_format(os, i, os->filename, 1);
1952 fprintf(stderr, "Output file #%d does not contain any stream\n", i);
1953 ret = AVERROR(EINVAL);
1958 /* for each output stream, we compute the right encoding parameters */
1959 for (i = 0; i < nb_output_streams; i++) {
1960 ost = &output_streams[i];
1961 os = output_files[ost->file_index].ctx;
1962 ist = &input_streams[ost->source_index];
1964 codec = ost->st->codec;
1965 icodec = ist->st->codec;
1967 ost->st->disposition = ist->st->disposition;
1968 codec->bits_per_raw_sample= icodec->bits_per_raw_sample;
1969 codec->chroma_sample_location = icodec->chroma_sample_location;
1971 if (ost->st->stream_copy) {
1972 uint64_t extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1974 if (extra_size > INT_MAX)
1977 /* if stream_copy is selected, no need to decode or encode */
1978 codec->codec_id = icodec->codec_id;
1979 codec->codec_type = icodec->codec_type;
1981 if(!codec->codec_tag){
1982 if( !os->oformat->codec_tag
1983 || av_codec_get_id (os->oformat->codec_tag, icodec->codec_tag) == codec->codec_id
1984 || av_codec_get_tag(os->oformat->codec_tag, icodec->codec_id) <= 0)
1985 codec->codec_tag = icodec->codec_tag;
1988 codec->bit_rate = icodec->bit_rate;
1989 codec->rc_max_rate = icodec->rc_max_rate;
1990 codec->rc_buffer_size = icodec->rc_buffer_size;
1991 codec->extradata= av_mallocz(extra_size);
1992 if (!codec->extradata)
1994 memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1995 codec->extradata_size= icodec->extradata_size;
1997 codec->time_base = ist->st->time_base;
1998 if(!strcmp(os->oformat->name, "avi")) {
1999 if(!copy_tb && av_q2d(icodec->time_base)*icodec->ticks_per_frame > 2*av_q2d(ist->st->time_base) && av_q2d(ist->st->time_base) < 1.0/500){
2000 codec->time_base = icodec->time_base;
2001 codec->time_base.num *= icodec->ticks_per_frame;
2002 codec->time_base.den *= 2;
2004 } else if(!(os->oformat->flags & AVFMT_VARIABLE_FPS)) {
2005 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){
2006 codec->time_base = icodec->time_base;
2007 codec->time_base.num *= icodec->ticks_per_frame;
2010 av_reduce(&codec->time_base.num, &codec->time_base.den,
2011 codec->time_base.num, codec->time_base.den, INT_MAX);
2013 switch(codec->codec_type) {
2014 case AVMEDIA_TYPE_AUDIO:
2015 if(audio_volume != 256) {
2016 fprintf(stderr,"-acodec copy and -vol are incompatible (frames are not decoded)\n");
2019 codec->channel_layout = icodec->channel_layout;
2020 codec->sample_rate = icodec->sample_rate;
2021 codec->channels = icodec->channels;
2022 codec->frame_size = icodec->frame_size;
2023 codec->audio_service_type = icodec->audio_service_type;
2024 codec->block_align= icodec->block_align;
2025 if(codec->block_align == 1 && codec->codec_id == CODEC_ID_MP3)
2026 codec->block_align= 0;
2027 if(codec->codec_id == CODEC_ID_AC3)
2028 codec->block_align= 0;
2030 case AVMEDIA_TYPE_VIDEO:
2031 codec->pix_fmt = icodec->pix_fmt;
2032 codec->width = icodec->width;
2033 codec->height = icodec->height;
2034 codec->has_b_frames = icodec->has_b_frames;
2035 if (!codec->sample_aspect_ratio.num) {
2036 codec->sample_aspect_ratio =
2037 ost->st->sample_aspect_ratio =
2038 ist->st->sample_aspect_ratio.num ? ist->st->sample_aspect_ratio :
2039 ist->st->codec->sample_aspect_ratio.num ?
2040 ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
2043 case AVMEDIA_TYPE_SUBTITLE:
2044 codec->width = icodec->width;
2045 codec->height = icodec->height;
2047 case AVMEDIA_TYPE_DATA:
2054 ost->enc = avcodec_find_encoder(ost->st->codec->codec_id);
2055 switch(codec->codec_type) {
2056 case AVMEDIA_TYPE_AUDIO:
2057 ost->fifo= av_fifo_alloc(1024);
2060 ost->reformat_pair = MAKE_SFMT_PAIR(AV_SAMPLE_FMT_NONE,AV_SAMPLE_FMT_NONE);
2061 if (!codec->sample_rate) {
2062 codec->sample_rate = icodec->sample_rate;
2064 choose_sample_rate(ost->st, ost->enc);
2065 codec->time_base = (AVRational){1, codec->sample_rate};
2066 if (codec->sample_fmt == AV_SAMPLE_FMT_NONE)
2067 codec->sample_fmt = icodec->sample_fmt;
2068 choose_sample_fmt(ost->st, ost->enc);
2069 if (!codec->channels) {
2070 codec->channels = icodec->channels;
2071 codec->channel_layout = icodec->channel_layout;
2073 if (av_get_channel_layout_nb_channels(codec->channel_layout) != codec->channels)
2074 codec->channel_layout = 0;
2075 ost->audio_resample = codec->sample_rate != icodec->sample_rate || audio_sync_method > 1;
2076 icodec->request_channels = codec->channels;
2077 ist->decoding_needed = 1;
2078 ost->encoding_needed = 1;
2079 ost->resample_sample_fmt = icodec->sample_fmt;
2080 ost->resample_sample_rate = icodec->sample_rate;
2081 ost->resample_channels = icodec->channels;
2083 case AVMEDIA_TYPE_VIDEO:
2084 if (codec->pix_fmt == PIX_FMT_NONE)
2085 codec->pix_fmt = icodec->pix_fmt;
2086 choose_pixel_fmt(ost->st, ost->enc);
2088 if (ost->st->codec->pix_fmt == PIX_FMT_NONE) {
2089 fprintf(stderr, "Video pixel format is unknown, stream cannot be encoded\n");
2093 if (!codec->width || !codec->height) {
2094 codec->width = icodec->width;
2095 codec->height = icodec->height;
2098 ost->video_resample = codec->width != icodec->width ||
2099 codec->height != icodec->height ||
2100 codec->pix_fmt != icodec->pix_fmt;
2101 if (ost->video_resample) {
2102 codec->bits_per_raw_sample= frame_bits_per_raw_sample;
2105 ost->resample_height = icodec->height;
2106 ost->resample_width = icodec->width;
2107 ost->resample_pix_fmt= icodec->pix_fmt;
2108 ost->encoding_needed = 1;
2109 ist->decoding_needed = 1;
2111 if (!ost->frame_rate.num)
2112 ost->frame_rate = ist->st->r_frame_rate.num ? ist->st->r_frame_rate : (AVRational){25,1};
2113 if (ost->enc && ost->enc->supported_framerates && !force_fps) {
2114 int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
2115 ost->frame_rate = ost->enc->supported_framerates[idx];
2117 codec->time_base = (AVRational){ost->frame_rate.den, ost->frame_rate.num};
2118 if( av_q2d(codec->time_base) < 0.001 && video_sync_method
2119 && (video_sync_method==1 || (video_sync_method<0 && !(os->oformat->flags & AVFMT_VARIABLE_FPS)))){
2120 av_log(os, AV_LOG_WARNING, "Frame rate very high for a muxer not effciciently supporting it.\n"
2121 "Please consider specifiying a lower framerate, a different muxer or -vsync 2\n");
2125 if (configure_video_filters(ist, ost)) {
2126 fprintf(stderr, "Error opening filters!\n");
2131 case AVMEDIA_TYPE_SUBTITLE:
2132 ost->encoding_needed = 1;
2133 ist->decoding_needed = 1;
2140 if (ost->encoding_needed && codec->codec_id != CODEC_ID_H264 &&
2141 (codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
2142 char logfilename[1024];
2145 snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
2146 pass_logfilename_prefix ? pass_logfilename_prefix : DEFAULT_PASS_LOGFILENAME_PREFIX,
2148 if (codec->flags & CODEC_FLAG_PASS1) {
2149 f = fopen(logfilename, "wb");
2151 fprintf(stderr, "Cannot write log file '%s' for pass-1 encoding: %s\n", logfilename, strerror(errno));
2157 size_t logbuffer_size;
2158 if (read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
2159 fprintf(stderr, "Error reading log file '%s' for pass-2 encoding\n", logfilename);
2162 codec->stats_in = logbuffer;
2166 if(codec->codec_type == AVMEDIA_TYPE_VIDEO){
2167 /* maximum video buffer size is 6-bytes per pixel, plus DPX header size */
2168 int size= codec->width * codec->height;
2169 bit_buffer_size= FFMAX(bit_buffer_size, 6*size + 1664);
2174 bit_buffer = av_malloc(bit_buffer_size);
2176 fprintf(stderr, "Cannot allocate %d bytes output buffer\n",
2178 ret = AVERROR(ENOMEM);
2182 /* open each encoder */
2183 for (i = 0; i < nb_output_streams; i++) {
2184 ost = &output_streams[i];
2185 if (ost->encoding_needed) {
2186 AVCodec *codec = ost->enc;
2187 AVCodecContext *dec = input_streams[ost->source_index].st->codec;
2189 snprintf(error, sizeof(error), "Encoder (codec %s) not found for output stream #%d.%d",
2190 avcodec_get_name(ost->st->codec->codec_id), ost->file_index, ost->index);
2191 ret = AVERROR(EINVAL);
2194 if (dec->subtitle_header) {
2195 ost->st->codec->subtitle_header = av_malloc(dec->subtitle_header_size);
2196 if (!ost->st->codec->subtitle_header) {
2197 ret = AVERROR(ENOMEM);
2200 memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
2201 ost->st->codec->subtitle_header_size = dec->subtitle_header_size;
2203 if (avcodec_open2(ost->st->codec, codec, &ost->opts) < 0) {
2204 snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d.%d - maybe incorrect parameters such as bit_rate, rate, width or height",
2205 ost->file_index, ost->index);
2206 ret = AVERROR(EINVAL);
2209 assert_codec_experimental(ost->st->codec, 1);
2210 assert_avoptions(ost->opts);
2211 if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
2212 av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
2213 "It takes bits/s as argument, not kbits/s\n");
2214 extra_size += ost->st->codec->extradata_size;
2218 /* init input streams */
2219 for (i = 0; i < nb_input_streams; i++)
2220 if ((ret = init_input_stream(i, output_streams, nb_output_streams, error, sizeof(error)) < 0))
2223 /* open files and write file headers */
2224 for (i = 0; i < nb_output_files; i++) {
2225 os = output_files[i].ctx;
2226 if (avformat_write_header(os, &output_files[i].opts) < 0) {
2227 snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?)", i);
2228 ret = AVERROR(EINVAL);
2231 // assert_avoptions(output_files[i].opts);
2232 if (strcmp(os->oformat->name, "rtp")) {
2238 /* dump the file output parameters - cannot be done before in case
2240 for(i=0;i<nb_output_files;i++) {
2241 av_dump_format(output_files[i].ctx, i, output_files[i].ctx->filename, 1);
2244 /* dump the stream mapping */
2246 fprintf(stderr, "Stream mapping:\n");
2247 for (i = 0; i < nb_output_streams;i ++) {
2248 ost = &output_streams[i];
2249 fprintf(stderr, " Stream #%d.%d -> #%d.%d",
2250 input_streams[ost->source_index].file_index,
2251 input_streams[ost->source_index].st->index,
2254 if (ost->sync_ist != &input_streams[ost->source_index])
2255 fprintf(stderr, " [sync #%d.%d]",
2256 ost->sync_ist->file_index,
2257 ost->sync_ist->st->index);
2258 if(ost->encoding_needed)
2259 fprintf(stderr, ": %s -> %s",
2260 input_streams[ost->source_index].dec ?
2261 input_streams[ost->source_index].dec->name : "?",
2262 ost->enc ? ost->enc->name : "?");
2264 fprintf(stderr, ": copy");
2265 fprintf(stderr, "\n");
2270 fprintf(stderr, "%s\n", error);
2275 print_sdp(output_files, nb_output_files);
2280 fprintf(stderr, "Press [q] to stop, [?] for help\n");
2281 avio_set_interrupt_cb(decode_interrupt_cb);
2285 timer_start = av_gettime();
2287 for(; received_sigterm == 0;) {
2288 int file_index, ist_index;
2294 ipts_min= INT64_MAX;
2296 /* if 'q' pressed, exits */
2300 /* read_key() returns 0 on EOF */
2304 if (key == '+') verbose++;
2305 if (key == '-') verbose--;
2306 if (key == 's') qp_hist ^= 1;
2309 do_hex_dump = do_pkt_dump = 0;
2310 } else if(do_pkt_dump){
2314 av_log_set_level(AV_LOG_DEBUG);
2316 if (key == 'c' || key == 'C'){
2317 char ret[4096], target[64], cmd[256], arg[256]={0};
2319 fprintf(stderr, "\nEnter command: <target> <time> <command>[ <argument>]\n");
2320 if(scanf("%4095[^\n\r]%*c", ret) == 1 && sscanf(ret, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &ts, cmd, arg) >= 3){
2321 for(i=0;i<nb_output_streams;i++) {
2323 ost = &output_streams[i];
2326 r= avfilter_graph_send_command(ost->graph, target, cmd, arg, ret, sizeof(ret), key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
2327 fprintf(stderr, "Command reply for %d: %d, %s\n", i, r, ret);
2329 r= avfilter_graph_queue_command(ost->graph, target, cmd, arg, 0, ts);
2334 fprintf(stderr, "Parse error\n");
2337 if (key == 'd' || key == 'D'){
2340 debug = input_streams[0].st->codec->debug<<1;
2341 if(!debug) debug = 1;
2342 while(debug & (FF_DEBUG_DCT_COEFF|FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE)) //unsupported, would just crash
2345 scanf("%d", &debug);
2346 for(i=0;i<nb_input_streams;i++) {
2347 input_streams[i].st->codec->debug = debug;
2349 for(i=0;i<nb_output_streams;i++) {
2350 ost = &output_streams[i];
2351 ost->st->codec->debug = debug;
2353 if(debug) av_log_set_level(AV_LOG_DEBUG);
2354 fprintf(stderr,"debug=%d\n", debug);
2357 fprintf(stderr, "key function\n"
2358 "? show this help\n"
2359 "+ increase verbosity\n"
2360 "- decrease verbosity\n"
2361 "c Send command to filtergraph\n"
2362 "D cycle through available debug modes\n"
2363 "h dump packets/hex press to cycle through the 3 states\n"
2365 "s Show QP histogram\n"
2370 /* select the stream that we must read now by looking at the
2371 smallest output pts */
2373 for (i = 0; i < nb_output_streams; i++) {
2376 ost = &output_streams[i];
2377 os = output_files[ost->file_index].ctx;
2378 ist = &input_streams[ost->source_index];
2379 if(ost->is_past_recording_time || no_packet[ist->file_index])
2381 opts = ost->st->pts.val * av_q2d(ost->st->time_base);
2383 if (!input_files[ist->file_index].eof_reached){
2384 if(ipts < ipts_min) {
2386 if(input_sync ) file_index = ist->file_index;
2388 if(opts < opts_min) {
2390 if(!input_sync) file_index = ist->file_index;
2393 if(ost->frame_number >= max_frames[ost->st->codec->codec_type]){
2398 /* if none, if is finished */
2399 if (file_index < 0) {
2400 if(no_packet_count){
2402 memset(no_packet, 0, nb_input_files);
2409 /* finish if limit size exhausted */
2410 if (limit_filesize != 0 && limit_filesize <= avio_tell(output_files[0].ctx->pb))
2413 /* read a frame from it and output it in the fifo */
2414 is = input_files[file_index].ctx;
2415 ret= av_read_frame(is, &pkt);
2416 if(ret == AVERROR(EAGAIN)){
2417 no_packet[file_index]=1;
2422 input_files[file_index].eof_reached = 1;
2430 memset(no_packet, 0, nb_input_files);
2433 av_pkt_dump_log2(NULL, AV_LOG_DEBUG, &pkt, do_hex_dump,
2434 is->streams[pkt.stream_index]);
2436 /* the following test is needed in case new streams appear
2437 dynamically in stream : we ignore them */
2438 if (pkt.stream_index >= input_files[file_index].nb_streams)
2439 goto discard_packet;
2440 ist_index = input_files[file_index].ist_index + pkt.stream_index;
2441 ist = &input_streams[ist_index];
2443 goto discard_packet;
2445 if (pkt.dts != AV_NOPTS_VALUE)
2446 pkt.dts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2447 if (pkt.pts != AV_NOPTS_VALUE)
2448 pkt.pts += av_rescale_q(input_files[ist->file_index].ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2450 if (ist->ts_scale) {
2451 if(pkt.pts != AV_NOPTS_VALUE)
2452 pkt.pts *= ist->ts_scale;
2453 if(pkt.dts != AV_NOPTS_VALUE)
2454 pkt.dts *= ist->ts_scale;
2457 // 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);
2458 if (pkt.dts != AV_NOPTS_VALUE && ist->next_pts != AV_NOPTS_VALUE
2459 && (is->iformat->flags & AVFMT_TS_DISCONT)) {
2460 int64_t pkt_dts= av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2461 int64_t delta= pkt_dts - ist->next_pts;
2462 if((delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
2463 (delta > 1LL*dts_delta_threshold*AV_TIME_BASE &&
2464 ist->st->codec->codec_type != AVMEDIA_TYPE_SUBTITLE) ||
2465 pkt_dts+1<ist->pts)&& !copy_ts){
2466 input_files[ist->file_index].ts_offset -= delta;
2468 fprintf(stderr, "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2469 delta, input_files[ist->file_index].ts_offset);
2470 pkt.dts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2471 if(pkt.pts != AV_NOPTS_VALUE)
2472 pkt.pts-= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2476 //fprintf(stderr,"read #%d.%d size=%d\n", ist->file_index, ist->st->index, pkt.size);
2477 if (output_packet(ist, ist_index, output_streams, nb_output_streams, &pkt) < 0) {
2480 fprintf(stderr, "Error while decoding stream #%d.%d\n",
2481 ist->file_index, ist->st->index);
2484 av_free_packet(&pkt);
2489 av_free_packet(&pkt);
2491 /* dump report by using the output first video and audio streams */
2492 print_report(output_files, output_streams, nb_output_streams, 0, timer_start);
2495 /* at the end of stream, we must flush the decoder buffers */
2496 for (i = 0; i < nb_input_streams; i++) {
2497 ist = &input_streams[i];
2498 if (ist->decoding_needed) {
2499 output_packet(ist, i, output_streams, nb_output_streams, NULL);
2505 /* write the trailer if needed and close file */
2506 for(i=0;i<nb_output_files;i++) {
2507 os = output_files[i].ctx;
2508 av_write_trailer(os);
2511 /* dump report by using the first video and audio streams */
2512 print_report(output_files, output_streams, nb_output_streams, 1, timer_start);
2514 /* close each encoder */
2515 for (i = 0; i < nb_output_streams; i++) {
2516 ost = &output_streams[i];
2517 if (ost->encoding_needed) {
2518 av_freep(&ost->st->codec->stats_in);
2519 avcodec_close(ost->st->codec);
2522 avfilter_graph_free(&ost->graph);
2526 /* close each decoder */
2527 for (i = 0; i < nb_input_streams; i++) {
2528 ist = &input_streams[i];
2529 if (ist->decoding_needed) {
2530 avcodec_close(ist->st->codec);
2538 av_freep(&bit_buffer);
2539 av_freep(&no_packet);
2541 if (output_streams) {
2542 for (i = 0; i < nb_output_streams; i++) {
2543 ost = &output_streams[i];
2545 if (ost->st->stream_copy)
2546 av_freep(&ost->st->codec->extradata);
2548 fclose(ost->logfile);
2549 ost->logfile = NULL;
2551 av_fifo_free(ost->fifo); /* works even if fifo is not
2552 initialized but set to zero */
2553 av_freep(&ost->st->codec->subtitle_header);
2554 av_free(ost->resample_frame.data[0]);
2555 av_free(ost->forced_kf_pts);
2556 if (ost->video_resample)
2557 sws_freeContext(ost->img_resample_ctx);
2559 audio_resample_close(ost->resample);
2560 if (ost->reformat_ctx)
2561 av_audio_convert_free(ost->reformat_ctx);
2562 av_dict_free(&ost->opts);
2569 static int opt_format(const char *opt, const char *arg)
2571 last_asked_format = arg;
2575 static int opt_video_rc_override_string(const char *opt, const char *arg)
2577 video_rc_override_string = arg;
2581 static int opt_me_threshold(const char *opt, const char *arg)
2583 me_threshold = parse_number_or_die(opt, arg, OPT_INT64, INT_MIN, INT_MAX);
2587 static int opt_verbose(const char *opt, const char *arg)
2589 verbose = parse_number_or_die(opt, arg, OPT_INT64, -10, 10);
2593 static int opt_frame_rate(const char *opt, const char *arg)
2595 if (av_parse_video_rate(&frame_rate, arg) < 0) {
2596 fprintf(stderr, "Incorrect value for %s: %s\n", opt, arg);
2602 static int opt_frame_crop(const char *opt, const char *arg)
2604 fprintf(stderr, "Option '%s' has been removed, use the crop filter instead\n", opt);
2605 return AVERROR(EINVAL);
2608 static int opt_frame_size(const char *opt, const char *arg)
2610 if (av_parse_video_size(&frame_width, &frame_height, arg) < 0) {
2611 fprintf(stderr, "Incorrect frame size\n");
2612 return AVERROR(EINVAL);
2617 static int opt_pad(const char *opt, const char *arg) {
2618 fprintf(stderr, "Option '%s' has been removed, use the pad filter instead\n", opt);
2622 static int opt_frame_pix_fmt(const char *opt, const char *arg)
2624 if (strcmp(arg, "list")) {
2625 frame_pix_fmt = av_get_pix_fmt(arg);
2626 if (frame_pix_fmt == PIX_FMT_NONE) {
2627 fprintf(stderr, "Unknown pixel format requested: %s\n", arg);
2628 return AVERROR(EINVAL);
2631 opt_pix_fmts(NULL, NULL);
2637 static int opt_frame_aspect_ratio(const char *opt, const char *arg)
2644 p = strchr(arg, ':');
2646 x = strtol(arg, &end, 10);
2648 y = strtol(end+1, &end, 10);
2650 ar = (double)x / (double)y;
2652 ar = strtod(arg, NULL);
2655 fprintf(stderr, "Incorrect aspect ratio specification.\n");
2656 return AVERROR(EINVAL);
2658 frame_aspect_ratio = ar;
2662 static int opt_metadata(const char *opt, const char *arg)
2664 char *mid= strchr(arg, '=');
2667 fprintf(stderr, "Missing =\n");
2672 av_dict_set(&metadata, arg, mid, 0);
2677 static int opt_qscale(const char *opt, const char *arg)
2679 video_qscale = parse_number_or_die(opt, arg, OPT_FLOAT, 0, 255);
2680 if (video_qscale <= 0 || video_qscale > 255) {
2681 fprintf(stderr, "qscale must be > 0.0 and <= 255\n");
2682 return AVERROR(EINVAL);
2687 static int opt_top_field_first(const char *opt, const char *arg)
2689 top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
2690 return opt_default(opt, arg);
2693 static int opt_thread_count(const char *opt, const char *arg)
2695 thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2698 fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
2703 static int opt_audio_sample_fmt(const char *opt, const char *arg)
2705 if (strcmp(arg, "list")) {
2706 audio_sample_fmt = av_get_sample_fmt(arg);
2707 if (audio_sample_fmt == AV_SAMPLE_FMT_NONE) {
2708 av_log(NULL, AV_LOG_ERROR, "Invalid sample format '%s'\n", arg);
2709 return AVERROR(EINVAL);
2714 for (i = -1; i < AV_SAMPLE_FMT_NB; i++)
2715 printf("%s\n", av_get_sample_fmt_string(fmt_str, sizeof(fmt_str), i));
2721 static int opt_audio_rate(const char *opt, const char *arg)
2723 audio_sample_rate = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2727 static int opt_audio_channels(const char *opt, const char *arg)
2729 audio_channels = parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
2733 static int opt_video_channel(const char *opt, const char *arg)
2735 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -channel.\n");
2736 return opt_default("channel", arg);
2739 static int opt_video_standard(const char *opt, const char *arg)
2741 av_log(NULL, AV_LOG_WARNING, "This option is deprecated, use -standard.\n");
2742 return opt_default("standard", arg);
2745 static int opt_codec(const char *opt, const char *arg)
2747 return av_dict_set(&codec_names, opt, arg, 0);
2750 static int opt_audio_codec(const char *opt, const char *arg)
2752 return opt_codec("codec:a", arg);
2755 static int opt_video_codec(const char *opt, const char *arg)
2757 return opt_codec("codec:v", arg);
2760 static int opt_subtitle_codec(const char *opt, const char *arg)
2762 return opt_codec("codec:s", arg);
2765 static int opt_data_codec(const char *opt, const char *arg)
2767 return opt_codec("codec:d", arg);
2770 static int opt_codec_tag(const char *opt, const char *arg)
2773 uint32_t *codec_tag;
2775 codec_tag = !strcmp(opt, "atag") ? &audio_codec_tag :
2776 !strcmp(opt, "vtag") ? &video_codec_tag :
2777 !strcmp(opt, "stag") ? &subtitle_codec_tag : NULL;
2781 *codec_tag = strtol(arg, &tail, 0);
2783 *codec_tag = AV_RL32(arg);
2788 static int opt_map(const char *opt, const char *arg)
2790 StreamMap *m = NULL;
2791 int i, negative = 0, file_idx;
2792 int sync_file_idx = -1, sync_stream_idx;
2800 map = av_strdup(arg);
2802 /* parse sync stream first, just pick first matching stream */
2803 if (sync = strchr(map, ',')) {
2805 sync_file_idx = strtol(sync + 1, &sync, 0);
2806 if (sync_file_idx >= nb_input_files || sync_file_idx < 0) {
2807 av_log(NULL, AV_LOG_ERROR, "Invalid sync file index: %d.\n", sync_file_idx);
2812 for (i = 0; i < input_files[sync_file_idx].ctx->nb_streams; i++)
2813 if (check_stream_specifier(input_files[sync_file_idx].ctx,
2814 input_files[sync_file_idx].ctx->streams[i], sync) == 1) {
2815 sync_stream_idx = i;
2818 if (i == input_files[sync_file_idx].ctx->nb_streams) {
2819 av_log(NULL, AV_LOG_ERROR, "Sync stream specification in map %s does not "
2820 "match any streams.\n", arg);
2826 file_idx = strtol(map, &p, 0);
2827 if (file_idx >= nb_input_files || file_idx < 0) {
2828 av_log(NULL, AV_LOG_ERROR, "Invalid input file index: %d.\n", file_idx);
2832 /* disable some already defined maps */
2833 for (i = 0; i < nb_stream_maps; i++) {
2834 m = &stream_maps[i];
2835 if (check_stream_specifier(input_files[m->file_index].ctx,
2836 input_files[m->file_index].ctx->streams[m->stream_index],
2837 *p == ':' ? p + 1 : p) > 0)
2841 for (i = 0; i < input_files[file_idx].ctx->nb_streams; i++) {
2842 if (check_stream_specifier(input_files[file_idx].ctx, input_files[file_idx].ctx->streams[i],
2843 *p == ':' ? p + 1 : p) <= 0)
2845 stream_maps = grow_array(stream_maps, sizeof(*stream_maps), &nb_stream_maps, nb_stream_maps + 1);
2846 m = &stream_maps[nb_stream_maps - 1];
2848 m->file_index = file_idx;
2849 m->stream_index = i;
2851 if (sync_file_idx >= 0) {
2852 m->sync_file_index = sync_file_idx;
2853 m->sync_stream_index = sync_stream_idx;
2855 m->sync_file_index = file_idx;
2856 m->sync_stream_index = i;
2861 av_log(NULL, AV_LOG_ERROR, "Stream map '%s' matches no streams.\n", arg);
2869 static void parse_meta_type(char *arg, char *type, int *index)
2879 if (*(++arg) == ':')
2880 *index = strtol(++arg, NULL, 0);
2883 fprintf(stderr, "Invalid metadata type %c.\n", *arg);
2890 static int opt_map_metadata(const char *opt, const char *arg)
2892 MetadataMap *m, *m1;
2895 meta_data_maps = grow_array(meta_data_maps, sizeof(*meta_data_maps),
2896 &nb_meta_data_maps, nb_meta_data_maps + 1);
2898 m = &meta_data_maps[nb_meta_data_maps - 1][1];
2899 m->file = strtol(arg, &p, 0);
2900 parse_meta_type(p, &m->type, &m->index);
2902 m1 = &meta_data_maps[nb_meta_data_maps - 1][0];
2903 if (p = strchr(opt, ':'))
2904 parse_meta_type(p, &m1->type, &m1->index);
2908 if (m->type == 'g' || m1->type == 'g')
2909 metadata_global_autocopy = 0;
2910 if (m->type == 's' || m1->type == 's')
2911 metadata_streams_autocopy = 0;
2912 if (m->type == 'c' || m1->type == 'c')
2913 metadata_chapters_autocopy = 0;
2918 static int opt_map_meta_data(const char *opt, const char *arg)
2920 fprintf(stderr, "-map_meta_data is deprecated and will be removed soon. "
2921 "Use -map_metadata instead.\n");
2922 return opt_map_metadata(opt, arg);
2925 static int opt_input_ts_scale(const char *opt, const char *arg)
2927 return av_dict_set(&ts_scale, opt, arg, 0);
2930 static int opt_recording_time(const char *opt, const char *arg)
2932 recording_time = parse_time_or_die(opt, arg, 1);
2936 static int opt_start_time(const char *opt, const char *arg)
2938 start_time = parse_time_or_die(opt, arg, 1);
2942 static int opt_recording_timestamp(const char *opt, const char *arg)
2945 int64_t recording_timestamp = parse_time_or_die(opt, arg, 0) / 1E6;
2946 struct tm time = *gmtime((time_t*)&recording_timestamp);
2947 strftime(buf, sizeof(buf), "creation_time=%FT%T%z", &time);
2948 opt_metadata("metadata", buf);
2950 av_log(NULL, AV_LOG_WARNING, "%s is deprecated, set the 'creation_time' metadata "
2951 "tag instead.\n", opt);
2955 static int opt_input_ts_offset(const char *opt, const char *arg)
2957 input_ts_offset = parse_time_or_die(opt, arg, 1);
2961 static enum CodecID find_codec_or_die(const char *name, enum AVMediaType type, int encoder)
2963 const char *codec_string = encoder ? "encoder" : "decoder";
2967 return CODEC_ID_NONE;
2969 avcodec_find_encoder_by_name(name) :
2970 avcodec_find_decoder_by_name(name);
2972 av_log(NULL, AV_LOG_ERROR, "Unknown %s '%s'\n", codec_string, name);
2975 if(codec->type != type) {
2976 av_log(NULL, AV_LOG_ERROR, "Invalid %s type '%s'\n", codec_string, name);
2982 static AVCodec *choose_codec(AVFormatContext *s, AVStream *st, enum AVMediaType type, AVDictionary *codec_names)
2984 AVDictionaryEntry *e = NULL;
2985 char *codec_name = NULL;
2988 while (e = av_dict_get(codec_names, "", e, AV_DICT_IGNORE_SUFFIX)) {
2989 char *p = strchr(e->key, ':');
2991 if ((ret = check_stream_specifier(s, st, p ? p + 1 : "")) > 0)
2992 codec_name = e->value;
2999 st->codec->codec_id = av_guess_codec(s->oformat, NULL, s->filename, NULL, type);
3000 return avcodec_find_encoder(st->codec->codec_id);
3002 } else if (!strcmp(codec_name, "copy"))
3003 st->stream_copy = 1;
3005 st->codec->codec_id = find_codec_or_die(codec_name, type, s->iformat == NULL);
3006 return s->oformat ? avcodec_find_encoder_by_name(codec_name) :
3007 avcodec_find_decoder_by_name(codec_name);
3014 * Add all the streams from the given input file to the global
3015 * list of input streams.
3017 static void add_input_streams(AVFormatContext *ic)
3019 int i, rfps, rfps_base, ret;
3021 for (i = 0; i < ic->nb_streams; i++) {
3022 AVStream *st = ic->streams[i];
3023 AVCodecContext *dec = st->codec;
3024 AVDictionaryEntry *e = NULL;
3028 dec->thread_count = thread_count;
3030 input_streams = grow_array(input_streams, sizeof(*input_streams), &nb_input_streams, nb_input_streams + 1);
3031 ist = &input_streams[nb_input_streams - 1];
3033 ist->file_index = nb_input_files;
3035 ist->opts = filter_codec_opts(codec_opts, ist->st->codec->codec_id, ic, st);
3037 while (e = av_dict_get(ts_scale, "", e, AV_DICT_IGNORE_SUFFIX)) {
3038 char *p = strchr(e->key, ':');
3040 if ((ret = check_stream_specifier(ic, st, p ? p + 1 : "")) > 0)
3046 ist->ts_scale = strtod(scale, NULL);
3048 ist->dec = choose_codec(ic, st, dec->codec_type, codec_names);
3050 switch (dec->codec_type) {
3051 case AVMEDIA_TYPE_AUDIO:
3053 ist->dec = avcodec_find_decoder(dec->codec_id);
3055 st->discard= AVDISCARD_ALL;
3057 case AVMEDIA_TYPE_VIDEO:
3059 ist->dec = avcodec_find_decoder(dec->codec_id);
3060 rfps = ic->streams[i]->r_frame_rate.num;
3061 rfps_base = ic->streams[i]->r_frame_rate.den;
3063 dec->flags |= CODEC_FLAG_EMU_EDGE;
3066 dec->debug |= FF_DEBUG_MV;
3068 if (dec->time_base.den != rfps*dec->ticks_per_frame || dec->time_base.num != rfps_base) {
3071 fprintf(stderr,"\nSeems stream %d codec frame rate differs from container frame rate: %2.2f (%d/%d) -> %2.2f (%d/%d)\n",
3072 i, (float)dec->time_base.den / dec->time_base.num, dec->time_base.den, dec->time_base.num,
3074 (float)rfps / rfps_base, rfps, rfps_base);
3078 st->discard= AVDISCARD_ALL;
3079 else if(video_discard)
3080 st->discard= video_discard;
3082 case AVMEDIA_TYPE_DATA:
3084 case AVMEDIA_TYPE_SUBTITLE:
3086 ist->dec = avcodec_find_decoder(dec->codec_id);
3087 if(subtitle_disable)
3088 st->discard = AVDISCARD_ALL;
3090 case AVMEDIA_TYPE_ATTACHMENT:
3091 case AVMEDIA_TYPE_UNKNOWN:
3099 static int opt_input_file(const char *opt, const char *filename)
3101 AVFormatContext *ic;
3102 AVInputFormat *file_iformat = NULL;
3106 AVDictionary **opts;
3107 int orig_nb_streams; // number of streams before avformat_find_stream_info
3109 if (last_asked_format) {
3110 if (!(file_iformat = av_find_input_format(last_asked_format))) {
3111 fprintf(stderr, "Unknown input format: '%s'\n", last_asked_format);
3114 last_asked_format = NULL;
3117 if (!strcmp(filename, "-"))
3120 using_stdin |= !strncmp(filename, "pipe:", 5) ||
3121 !strcmp(filename, "/dev/stdin");
3123 /* get default parameters from command line */
3124 ic = avformat_alloc_context();
3126 print_error(filename, AVERROR(ENOMEM));
3129 if (audio_sample_rate) {
3130 snprintf(buf, sizeof(buf), "%d", audio_sample_rate);
3131 av_dict_set(&format_opts, "sample_rate", buf, 0);
3133 if (audio_channels) {
3134 snprintf(buf, sizeof(buf), "%d", audio_channels);
3135 av_dict_set(&format_opts, "channels", buf, 0);
3137 if (frame_rate.num) {
3138 snprintf(buf, sizeof(buf), "%d/%d", frame_rate.num, frame_rate.den);
3139 av_dict_set(&format_opts, "framerate", buf, 0);
3141 if (frame_width && frame_height) {
3142 snprintf(buf, sizeof(buf), "%dx%d", frame_width, frame_height);
3143 av_dict_set(&format_opts, "video_size", buf, 0);
3145 if (frame_pix_fmt != PIX_FMT_NONE)
3146 av_dict_set(&format_opts, "pixel_format", av_get_pix_fmt_name(frame_pix_fmt), 0);
3148 ic->flags |= AVFMT_FLAG_NONBLOCK;
3151 av_log(NULL, AV_LOG_WARNING, "-loop_input is deprecated, use -loop 1\n");
3152 ic->loop_input = loop_input;
3155 /* open the input file with generic libav function */
3156 err = avformat_open_input(&ic, filename, file_iformat, &format_opts);
3158 print_error(filename, err);
3161 assert_avoptions(format_opts);
3166 for(i=0; i<ic->nb_streams; i++){
3167 ic->streams[i]->discard= AVDISCARD_ALL;
3169 for(i=0; i<ic->nb_programs; i++){
3170 AVProgram *p= ic->programs[i];
3171 if(p->id != opt_programid){
3172 p->discard = AVDISCARD_ALL;
3175 for(j=0; j<p->nb_stream_indexes; j++){
3176 ic->streams[p->stream_index[j]]->discard= AVDISCARD_DEFAULT;
3181 fprintf(stderr, "Specified program id not found\n");
3187 /* apply forced codec ids */
3188 for (i = 0; i < ic->nb_streams; i++)
3189 choose_codec(ic, ic->streams[i], ic->streams[i]->codec->codec_type, codec_names);
3191 /* Set AVCodecContext options for avformat_find_stream_info */
3192 opts = setup_find_stream_info_opts(ic, codec_opts);
3193 orig_nb_streams = ic->nb_streams;
3195 /* If not enough info to get the stream parameters, we decode the
3196 first frames to get it. (used in mpeg case for example) */
3197 ret = avformat_find_stream_info(ic, opts);
3198 if (ret < 0 && verbose >= 0) {
3199 fprintf(stderr, "%s: could not find codec parameters\n", filename);
3200 av_close_input_file(ic);
3204 timestamp = start_time;
3205 /* add the stream start time */
3206 if (ic->start_time != AV_NOPTS_VALUE)
3207 timestamp += ic->start_time;
3209 /* if seeking requested, we execute it */
3210 if (start_time != 0) {
3211 ret = av_seek_frame(ic, -1, timestamp, AVSEEK_FLAG_BACKWARD);
3213 fprintf(stderr, "%s: could not seek to position %0.3f\n",
3214 filename, (double)timestamp / AV_TIME_BASE);
3216 /* reset seek info */
3220 /* update the current parameters so that they match the one of the input stream */
3221 add_input_streams(ic);
3223 /* dump the file content */
3225 av_dump_format(ic, nb_input_files, filename, 0);
3227 input_files = grow_array(input_files, sizeof(*input_files), &nb_input_files, nb_input_files + 1);
3228 input_files[nb_input_files - 1].ctx = ic;
3229 input_files[nb_input_files - 1].ist_index = nb_input_streams - ic->nb_streams;
3230 input_files[nb_input_files - 1].ts_offset = input_ts_offset - (copy_ts ? 0 : timestamp);
3231 input_files[nb_input_files - 1].nb_streams = ic->nb_streams;
3233 top_field_first = -1;
3234 frame_rate = (AVRational){0, 0};
3235 frame_pix_fmt = PIX_FMT_NONE;
3238 audio_sample_rate = 0;
3240 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3241 av_dict_free(&ts_scale);
3243 for (i = 0; i < orig_nb_streams; i++)
3244 av_dict_free(&opts[i]);
3246 av_dict_free(&codec_names);
3252 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3253 AVCodecContext *avctx)
3259 for (p = kf; *p; p++)
3262 ost->forced_kf_count = n;
3263 ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
3264 if (!ost->forced_kf_pts) {
3265 av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3268 for (i = 0; i < n; i++) {
3269 p = i ? strchr(p, ',') + 1 : kf;
3270 t = parse_time_or_die("force_key_frames", p, 1);
3271 ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3275 static OutputStream *new_output_stream(AVFormatContext *oc, enum AVMediaType type)
3278 AVStream *st = av_new_stream(oc, oc->nb_streams < nb_streamid_map ? streamid_map[oc->nb_streams] : 0);
3279 int idx = oc->nb_streams - 1;
3282 av_log(NULL, AV_LOG_ERROR, "Could not alloc stream.\n");
3286 output_streams = grow_array(output_streams, sizeof(*output_streams), &nb_output_streams,
3287 nb_output_streams + 1);
3288 ost = &output_streams[nb_output_streams - 1];
3289 ost->file_index = nb_output_files;
3292 st->codec->codec_type = type;
3293 ost->enc = choose_codec(oc, st, type, codec_names);
3295 ost->opts = filter_codec_opts(codec_opts, ost->enc->id, oc, st);
3298 avcodec_get_context_defaults3(st->codec, ost->enc);
3299 st->codec->codec_type = type; // XXX hack, avcodec_get_context_defaults2() sets type to unknown for stream copy
3301 ost->sws_flags = av_get_int(sws_opts, "sws_flags", NULL);
3305 static OutputStream *new_video_stream(AVFormatContext *oc)
3309 AVCodecContext *video_enc;
3311 ost = new_output_stream(oc, AVMEDIA_TYPE_VIDEO);
3313 if (!st->stream_copy) {
3314 ost->frame_aspect_ratio = frame_aspect_ratio;
3315 frame_aspect_ratio = 0;
3317 ost->avfilter = vfilters;
3322 ost->bitstream_filters = video_bitstream_filters;
3323 video_bitstream_filters= NULL;
3325 st->codec->thread_count= thread_count;
3327 video_enc = st->codec;
3330 video_enc->codec_tag= video_codec_tag;
3332 if(oc->oformat->flags & AVFMT_GLOBALHEADER) {
3333 video_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3336 if (st->stream_copy) {
3337 video_enc->sample_aspect_ratio =
3338 st->sample_aspect_ratio = av_d2q(frame_aspect_ratio*frame_height/frame_width, 255);
3344 ost->frame_rate = frame_rate;
3346 video_enc->width = frame_width;
3347 video_enc->height = frame_height;
3348 video_enc->pix_fmt = frame_pix_fmt;
3349 video_enc->bits_per_raw_sample = frame_bits_per_raw_sample;
3350 st->sample_aspect_ratio = video_enc->sample_aspect_ratio;
3353 video_enc->gop_size = 0;
3354 if (video_qscale || same_quant) {
3355 video_enc->flags |= CODEC_FLAG_QSCALE;
3356 video_enc->global_quality = FF_QP2LAMBDA * video_qscale;
3360 video_enc->intra_matrix = intra_matrix;
3362 video_enc->inter_matrix = inter_matrix;
3364 p= video_rc_override_string;
3367 int e=sscanf(p, "%d,%d,%d", &start, &end, &q);
3369 fprintf(stderr, "error parsing rc_override\n");
3372 video_enc->rc_override=
3373 av_realloc(video_enc->rc_override,
3374 sizeof(RcOverride)*(i+1));
3375 video_enc->rc_override[i].start_frame= start;
3376 video_enc->rc_override[i].end_frame = end;
3378 video_enc->rc_override[i].qscale= q;
3379 video_enc->rc_override[i].quality_factor= 1.0;
3382 video_enc->rc_override[i].qscale= 0;
3383 video_enc->rc_override[i].quality_factor= -q/100.0;
3388 video_enc->rc_override_count=i;
3389 if (!video_enc->rc_initial_buffer_occupancy)
3390 video_enc->rc_initial_buffer_occupancy = video_enc->rc_buffer_size*3/4;
3391 video_enc->me_threshold= me_threshold;
3392 video_enc->intra_dc_precision= intra_dc_precision - 8;
3395 video_enc->flags|= CODEC_FLAG_PSNR;
3400 video_enc->flags |= CODEC_FLAG_PASS1;
3402 video_enc->flags |= CODEC_FLAG_PASS2;
3406 if (forced_key_frames)
3407 parse_forced_key_frames(forced_key_frames, ost, video_enc);
3409 if (video_language) {
3410 av_dict_set(&st->metadata, "language", video_language, 0);
3411 av_freep(&video_language);
3414 /* reset some key parameters */
3416 av_freep(&forced_key_frames);
3417 frame_pix_fmt = PIX_FMT_NONE;
3421 static OutputStream *new_audio_stream(AVFormatContext *oc)
3425 AVCodecContext *audio_enc;
3427 ost = new_output_stream(oc, AVMEDIA_TYPE_AUDIO);
3430 ost->bitstream_filters = audio_bitstream_filters;
3431 audio_bitstream_filters= NULL;
3433 st->codec->thread_count= thread_count;
3435 audio_enc = st->codec;
3436 audio_enc->codec_type = AVMEDIA_TYPE_AUDIO;
3439 audio_enc->codec_tag= audio_codec_tag;
3441 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3442 audio_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3444 if (!st->stream_copy) {
3445 if (audio_qscale > QSCALE_NONE) {
3446 audio_enc->flags |= CODEC_FLAG_QSCALE;
3447 audio_enc->global_quality = FF_QP2LAMBDA * audio_qscale;
3450 audio_enc->channels = audio_channels;
3451 if (audio_sample_fmt != AV_SAMPLE_FMT_NONE)
3452 audio_enc->sample_fmt = audio_sample_fmt;
3453 if (audio_sample_rate)
3454 audio_enc->sample_rate = audio_sample_rate;
3456 if (audio_language) {
3457 av_dict_set(&st->metadata, "language", audio_language, 0);
3458 av_freep(&audio_language);
3461 /* reset some key parameters */
3467 static OutputStream *new_data_stream(AVFormatContext *oc)
3471 AVCodecContext *data_enc;
3473 ost = new_output_stream(oc, AVMEDIA_TYPE_DATA);
3475 data_enc = st->codec;
3476 if (!st->stream_copy) {
3477 fprintf(stderr, "Data stream encoding not supported yet (only streamcopy)\n");
3482 data_enc->codec_tag= data_codec_tag;
3484 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3485 data_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3492 static OutputStream *new_subtitle_stream(AVFormatContext *oc)
3496 AVCodecContext *subtitle_enc;
3498 ost = new_output_stream(oc, AVMEDIA_TYPE_SUBTITLE);
3500 subtitle_enc = st->codec;
3502 ost->bitstream_filters = subtitle_bitstream_filters;
3503 subtitle_bitstream_filters= NULL;
3505 subtitle_enc->codec_type = AVMEDIA_TYPE_SUBTITLE;
3507 if(subtitle_codec_tag)
3508 subtitle_enc->codec_tag= subtitle_codec_tag;
3510 if (oc->oformat->flags & AVFMT_GLOBALHEADER) {
3511 subtitle_enc->flags |= CODEC_FLAG_GLOBAL_HEADER;
3514 if (subtitle_language) {
3515 av_dict_set(&st->metadata, "language", subtitle_language, 0);
3516 av_freep(&subtitle_language);
3519 subtitle_disable = 0;
3523 /* arg format is "output-stream-index:streamid-value". */
3524 static int opt_streamid(const char *opt, const char *arg)
3530 av_strlcpy(idx_str, arg, sizeof(idx_str));
3531 p = strchr(idx_str, ':');
3534 "Invalid value '%s' for option '%s', required syntax is 'index:value'\n",
3539 idx = parse_number_or_die(opt, idx_str, OPT_INT, 0, MAX_STREAMS-1);
3540 streamid_map = grow_array(streamid_map, sizeof(*streamid_map), &nb_streamid_map, idx+1);
3541 streamid_map[idx] = parse_number_or_die(opt, p, OPT_INT, 0, INT_MAX);
3544 static int read_ffserver_streams(AVFormatContext *s, const char *filename)
3547 AVFormatContext *ic = NULL;
3549 err = avformat_open_input(&ic, filename, NULL, NULL);
3552 /* copy stream format */
3553 for(i=0;i<ic->nb_streams;i++) {
3558 codec = avcodec_find_encoder(ic->streams[i]->codec->codec_id);
3559 ost = new_output_stream(s, codec->type);
3562 // FIXME: a more elegant solution is needed
3563 memcpy(st, ic->streams[i], sizeof(AVStream));
3564 st->info = av_malloc(sizeof(*st->info));
3565 memcpy(st->info, ic->streams[i]->info, sizeof(*st->info));
3566 avcodec_copy_context(st->codec, ic->streams[i]->codec);
3568 if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO && !st->stream_copy)
3569 choose_sample_fmt(st, codec);
3570 else if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO && !st->stream_copy)
3571 choose_pixel_fmt(st, codec);
3574 av_close_input_file(ic);
3579 static int copy_chapters(int infile, int outfile)
3581 AVFormatContext *is = input_files[infile].ctx;
3582 AVFormatContext *os = output_files[outfile].ctx;
3585 for (i = 0; i < is->nb_chapters; i++) {
3586 AVChapter *in_ch = is->chapters[i], *out_ch;
3587 int64_t ts_off = av_rescale_q(start_time - input_files[infile].ts_offset,
3588 AV_TIME_BASE_Q, in_ch->time_base);
3589 int64_t rt = (recording_time == INT64_MAX) ? INT64_MAX :
3590 av_rescale_q(recording_time, AV_TIME_BASE_Q, in_ch->time_base);
3593 if (in_ch->end < ts_off)
3595 if (rt != INT64_MAX && in_ch->start > rt + ts_off)
3598 out_ch = av_mallocz(sizeof(AVChapter));
3600 return AVERROR(ENOMEM);
3602 out_ch->id = in_ch->id;
3603 out_ch->time_base = in_ch->time_base;
3604 out_ch->start = FFMAX(0, in_ch->start - ts_off);
3605 out_ch->end = FFMIN(rt, in_ch->end - ts_off);
3607 if (metadata_chapters_autocopy)
3608 av_dict_copy(&out_ch->metadata, in_ch->metadata, 0);
3611 os->chapters = av_realloc(os->chapters, sizeof(AVChapter)*os->nb_chapters);
3613 return AVERROR(ENOMEM);
3614 os->chapters[os->nb_chapters - 1] = out_ch;
3619 static int opt_output_file(const char *opt, const char *filename)
3621 AVFormatContext *oc;
3623 AVOutputFormat *file_oformat;
3627 if (!strcmp(filename, "-"))
3630 err = avformat_alloc_output_context2(&oc, NULL, last_asked_format, filename);
3631 last_asked_format = NULL;
3633 print_error(filename, err);
3636 file_oformat= oc->oformat;
3638 if (!strcmp(file_oformat->name, "ffm") &&
3639 av_strstart(filename, "http:", NULL)) {
3640 /* special case for files sent to ffserver: we get the stream
3641 parameters from ffserver */
3642 int err = read_ffserver_streams(oc, filename);
3644 print_error(filename, err);
3647 } else if (!nb_stream_maps) {
3648 /* pick the "best" stream of each type */
3649 #define NEW_STREAM(type, index)\
3651 ost = new_ ## type ## _stream(oc);\
3652 ost->source_index = index;\
3653 ost->sync_ist = &input_streams[index];\
3654 input_streams[index].discard = 0;\
3657 /* video: highest resolution */
3658 if (!video_disable && oc->oformat->video_codec != CODEC_ID_NONE) {
3659 int area = 0, idx = -1;
3660 for (i = 0; i < nb_input_streams; i++) {
3661 ist = &input_streams[i];
3662 if (ist->st->codec->codec_type == AVMEDIA_TYPE_VIDEO &&
3663 ist->st->codec->width * ist->st->codec->height > area) {
3664 area = ist->st->codec->width * ist->st->codec->height;
3668 NEW_STREAM(video, idx);
3671 /* audio: most channels */
3672 if (!audio_disable && oc->oformat->audio_codec != CODEC_ID_NONE) {
3673 int channels = 0, idx = -1;
3674 for (i = 0; i < nb_input_streams; i++) {
3675 ist = &input_streams[i];
3676 if (ist->st->codec->codec_type == AVMEDIA_TYPE_AUDIO &&
3677 ist->st->codec->channels > channels) {
3678 channels = ist->st->codec->channels;
3682 NEW_STREAM(audio, idx);
3685 /* subtitles: pick first */
3686 if (!subtitle_disable && oc->oformat->subtitle_codec != CODEC_ID_NONE) {
3687 for (i = 0; i < nb_input_streams; i++)
3688 if (input_streams[i].st->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
3689 NEW_STREAM(subtitle, i);
3693 /* do something with data? */
3695 for (i = 0; i < nb_stream_maps; i++) {
3696 StreamMap *map = &stream_maps[i];
3701 ist = &input_streams[input_files[map->file_index].ist_index + map->stream_index];
3702 switch (ist->st->codec->codec_type) {
3703 case AVMEDIA_TYPE_VIDEO: ost = new_video_stream(oc); break;
3704 case AVMEDIA_TYPE_AUDIO: ost = new_audio_stream(oc); break;
3705 case AVMEDIA_TYPE_SUBTITLE: ost = new_subtitle_stream(oc); break;
3706 case AVMEDIA_TYPE_DATA: ost = new_data_stream(oc); break;
3708 av_log(NULL, AV_LOG_ERROR, "Cannot map stream #%d.%d - unsupported type.\n",
3709 map->file_index, map->stream_index);
3713 ost->source_index = input_files[map->file_index].ist_index + map->stream_index;
3714 ost->sync_ist = &input_streams[input_files[map->sync_file_index].ist_index +
3715 map->sync_stream_index];
3720 av_dict_copy(&oc->metadata, metadata, 0);
3721 av_dict_free(&metadata);
3724 output_files = grow_array(output_files, sizeof(*output_files), &nb_output_files, nb_output_files + 1);
3725 output_files[nb_output_files - 1].ctx = oc;
3726 output_files[nb_output_files - 1].ost_index = nb_output_streams - oc->nb_streams;
3727 output_files[nb_output_files - 1].recording_time = recording_time;
3728 output_files[nb_output_files - 1].start_time = start_time;
3729 av_dict_copy(&output_files[nb_output_files - 1].opts, format_opts, 0);
3731 /* check filename in case of an image number is expected */
3732 if (oc->oformat->flags & AVFMT_NEEDNUMBER) {
3733 if (!av_filename_number_test(oc->filename)) {
3734 print_error(oc->filename, AVERROR(EINVAL));
3739 if (!(oc->oformat->flags & AVFMT_NOFILE)) {
3740 /* test if it already exists to avoid loosing precious files */
3741 if (!file_overwrite &&
3742 (strchr(filename, ':') == NULL ||
3743 filename[1] == ':' ||
3744 av_strstart(filename, "file:", NULL))) {
3745 if (avio_check(filename, 0) == 0) {
3747 fprintf(stderr,"File '%s' already exists. Overwrite ? [y/N] ", filename);
3749 if (!read_yesno()) {
3750 fprintf(stderr, "Not overwriting - exiting\n");
3755 fprintf(stderr,"File '%s' already exists. Exiting.\n", filename);
3762 if ((err = avio_open(&oc->pb, filename, AVIO_FLAG_WRITE)) < 0) {
3763 print_error(filename, err);
3768 oc->preload= (int)(mux_preload*AV_TIME_BASE);
3769 oc->max_delay= (int)(mux_max_delay*AV_TIME_BASE);
3771 if (loop_output >= 0) {
3772 av_log(NULL, AV_LOG_WARNING, "-loop_output is deprecated, use -loop\n");
3773 oc->loop_output = loop_output;
3777 if (chapters_input_file >= nb_input_files) {
3778 if (chapters_input_file == INT_MAX) {
3779 /* copy chapters from the first input file that has them*/
3780 chapters_input_file = -1;
3781 for (i = 0; i < nb_input_files; i++)
3782 if (input_files[i].ctx->nb_chapters) {
3783 chapters_input_file = i;
3787 av_log(NULL, AV_LOG_ERROR, "Invalid input file index %d in chapter mapping.\n",
3788 chapters_input_file);
3792 if (chapters_input_file >= 0)
3793 copy_chapters(chapters_input_file, nb_output_files - 1);
3796 for (i = 0; i < nb_meta_data_maps; i++) {
3797 AVFormatContext *files[2];
3798 AVDictionary **meta[2];
3801 #define METADATA_CHECK_INDEX(index, nb_elems, desc)\
3802 if ((index) < 0 || (index) >= (nb_elems)) {\
3803 av_log(NULL, AV_LOG_ERROR, "Invalid %s index %d while processing metadata maps\n",\
3808 int in_file_index = meta_data_maps[i][1].file;
3809 if (in_file_index < 0)
3811 METADATA_CHECK_INDEX(in_file_index, nb_input_files, "input file")
3814 files[1] = input_files[in_file_index].ctx;
3816 for (j = 0; j < 2; j++) {
3817 MetadataMap *map = &meta_data_maps[i][j];
3819 switch (map->type) {
3821 meta[j] = &files[j]->metadata;
3824 METADATA_CHECK_INDEX(map->index, files[j]->nb_streams, "stream")
3825 meta[j] = &files[j]->streams[map->index]->metadata;
3828 METADATA_CHECK_INDEX(map->index, files[j]->nb_chapters, "chapter")
3829 meta[j] = &files[j]->chapters[map->index]->metadata;
3832 METADATA_CHECK_INDEX(map->index, files[j]->nb_programs, "program")
3833 meta[j] = &files[j]->programs[map->index]->metadata;
3838 av_dict_copy(meta[0], *meta[1], AV_DICT_DONT_OVERWRITE);
3841 /* copy global metadata by default */
3842 if (metadata_global_autocopy && nb_input_files)
3843 av_dict_copy(&oc->metadata, input_files[0].ctx->metadata,
3844 AV_DICT_DONT_OVERWRITE);
3845 if (metadata_streams_autocopy)
3846 for (i = output_files[nb_output_files - 1].ost_index; i < nb_output_streams; i++) {
3847 InputStream *ist = &input_streams[output_streams[i].source_index];
3848 av_dict_copy(&output_streams[i].st->metadata, ist->st->metadata, AV_DICT_DONT_OVERWRITE);
3851 frame_rate = (AVRational){0, 0};
3854 audio_sample_rate = 0;
3856 audio_sample_fmt = AV_SAMPLE_FMT_NONE;
3857 chapters_input_file = INT_MAX;
3858 recording_time = INT64_MAX;
3861 av_freep(&meta_data_maps);
3862 nb_meta_data_maps = 0;
3863 metadata_global_autocopy = 1;
3864 metadata_streams_autocopy = 1;
3865 metadata_chapters_autocopy = 1;
3866 av_freep(&stream_maps);
3868 av_freep(&streamid_map);
3869 nb_streamid_map = 0;
3871 av_dict_free(&codec_names);
3873 av_freep(&forced_key_frames);
3879 /* same option as mencoder */
3880 static int opt_pass(const char *opt, const char *arg)
3882 do_pass = parse_number_or_die(opt, arg, OPT_INT, 1, 2);
3886 static int64_t getutime(void)
3889 struct rusage rusage;
3891 getrusage(RUSAGE_SELF, &rusage);
3892 return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
3893 #elif HAVE_GETPROCESSTIMES
3895 FILETIME c, e, k, u;
3896 proc = GetCurrentProcess();
3897 GetProcessTimes(proc, &c, &e, &k, &u);
3898 return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
3900 return av_gettime();
3904 static int64_t getmaxrss(void)
3906 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
3907 struct rusage rusage;
3908 getrusage(RUSAGE_SELF, &rusage);
3909 return (int64_t)rusage.ru_maxrss * 1024;
3910 #elif HAVE_GETPROCESSMEMORYINFO
3912 PROCESS_MEMORY_COUNTERS memcounters;
3913 proc = GetCurrentProcess();
3914 memcounters.cb = sizeof(memcounters);
3915 GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
3916 return memcounters.PeakPagefileUsage;
3922 static void parse_matrix_coeffs(uint16_t *dest, const char *str)
3925 const char *p = str;
3932 fprintf(stderr, "Syntax error in matrix \"%s\" at coeff %d\n", str, i);
3939 static int opt_inter_matrix(const char *opt, const char *arg)
3941 inter_matrix = av_mallocz(sizeof(uint16_t) * 64);
3942 parse_matrix_coeffs(inter_matrix, arg);
3946 static int opt_intra_matrix(const char *opt, const char *arg)
3948 intra_matrix = av_mallocz(sizeof(uint16_t) * 64);
3949 parse_matrix_coeffs(intra_matrix, arg);
3953 static void show_usage(void)
3955 printf("Hyper fast Audio and Video encoder\n");
3956 printf("usage: %s [options] [[infile options] -i infile]... {[outfile options] outfile}...\n", program_name);
3960 static int opt_help(const char *opt, const char *arg)
3963 AVOutputFormat *oformat = NULL;
3964 AVInputFormat *iformat = NULL;
3966 av_log_set_callback(log_callback_help);
3968 show_help_options(options, "Main options:\n",
3969 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB, 0);
3970 show_help_options(options, "\nAdvanced options:\n",
3971 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_SUBTITLE | OPT_GRAB,
3973 show_help_options(options, "\nVideo options:\n",
3974 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3976 show_help_options(options, "\nAdvanced Video options:\n",
3977 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3978 OPT_VIDEO | OPT_EXPERT);
3979 show_help_options(options, "\nAudio options:\n",
3980 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3982 show_help_options(options, "\nAdvanced Audio options:\n",
3983 OPT_EXPERT | OPT_AUDIO | OPT_VIDEO | OPT_GRAB,
3984 OPT_AUDIO | OPT_EXPERT);
3985 show_help_options(options, "\nSubtitle options:\n",
3986 OPT_SUBTITLE | OPT_GRAB,
3988 show_help_options(options, "\nAudio/Video grab options:\n",
3992 av_opt_show2(avcodec_opts[0], NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
3995 /* individual codec options */
3997 while ((c = av_codec_next(c))) {
3998 if (c->priv_class) {
3999 av_opt_show2(&c->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4004 av_opt_show2(avformat_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4007 /* individual muxer options */
4008 while ((oformat = av_oformat_next(oformat))) {
4009 if (oformat->priv_class) {
4010 av_opt_show2(&oformat->priv_class, NULL, AV_OPT_FLAG_ENCODING_PARAM, 0);
4015 /* individual demuxer options */
4016 while ((iformat = av_iformat_next(iformat))) {
4017 if (iformat->priv_class) {
4018 av_opt_show2(&iformat->priv_class, NULL, AV_OPT_FLAG_DECODING_PARAM, 0);
4023 av_opt_show2(sws_opts, NULL, AV_OPT_FLAG_ENCODING_PARAM|AV_OPT_FLAG_DECODING_PARAM, 0);
4027 static int opt_target(const char *opt, const char *arg)
4029 enum { PAL, NTSC, FILM, UNKNOWN } norm = UNKNOWN;
4030 static const char *const frame_rates[] = {"25", "30000/1001", "24000/1001"};
4032 if(!strncmp(arg, "pal-", 4)) {
4035 } else if(!strncmp(arg, "ntsc-", 5)) {
4038 } else if(!strncmp(arg, "film-", 5)) {
4043 /* Calculate FR via float to avoid int overflow */
4044 fr = (int)(frame_rate.num * 1000.0 / frame_rate.den);
4047 } else if((fr == 29970) || (fr == 23976)) {
4050 /* Try to determine PAL/NTSC by peeking in the input files */
4051 if(nb_input_files) {
4053 for (j = 0; j < nb_input_files; j++) {
4054 for (i = 0; i < input_files[j].ctx->nb_streams; i++) {
4055 AVCodecContext *c = input_files[j].ctx->streams[i]->codec;
4056 if(c->codec_type != AVMEDIA_TYPE_VIDEO)
4058 fr = c->time_base.den * 1000 / c->time_base.num;
4062 } else if((fr == 29970) || (fr == 23976)) {
4072 if(verbose > 0 && norm != UNKNOWN)
4073 fprintf(stderr, "Assuming %s for target.\n", norm == PAL ? "PAL" : "NTSC");
4076 if(norm == UNKNOWN) {
4077 fprintf(stderr, "Could not determine norm (PAL/NTSC/NTSC-Film) for target.\n");
4078 fprintf(stderr, "Please prefix target with \"pal-\", \"ntsc-\" or \"film-\",\n");
4079 fprintf(stderr, "or set a framerate with \"-r xxx\".\n");
4083 if(!strcmp(arg, "vcd")) {
4084 opt_codec("c:v", "mpeg1video");
4085 opt_codec("c:a", "mp2");
4086 opt_format("f", "vcd");
4088 opt_frame_size("s", norm == PAL ? "352x288" : "352x240");
4089 opt_frame_rate("r", frame_rates[norm]);
4090 opt_default("g", norm == PAL ? "15" : "18");
4092 opt_default("b", "1150000");
4093 opt_default("maxrate", "1150000");
4094 opt_default("minrate", "1150000");
4095 opt_default("bufsize", "327680"); // 40*1024*8;
4097 opt_default("b:a", "224000");
4098 audio_sample_rate = 44100;
4101 opt_default("packetsize", "2324");
4102 opt_default("muxrate", "1411200"); // 2352 * 75 * 8;
4104 /* We have to offset the PTS, so that it is consistent with the SCR.
4105 SCR starts at 36000, but the first two packs contain only padding
4106 and the first pack from the other stream, respectively, may also have
4107 been written before.
4108 So the real data starts at SCR 36000+3*1200. */
4109 mux_preload= (36000+3*1200) / 90000.0; //0.44
4110 } else if(!strcmp(arg, "svcd")) {
4112 opt_codec("c:v", "mpeg2video");
4113 opt_codec("c:a", "mp2");
4114 opt_format("f", "svcd");
4116 opt_frame_size("s", norm == PAL ? "480x576" : "480x480");
4117 opt_frame_rate("r", frame_rates[norm]);
4118 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4119 opt_default("g", norm == PAL ? "15" : "18");
4121 opt_default("b", "2040000");
4122 opt_default("maxrate", "2516000");
4123 opt_default("minrate", "0"); //1145000;
4124 opt_default("bufsize", "1835008"); //224*1024*8;
4125 opt_default("flags", "+scan_offset");
4128 opt_default("b:a", "224000");
4129 audio_sample_rate = 44100;
4131 opt_default("packetsize", "2324");
4133 } else if(!strcmp(arg, "dvd")) {
4135 opt_codec("c:v", "mpeg2video");
4136 opt_codec("c:a", "ac3");
4137 opt_format("f", "dvd");
4139 opt_frame_size("vcodec", norm == PAL ? "720x576" : "720x480");
4140 opt_frame_rate("r", frame_rates[norm]);
4141 opt_frame_pix_fmt("pix_fmt", "yuv420p");
4142 opt_default("g", norm == PAL ? "15" : "18");
4144 opt_default("b", "6000000");
4145 opt_default("maxrate", "9000000");
4146 opt_default("minrate", "0"); //1500000;
4147 opt_default("bufsize", "1835008"); //224*1024*8;
4149 opt_default("packetsize", "2048"); // from www.mpucoder.com: DVD sectors contain 2048 bytes of data, this is also the size of one pack.
4150 opt_default("muxrate", "10080000"); // from mplex project: data_rate = 1260000. mux_rate = data_rate * 8
4152 opt_default("b:a", "448000");
4153 audio_sample_rate = 48000;
4155 } else if(!strncmp(arg, "dv", 2)) {
4157 opt_format("f", "dv");
4159 opt_frame_size("s", norm == PAL ? "720x576" : "720x480");
4160 opt_frame_pix_fmt("pix_fmt", !strncmp(arg, "dv50", 4) ? "yuv422p" :
4161 norm == PAL ? "yuv420p" : "yuv411p");
4162 opt_frame_rate("r", frame_rates[norm]);
4164 audio_sample_rate = 48000;
4168 fprintf(stderr, "Unknown target: %s\n", arg);
4169 return AVERROR(EINVAL);
4174 static int opt_vstats_file(const char *opt, const char *arg)
4176 av_free (vstats_filename);
4177 vstats_filename=av_strdup (arg);
4181 static int opt_vstats(const char *opt, const char *arg)
4184 time_t today2 = time(NULL);
4185 struct tm *today = localtime(&today2);
4187 snprintf(filename, sizeof(filename), "vstats_%02d%02d%02d.log", today->tm_hour, today->tm_min,
4189 return opt_vstats_file(opt, filename);
4192 static int opt_bsf(const char *opt, const char *arg)
4194 AVBitStreamFilterContext *bsfc= av_bitstream_filter_init(arg); //FIXME split name and args for filter at '='
4195 AVBitStreamFilterContext **bsfp;
4198 fprintf(stderr, "Unknown bitstream filter %s\n", arg);
4202 bsfp= *opt == 'v' ? &video_bitstream_filters :
4203 *opt == 'a' ? &audio_bitstream_filters :
4204 &subtitle_bitstream_filters;
4206 bsfp= &(*bsfp)->next;
4213 static void log_callback_null(void* ptr, int level, const char* fmt, va_list vl)
4217 static int opt_passlogfile(const char *opt, const char *arg)
4219 pass_logfilename_prefix = arg;
4220 #if CONFIG_LIBX264_ENCODER
4221 return opt_default("passlogfile", arg);
4227 static const OptionDef options[] = {
4229 #include "cmdutils_common_opts.h"
4230 { "f", HAS_ARG, {(void*)opt_format}, "force format", "fmt" },
4231 { "i", HAS_ARG, {(void*)opt_input_file}, "input file name", "filename" },
4232 { "y", OPT_BOOL, {(void*)&file_overwrite}, "overwrite output files" },
4233 { "c", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4234 { "codec", HAS_ARG, {(void*)opt_codec}, "codec name", "codec" },
4235 { "map", HAS_ARG | OPT_EXPERT, {(void*)opt_map}, "set input stream mapping", "file.stream[:syncfile.syncstream]" },
4236 { "map_meta_data", HAS_ARG | OPT_EXPERT, {(void*)opt_map_meta_data}, "DEPRECATED set meta data information of outfile from infile",
4237 "outfile[,metadata]:infile[,metadata]" },
4238 { "map_metadata", HAS_ARG | OPT_EXPERT, {(void*)opt_map_metadata}, "set metadata information of outfile from infile",
4239 "outfile[,metadata]:infile[,metadata]" },
4240 { "map_chapters", OPT_INT | HAS_ARG | OPT_EXPERT, {(void*)&chapters_input_file}, "set chapters mapping", "input_file_index" },
4241 { "t", HAS_ARG, {(void*)opt_recording_time}, "record or transcode \"duration\" seconds of audio/video", "duration" },
4242 { "fs", HAS_ARG | OPT_INT64, {(void*)&limit_filesize}, "set the limit file size in bytes", "limit_size" }, //
4243 { "ss", HAS_ARG, {(void*)opt_start_time}, "set the start time offset", "time_off" },
4244 { "itsoffset", HAS_ARG, {(void*)opt_input_ts_offset}, "set the input ts offset", "time_off" },
4245 { "itsscale", HAS_ARG, {(void*)opt_input_ts_scale}, "set the input ts scale", "scale" },
4246 { "timestamp", HAS_ARG, {(void*)opt_recording_timestamp}, "set the recording timestamp ('now' to set the current time)", "time" },
4247 { "metadata", HAS_ARG, {(void*)opt_metadata}, "add metadata", "string=string" },
4248 { "dframes", OPT_INT | HAS_ARG, {(void*)&max_frames[AVMEDIA_TYPE_DATA]}, "set the number of data frames to record", "number" },
4249 { "benchmark", OPT_BOOL | OPT_EXPERT, {(void*)&do_benchmark},
4250 "add timings for benchmarking" },
4251 { "timelimit", HAS_ARG, {(void*)opt_timelimit}, "set max runtime in seconds", "limit" },
4252 { "dump", OPT_BOOL | OPT_EXPERT, {(void*)&do_pkt_dump},
4253 "dump each input packet" },
4254 { "hex", OPT_BOOL | OPT_EXPERT, {(void*)&do_hex_dump},
4255 "when dumping packets, also dump the payload" },
4256 { "re", OPT_BOOL | OPT_EXPERT, {(void*)&rate_emu}, "read input at native frame rate", "" },
4257 { "loop_input", OPT_BOOL | OPT_EXPERT, {(void*)&loop_input}, "deprecated, use -loop" },
4258 { "loop_output", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&loop_output}, "deprecated, use -loop", "" },
4259 { "v", HAS_ARG, {(void*)opt_verbose}, "set the verbosity level", "number" },
4260 { "target", HAS_ARG, {(void*)opt_target}, "specify target file type (\"vcd\", \"svcd\", \"dvd\", \"dv\", \"dv50\", \"pal-vcd\", \"ntsc-svcd\", ...)", "type" },
4261 { "threads", HAS_ARG | OPT_EXPERT, {(void*)opt_thread_count}, "thread count", "count" },
4262 { "vsync", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&video_sync_method}, "video sync method", "" },
4263 { "async", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&audio_sync_method}, "audio sync method", "" },
4264 { "adrift_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&audio_drift_threshold}, "audio drift threshold", "threshold" },
4265 { "copyts", OPT_BOOL | OPT_EXPERT, {(void*)©_ts}, "copy timestamps" },
4266 { "copytb", OPT_BOOL | OPT_EXPERT, {(void*)©_tb}, "copy input stream time base when stream copying" },
4267 { "shortest", OPT_BOOL | OPT_EXPERT, {(void*)&opt_shortest}, "finish encoding within shortest input" }, //
4268 { "dts_delta_threshold", HAS_ARG | OPT_FLOAT | OPT_EXPERT, {(void*)&dts_delta_threshold}, "timestamp discontinuity delta threshold", "threshold" },
4269 { "programid", HAS_ARG | OPT_INT | OPT_EXPERT, {(void*)&opt_programid}, "desired program number", "" },
4270 { "xerror", OPT_BOOL, {(void*)&exit_on_error}, "exit on error", "error" },
4271 { "copyinkf", OPT_BOOL | OPT_EXPERT, {(void*)©_initial_nonkeyframes}, "copy initial non-keyframes" },
4274 { "vframes", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&max_frames[AVMEDIA_TYPE_VIDEO]}, "set the number of video frames to record", "number" },
4275 { "r", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_rate}, "set frame rate (Hz value, fraction or abbreviation)", "rate" },
4276 { "s", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_size}, "set frame size (WxH or abbreviation)", "size" },
4277 { "aspect", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_aspect_ratio}, "set aspect ratio (4:3, 16:9 or 1.3333, 1.7777)", "aspect" },
4278 { "pix_fmt", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_frame_pix_fmt}, "set pixel format, 'list' as argument shows all the pixel formats supported", "format" },
4279 { "bits_per_raw_sample", OPT_INT | HAS_ARG | OPT_VIDEO, {(void*)&frame_bits_per_raw_sample}, "set the number of bits per raw sample", "number" },
4280 { "croptop", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4281 { "cropbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4282 { "cropleft", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4283 { "cropright", HAS_ARG | OPT_VIDEO, {(void*)opt_frame_crop}, "Removed, use the crop filter instead", "size" },
4284 { "padtop", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4285 { "padbottom", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4286 { "padleft", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4287 { "padright", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "size" },
4288 { "padcolor", HAS_ARG | OPT_VIDEO, {(void*)opt_pad}, "Removed, use the pad filter instead", "color" },
4289 { "intra", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_only}, "use only intra frames"},
4290 { "vn", OPT_BOOL | OPT_VIDEO, {(void*)&video_disable}, "disable video" },
4291 { "vdt", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&video_discard}, "discard threshold", "n" },
4292 { "qscale", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_qscale}, "use fixed video quantizer scale (VBR)", "q" },
4293 { "rc_override", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_video_rc_override_string}, "rate control override for specific intervals", "override" },
4294 { "vcodec", HAS_ARG | OPT_VIDEO, {(void*)opt_video_codec}, "force video codec ('copy' to copy stream)", "codec" },
4295 { "me_threshold", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_me_threshold}, "motion estimation threshold", "threshold" },
4296 { "sameq", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4297 { "same_quant", OPT_BOOL | OPT_VIDEO, {(void*)&same_quant}, "use same quantizer as source (implies VBR)" },
4298 { "pass", HAS_ARG | OPT_VIDEO, {(void*)opt_pass}, "select the pass number (1 or 2)", "n" },
4299 { "passlogfile", HAS_ARG | OPT_VIDEO, {(void*)&opt_passlogfile}, "select two pass log file name prefix", "prefix" },
4300 { "deinterlace", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_deinterlace},
4301 "deinterlace pictures" },
4302 { "psnr", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&do_psnr}, "calculate PSNR of compressed frames" },
4303 { "vstats", OPT_EXPERT | OPT_VIDEO, {(void*)&opt_vstats}, "dump video coding statistics to file" },
4304 { "vstats_file", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_vstats_file}, "dump video coding statistics to file", "file" },
4306 { "vf", OPT_STRING | HAS_ARG, {(void*)&vfilters}, "video filters", "filter list" },
4308 { "intra_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_intra_matrix}, "specify intra matrix coeffs", "matrix" },
4309 { "inter_matrix", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_inter_matrix}, "specify inter matrix coeffs", "matrix" },
4310 { "top", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_top_field_first}, "top=1/bottom=0/auto=-1 field first", "" },
4311 { "dc", OPT_INT | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)&intra_dc_precision}, "intra_dc_precision", "precision" },
4312 { "vtag", HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void*)opt_codec_tag}, "force video tag/fourcc", "fourcc/tag" },
4313 { "vlang", HAS_ARG | OPT_STRING | OPT_VIDEO, {(void *)&video_language}, "set the ISO 639 language code (3 letters) of the current video stream" , "code" },
4314 { "qphist", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, { (void *)&qp_hist }, "show QP histogram" },
4315 { "force_fps", OPT_BOOL | OPT_EXPERT | OPT_VIDEO, {(void*)&force_fps}, "force the selected framerate, disable the best supported framerate selection" },
4316 { "streamid", HAS_ARG | OPT_EXPERT, {(void*)opt_streamid}, "set the value of an outfile streamid", "streamIndex:value" },
4317 { "force_key_frames", OPT_STRING | HAS_ARG | OPT_EXPERT | OPT_VIDEO, {(void *)&forced_key_frames}, "force key frames at specified timestamps", "timestamps" },
4320 { "aframes", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&max_frames[AVMEDIA_TYPE_AUDIO]}, "set the number of audio frames to record", "number" },
4321 { "aq", OPT_FLOAT | HAS_ARG | OPT_AUDIO, {(void*)&audio_qscale}, "set audio quality (codec-specific)", "quality", },
4322 { "ar", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_rate}, "set audio sampling rate (in Hz)", "rate" },
4323 { "ac", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_channels}, "set number of audio channels", "channels" },
4324 { "an", OPT_BOOL | OPT_AUDIO, {(void*)&audio_disable}, "disable audio" },
4325 { "acodec", HAS_ARG | OPT_AUDIO, {(void*)opt_audio_codec}, "force audio codec ('copy' to copy stream)", "codec" },
4326 { "atag", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_codec_tag}, "force audio tag/fourcc", "fourcc/tag" },
4327 { "vol", OPT_INT | HAS_ARG | OPT_AUDIO, {(void*)&audio_volume}, "change audio volume (256=normal)" , "volume" }, //
4328 { "alang", HAS_ARG | OPT_STRING | OPT_AUDIO, {(void *)&audio_language}, "set the ISO 639 language code (3 letters) of the current audio stream" , "code" },
4329 { "sample_fmt", HAS_ARG | OPT_EXPERT | OPT_AUDIO, {(void*)opt_audio_sample_fmt}, "set sample format, 'list' as argument shows all the sample formats supported", "format" },
4331 /* subtitle options */
4332 { "sn", OPT_BOOL | OPT_SUBTITLE, {(void*)&subtitle_disable}, "disable subtitle" },
4333 { "scodec", HAS_ARG | OPT_SUBTITLE, {(void*)opt_subtitle_codec}, "force subtitle codec ('copy' to copy stream)", "codec" },
4334 { "slang", HAS_ARG | OPT_STRING | OPT_SUBTITLE, {(void *)&subtitle_language}, "set the ISO 639 language code (3 letters) of the current subtitle stream" , "code" },
4335 { "stag", HAS_ARG | OPT_EXPERT | OPT_SUBTITLE, {(void*)opt_codec_tag}, "force subtitle tag/fourcc", "fourcc/tag" },
4338 { "vc", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_channel}, "deprecated, use -channel", "channel" },
4339 { "tvstd", HAS_ARG | OPT_EXPERT | OPT_VIDEO | OPT_GRAB, {(void*)opt_video_standard}, "deprecated, use -standard", "standard" },
4340 { "isync", OPT_BOOL | OPT_EXPERT | OPT_GRAB, {(void*)&input_sync}, "sync read on input", "" },
4343 { "muxdelay", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_max_delay}, "set the maximum demux-decode delay", "seconds" },
4344 { "muxpreload", OPT_FLOAT | HAS_ARG | OPT_EXPERT, {(void*)&mux_preload}, "set the initial demux-decode delay", "seconds" },
4346 { "absf", HAS_ARG | OPT_AUDIO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4347 { "vbsf", HAS_ARG | OPT_VIDEO | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4348 { "sbsf", HAS_ARG | OPT_SUBTITLE | OPT_EXPERT, {(void*)opt_bsf}, "", "bitstream_filter" },
4350 /* data codec support */
4351 { "dcodec", HAS_ARG | OPT_DATA, {(void*)opt_data_codec}, "force data codec ('copy' to copy stream)", "codec" },
4353 { "default", HAS_ARG | OPT_AUDIO | OPT_VIDEO | OPT_EXPERT, {(void*)opt_default}, "generic catch all option", "" },
4357 int main(int argc, char **argv)
4361 av_log_set_flags(AV_LOG_SKIP_REPEATED);
4363 if(argc>1 && !strcmp(argv[1], "-d")){
4366 av_log_set_callback(log_callback_null);
4371 avcodec_register_all();
4373 avdevice_register_all();
4376 avfilter_register_all();
4381 if(isatty(STDIN_FILENO))
4382 avio_set_interrupt_cb(decode_interrupt_cb);
4391 parse_options(argc, argv, options, opt_output_file);
4393 if(nb_output_files <= 0 && nb_input_files == 0) {
4395 fprintf(stderr, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4399 /* file converter / grab */
4400 if (nb_output_files <= 0) {
4401 fprintf(stderr, "At least one output file must be specified\n");
4405 if (nb_input_files == 0) {
4406 fprintf(stderr, "At least one input file must be specified\n");
4411 if (transcode(output_files, nb_output_files, input_files, nb_input_files) < 0)
4413 ti = getutime() - ti;
4415 int maxrss = getmaxrss() / 1024;
4416 printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
4419 return exit_program(0);